nairda-roleplay 0.1.1

data/README.md

@@ -0,0 +1,16 @@
+Roleplay
+========
+
+Ever wanted to write some old school, kick-ass role-playing stuff in Ruby, but
+never had enough support for doing it? Well, now you can!
+
+Roleplay is a set of libraries helpful in wide variety of RPG development. In
+the current state it contains:
+
+* DSL for creating complex dice rolls (e.g. `13.d8 * 6 - 10.d20 + 2`). See
+  Roleplay::Roll for more.
+
+COPYRIGHT
+---------
+
+Copyright 2009 Adrian Pacała. See LICENSE for details.

data/VERSION.yml

@@ -0,0 +1,4 @@
+---
+:major: 0
+:minor: 1
+:patch: 1

data/lib/roleplay.rb

@@ -0,0 +1,3 @@
+require 'roleplay/core_ext'
+require 'roleplay/error'
+require 'roleplay/roll'

data/lib/roleplay/core_ext.rb

@@ -0,0 +1,3 @@
+Dir[File.dirname(__FILE__) + '/core_ext/**/*.rb'].sort.each do |path|
+  require path
+end

data/lib/roleplay/core_ext/enumerable.rb

@@ -0,0 +1,9 @@
+module Enumerable
+  ##
+  # Calculates sum of the collection.
+  #
+  # @return Object class depending on type of stored elements
+  def sum
+    inject(nil) { |sum, x| sum ? sum + x : x }
+  end
+end

data/lib/roleplay/core_ext/float.rb

@@ -0,0 +1,25 @@
+class Float
+  ##
+  # Rounds self to given number of decimal places.
+  #
+  # @param [Fixnum] n places to round to
+  def round_to(n)
+    (self * 10 ** n).round.to_f / 10 ** n
+  end
+
+  ##
+  # Rounds down self to given number of decimal places.
+  #
+  # @param [Fixnum] n places to ceil to
+  def ceil_to(n)
+    (self * 10 ** n).ceil.to_f / 10 ** n
+  end
+
+  ##
+  # Rounds up self to given number of decimal places.
+  #
+  # @param [Fixnum] n places to floor to
+  def floor_to(n)
+    (self * 10 ** n).floor.to_f / 10 ** n
+  end
+end

data/lib/roleplay/core_ext/kernel.rb

@@ -0,0 +1,22 @@
+require 'inline'
+
+module Kernel
+  inline do |builder|
+    builder.add_to_init 'srand(time(NULL));'
+    builder.c %{
+      VALUE random_list(int length, int minimum, int maximum)
+      {
+          int i;
+          int range = 1 + maximum - minimum;
+          VALUE list = rb_ary_new2(length);
+
+          for (i = 0; i < length; i++)
+          {
+              rb_ary_store(list, i, INT2NUM((rand() % range) + minimum));
+          }
+
+          return list;
+      }
+    }
+  end
+end

data/lib/roleplay/error.rb

@@ -0,0 +1,4 @@
+module Roleplay
+  class Error < RuntimeError
+  end
+end

data/lib/roleplay/roll.rb

@@ -0,0 +1,119 @@
+module Roleplay
+  # Class for generating dice rolls, sprinkled with small DSL.
+  class Roll
+    class InvalidOperatorError < Error
+    end
+
+    # List of valid modifier operators.
+    OPERATORS = [:+, :-, :*, :/, :%, :**].freeze
+
+    # Number of dice to be rolled.
+    attr_accessor :count
+
+    # Type of die to be used in this particular roll.
+    attr_accessor :die
+
+    # Modifier chain.
+    attr_reader :modifiers
+
+    ##
+    # Creates new Roll instance.
+    #
+    # @param [Fixnum] count number of dice to be rolled
+    # @param [Fixnum] die type of die to be used
+    # @raise ArgumentError if given +count+ is a negative number
+    # @raise ArgumentError if given +die+ is a negative number
+    def initialize(count, die)
+      raise ArgumentError, "dice count can't be negative" if count < 0
+      raise ArgumentError, "die type can't be negative" if die < 0
+      @count = count
+      @die = die
+      @modifiers = []
+    end
+
+    ##
+    # Adds new modifier at the end of the current stack.
+    #
+    # @param [Symbol, String] operator modifier operator
+    # @param [Roll, Fixnum] value modifier value
+    # @return [Roll] self
+    # @raise InvalidOperatorError if given operator is not available for
+    #   applying to the roll
+    def push_modifier(operator, value)
+      raise InvalidOperatorError unless
+        OPERATORS.include?(operator.to_sym)
+      @modifiers << [operator, value]
+      self
+    end
+
+    ##
+    # Applies all modifiers to given value.
+    #
+    # @param [Fixnum] base value to apply the modifiers to
+    # @param [Symbol, String] method name of the method to call on each
+    #   modifying value before applying it to +base+
+    # @return [Fixnum] result of the calculation
+    def apply_modifiers(base, method)
+      method = method.to_sym
+
+      @modifiers.each do |mod|
+        value = mod[1].respond_to?(method) ? mod[1].send(method) : mod[1].to_i
+        base  = base.send(mod[0], value)
+      end
+
+      base
+    end
+
+    ##
+    # Returns the lowest possible value of current roll (with modifiers).
+    #
+    # @return [Fixnum]
+    def minimum
+      apply_modifiers(@count, :minimum)
+    end
+
+    alias_method :min, :minimum
+
+    ##
+    # Returns the highest possible value of current roll (with modifiers).
+    #
+    # @return [Fixnum]
+    def maximum
+      apply_modifiers(@count * @die, :maximum)
+    end
+
+    alias_method :max, :maximum
+
+    ##
+    # Executes current roll and returns the result with applied modifiers.
+    #
+    # @yieldparam [Fixnum] result result of each die roll without modifiers
+    # @return [Fixnum] total result of the roll
+    def generate(&block)
+      results = random_list(@count, 1, @die).sum
+      results.each { |results| yield(results) } if block_given?
+      apply_modifiers(results, :generate)
+    end
+
+    private
+
+    ##
+    # This allows us to do the crazy DSL stuff.
+    #
+    # @raise NoMethodError if the missing method is not recognized as a valid
+    #   modifier operator
+    # @see push_modifier
+    def method_missing(method, *args)
+      push_modifier(method, args[0])
+    rescue InvalidOperatorError
+      raise NoMethodError, method.to_s
+    end
+  end
+end
+
+class Integer
+  # More DSL magic!
+  [2, 3, 4, 6, 8, 10, 12, 20, 100].each do |sides|
+    define_method("d#{sides}") { Roleplay::Roll.new(self, sides) }
+  end
+end

data/test/roleplay/core_ext/enumerable_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class EnumerableTest < Test::Unit::TestCase
+  should 'sum numeric values' do
+    assert_equal 6, [1, 2, 3].sum
+  end
+
+  should 'sum text values' do
+    assert_equal 'abc', %w(a b c).sum
+  end
+end

data/test/roleplay/core_ext/float_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class FloatTest < Test::Unit::TestCase
+  should 'round to specified decimal places' do
+    assert_equal 9.1, 9.11.round_to(1)
+    assert_equal 12.346, 12.34567.round_to(3)
+  end
+
+  should 'ceil to specified decimal places' do
+    assert_equal 9.2, 9.11.ceil_to(1)
+    assert_equal 12.346, 12.34567.ceil_to(3)
+  end
+
+  should 'floor to specified decimal places' do
+    assert_equal 9.1, 9.11.floor_to(1)
+    assert_equal 12.345, 12.34567.floor_to(3)
+  end
+end

data/test/roleplay/core_ext/kernel_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class KernelTest < Test::Unit::TestCase
+  should 'generate list of random values' do
+    values = random_list(10, 1, 100)
+    assert_instance_of Array, values
+    assert_equal 10, values.length
+    values.each { |value| assert value >= 1 && value <= 100 }
+  end
+end

data/test/roleplay/roll_test.rb

@@ -0,0 +1,138 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RollTest < Test::Unit::TestCase
+  include Roleplay
+
+  should 'properly alias methods' do
+    roll = Roll.new(1, 6)
+    assert_equal roll.minimum, roll.min
+    assert_equal roll.maximum, roll.max
+  end
+
+  context 'instantiation' do
+    should 'raise error on negative number of roll' do
+      assert_raise(ArgumentError) { Roll.new(-1, 6) }
+    end
+
+    should 'raise error on negative roll type' do
+      assert_raise(ArgumentError) { Roll.new(1, -6) }
+    end
+
+    should 'create a roll without modifiers' do
+      roll = Roll.new(3, 6)
+      assert roll
+      assert_equal 3, roll.count
+      assert_equal 6, roll.die
+    end
+
+    should 'create a roll with numeric modifiers' do
+      roll = Roll.new(5, 20)
+      roll * (3 + 4)
+      roll - 10
+      assert_equal 5, roll.count
+      assert_equal 20, roll.die
+      assert_equal [[:*, 7], [:-, 10]], roll.modifiers
+    end
+  end
+
+  context 'modifiers' do
+    should 'raise error on invalid modifier' do
+      roll = Roll.new(1, 6)
+
+      assert_raise(Roll::InvalidOperatorError) do
+        roll.push_modifier(:bad, 'modifier')
+      end
+    end
+
+    context 'stack' do
+      setup { @roll = Roll.new(1, 12) }
+
+      should 'append numeric modifiers' do
+        @roll.push_modifier :+, 1
+        @roll.push_modifier :/, (2 + 3)
+        @roll.push_modifier :*, ((4 * 5) - 6)
+        assert_equal [[:+, 1], [:/, 5], [:*, 14]], @roll.modifiers
+      end
+
+      should 'append roll modifiers' do
+        another_roll = Roll.new(5, 6)
+        @roll.push_modifier :+, another_roll
+        assert_equal :+, @roll.modifiers[0][0]
+        assert_instance_of Roll, @roll.modifiers[0][1]
+      end
+    end
+  end
+
+  context 'minimum and maximum values of a roll' do
+    should 'without any modifiers' do
+      roll = Roll.new(5, 10)
+      assert_equal 5, roll.minimum
+      assert_equal 50, roll.maximum
+    end
+
+    should 'with numeric modifiers' do
+      roll = Roll.new(5, 10)
+      roll * ((12 + 24) / 3)
+      roll + 7
+      assert_equal 67, roll.minimum
+      assert_equal 607, roll.maximum
+    end
+
+    should 'with roll modifiers' do
+      roll = Roll.new(5, 10)
+      roll * Roll.new(1, 12)
+      roll - Roll.new(5, 6)
+      assert_equal 0, roll.minimum
+      assert_equal 570, roll.maximum
+    end
+  end
+
+  context 'result generation' do
+    should 'roll not using any modifiers' do
+      roll = Roll.new(3, 6)
+      result = roll.generate
+      assert result >= roll.minimum && result <= roll.maximum
+    end
+
+    should 'roll using numeric modifiers' do
+      roll = Roll.new(3, 6)
+      roll * 3
+      roll + 7
+      result = roll.generate
+      assert result >= roll.minimum && result <= roll.maximum
+    end
+
+    should 'roll using roll modifiers' do
+      roll = Roll.new(3, 6)
+      roll * Roll.new(1, 20)
+      roll + Roll.new(3, 12)
+      result = roll.generate
+      assert result >= roll.minimum && result <= roll.maximum
+    end
+  end
+
+  context 'DSL' do
+    context 'instantiation' do
+      should 'define integer methods for creating rolls' do
+        [2, 3, 4, 6, 8, 10, 12, 20, 100].each do |die|
+          assert_respond_to 1, "d#{die}"
+        end
+      end
+
+      should 'create roll with numeric modifiers' do
+        roll = 3.d6 * 3 - 5
+        assert_instance_of Roll, roll
+        assert_equal [[:*, 3], [:-, 5]], roll.modifiers
+        assert_equal 4, roll.minimum
+        assert_equal 49, roll.maximum
+      end
+
+      should 'create roll with other roll as modifier' do
+        roll = 3.d6 - 1 + 2.d10 * 2
+        assert_instance_of Roll, roll
+        assert_equal 6, roll.minimum
+        assert_equal 57, roll.maximum
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'roleplay'

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: nairda-roleplay
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- "Adrian Paca\xC5\x82a"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-28 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: RubyInline
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.8"
+    version: 
+description: Roleplay
+email: adrian@zenbe.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- VERSION.yml
+- lib/roleplay
+- lib/roleplay/core_ext
+- lib/roleplay/core_ext/enumerable.rb
+- lib/roleplay/core_ext/float.rb
+- lib/roleplay/core_ext/kernel.rb
+- lib/roleplay/core_ext.rb
+- lib/roleplay/error.rb
+- lib/roleplay/roll.rb
+- lib/roleplay.rb
+- test/roleplay
+- test/roleplay/core_ext
+- test/roleplay/core_ext/enumerable_test.rb
+- test/roleplay/core_ext/float_test.rb
+- test/roleplay/core_ext/kernel_test.rb
+- test/roleplay/roll_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/nairda/roleplay
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Roleplay
+test_files: []
+