tabletop 0.2.1 → 0.3.0

data/lib/tabletop/token.rb

@@ -1,50 +1,88 @@
 module Tabletop
   
   class NotEnoughTokensError < ArgumentError
+    def initialize(wanted, available)
+      w_t, a_t = "token", "token"
+      
+      w_t << "s" if wanted > 1 or wanted == 0
+      
+      a_t << "s" if available > 1 or available == 0
+      
+      available = available > 0 ? available : "no"
+      
+      super("tried to remove #{wanted} #{w_t} from a stack with #{available} #{a_t}")
+    end
+  end
+  
+  class ExceedMaxTokensError < ArgumentError
   end
   
   class TokenStack
     
-    # The number of tokens in the Stack
-    attr_accessor :count
+    # The number of tokens in the stack, and the maximum number it can have
+    attr_accessor :count, :max
     include Comparable
     
-    def initialize(num_tokens = 1)
+    def initialize(num_tokens = 1, hash={})
       @count = num_tokens
+      @max = hash[:max]
     end
     
     def <=>(operand)
         count <=> operand.to_int
     end
     
+    def count=(new_value)
+      raise_if_over_max(new_value)
+      @count = new_value
+    end
+    
     def add(n = 1)
-      raise ArgumentError unless n.instance_of?(Fixnum) and n > 0
+      raise ArgumentError unless n.respond_to?(:to_i)
+      raise ArgumentError if n < 0
+      n = n.to_i
+      raise_if_over_max(n + @count)
       @count += n
     end
     
+    def raise_if_over_max(value)
+      if @max
+        raise ExceedMaxTokensError if value > @max
+      end 
+    end
+    
     # Raises NotEnoughTokensError if there aren't enough tokens to remove 
     def remove(n=1)
-      raise ArgumentError unless n.instance_of?(Fixnum) and n > 0
+      raise ArgumentError unless n.respond_to?(:to_i)
+      n = n.to_i
+      raise ArgumentError if n < 0
       if n > @count
-        n_t, c_t = "token", "token"
-        
-        n_t << "s" if n > 1 or n == 0
-        
-        c_t << "s" if @count > 1 or @count == 0
-        
-        c = @count > 0 ? @count : "no" 
-        errmsg = "tried to remove #{n} #{n_t} from a stack with #{c} #{c_t}"
-        raise NotEnoughTokensError, errmsg
+        raise NotEnoughTokensError.new(n, @count)
       end
       @count -= n
     end
     
-    # Removes N tokens from the receiver stack, then 
-    # adds them to the stack in opts[:to] 
+    # Usage: stack_a.move(N, :to => stack_b)
+    # Removes N tokens from stack_a, and adds 
+    # the same number to stack_b 
     def move(n, opts)
-      raise(ArgumentError, "target is #{opts[:to].class}, not TokenStack") unless opts[:to].instance_of?(TokenStack)
-      remove(n)
-      opts[:to].add(n)
+      begin
+        opts[:to].add(n)
+      rescue NoMethodError
+        raise ArgumentError
+      end
+      
+      begin
+        remove(n)
+      rescue NotEnoughTokensError
+        opts[:to].remove(n)
+        raise
+      end
+    end
+    
+    def refresh
+      raise NoMethodError if @max.nil?
+      @count = @max
     end
   end
 end

data/lib/tabletop/version.rb

@@ -1,3 +1,3 @@
 module Tabletop
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/tabletop.rb

@@ -3,3 +3,4 @@ require_relative 'tabletop/randomizers'
 require_relative 'tabletop/pool'
 require_relative 'tabletop/roll'
 require_relative 'tabletop/token'
+require_relative 'tabletop/condition'

data/spec/condition_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Tabletop
+  describe Condition do
+    describe "#met_by?" do
+      it "it evaluates the block passed on initialization" do
+        c = Condition.new do |p|
+          p.sum > 7
+        end
+        c.met_by?(Pool.new("2/6 4/10")).should be_false
+        c.met_by?(Pool.new("4/8 4/12")).should be_true
+      end
+    end
+  end
+end

data/spec/fixnum_spec.rb

@@ -9,6 +9,10 @@ module Tabletop
         10.d100.should be_instance_of(Pool)
       end
       
+      it "raises an exception for invalid method names" do
+        expect {10.dthing}.to raise_error(NoMethodError)
+      end
+      
       it "shows up in respond_to?(:dN)" do
         1.should respond_to(:d50)
         10.should_not respond_to(:dthing)

data/spec/pool_spec.rb

@@ -2,121 +2,165 @@ require 'spec_helper'
 
 module Tabletop
   describe Pool do
-    before :each do
-      Random.srand(10)
-      @d6 = Pool.new("d6")
-      @d17s = Pool.new("5d17")
-      @mixed = Pool.new("2d10 d20") 
-      @fudge = Pool.new("3dF")
+
+    let(:d6_set) { Pool.new("2/6 1/6 3/6 4/6 5/6 6/6") }
+    
+    describe ".new" do
+      it "can accept a string of d-notation" do
+        p = Pool.new("2d10 d20")
+        p.length.should == 3
+        p[0].sides.should == 10
+        p[1].sides.should == 10
+        p[2].sides.should == 20
+      end
+      it "can accept an array of dice objects" do
+        # mostly used internally
+        p = Pool.new([Die.new(value: 1), Die.new(sides: 4)])
+        p.length.should == 2
+        p[0].sides.should == 6
+        p[0].value.should == 1
+        p[1].sides.should == 4
+      end
+      it "can accept a string describing a specific dice configuration" do
+        pool = Pool.new("1/4 2/6 3/8")
+        pool.length.should == 3
+        pool[0].value.should == 1
+        pool[0].sides.should == 4
+        pool[1].value.should == 2
+        pool[1].sides.should == 6
+        pool[2].value.should == 3
+        pool[2].sides.should == 8
+      end
     end
     
     describe "#dice" do
       it "should return an array of dice notation" do
-        @mixed.dice.should == ["2d10","d20"]
-        @d6.dice.should == ["d6"]
-        @d17s.dice.should == ["5d17"]
-        @fudge.dice.should == ["3dF"]
         Pool.new("d20 2dF 2d10").dice.should == ["2d10","d20", "2dF"]
       end
     end
     
     describe "[]" do
-      it "should access Die objects" do
-        @d6[0].should be_instance_of(Die)
-        @fudge[0].should be_instance_of(FudgeDie)
+      it "should access the objects " do
+        d = Pool.new("1/4")[0]
+        d.value.should == 1
+        d.sides.should == 4
       end
     end
     
     describe "+" do
-      it "should join Pools into new Pools" do
-        (@mixed + @d17s).should be_instance_of(Pool)
-        (@d6 + @fudge).should be_instance_of(Pool)
-      end
-      
-      it "should persist die types" do
-        (@d6 + @fudge)[1].should be_instance_of(FudgeDie)
-      end
-      
-      it "should join pools without rolling them" do
-        merge = @d6 + @d17s
-        merge.values.should == [2, 5, 16, 1, 17, 9]
-        merge.roll
-        merge.values.should == [4, 17, 5, 16, 12, 12]
-      end
-      
-      it "creates genuinely new pools" do
-        merge = @d6 + @d17s
-        merge.roll
-        @d6.values.should == [2]
-        @d17s.values.should == [5, 16, 1, 17, 9]
+      before(:each) do
+        @a = 5.d6
       end
-      
-      it "should alter #dice accordingly" do
-        @d6 = Pool.new("d6")
-        @d17s = Pool.new("5d17")
-        @mixed = Pool.new("2d10 d20")
-        (@d6 + @d17s).dice.should == ["d6", "5d17"]
-        (@d17s + @d6).dice.should == ["d6", "5d17"]
-        (@d17s + @mixed).dice.should == ["2d10","5d17","d20"]
-        (@mixed + @fudge).dice.should == ["2d10", "d20", "3dF"]
+      context "adding a number" do
+        it "should return the pool's sum plus the number" do
+          (@a + 5).should == @a.sum + 5
+        end
       end
-      
-      it "should understand adding a number as looking for a sum result" do
-        (@d17s + 5).should == 53
-        (@mixed + @d6 + 10).should == 34
-        (@fudge + 3).should == 2
+      context "adding a randomizer" do
+        it "adds to the pool" do
+          mixed = @a + Die.new
+          mixed.length.should == 6
+        end
+        it "preserves class" do
+          (@a + FudgeDie.new(value:-1))[-1].value.should == -1
+          (@a + Coin.new)[-1].should respond_to :flip
+        end
       end
-      
-      it "should add literal dice arrays as if they were pools" do
-        g = @d6 + [Die.new(6,3), Die.new(10, 4)]
-        g.values.should == [2, 3, 4]
-        g.dice.should == ["2d6", "d10"]
-        g.roll
-        @d6.values.should == [2]
+      context "adding another pool" do
+        before(:each) do
+          @b = 4.d4
+          @merge = @a+@b
+        end
+        it "should make a union of the pools" do
+          @merge.values.should == @a.values + @b.values
+        end
+        it "should make new die objects" do
+          @merge.roll
+          @merge.values.should_not == @a.values + @b.values
+        end
+        it "should persist die types" do
+          (Pool.new("d6")+Pool.new("dF"))[1].should be_instance_of(FudgeDie)
+          (Pool.new("d6")+Pool.new([Coin.new]))[1].should respond_to(:flip)
+        end
+        it "should alter #dice accordingly" do
+          (Pool.new("2d17 d6")+Pool.new("3d17")).dice.should == ["d6", "5d17"]
+        end
       end
-      
-      it "should reject adding anything else" do
-        expect {@d6 + "foof"}.to raise_error(ArgumentError)
-        expect {@d6 + [Die.new, Object.new]}.to raise_error(ArgumentError)
+      context "adding anything else" do
+        it "should raise an exception" do
+          expect {Pool.new("d6") + "foof"}.to raise_error(ArgumentError)
+          expect {Pool.new("d6") + [Die.new, Object.new]}.to raise_error(ArgumentError)
+        end
       end
     end
     
     describe "*" do
       it "should multiply by the sum of the pool" do
         (1..10).each do |v|
-          p = Pool.new([Die.new(10, v)])
+          p = Pool.new("#{v}/10")
           (p * 5).should == (v * 5)
           (5 * p).should == (5 * v)
         end
       end
     end
+
+    describe "-" do
+      context "subtracting a number" do
+        it "should return the pool's sum minus the number" do
+          (d6_set - 1).should == 20
+        end
+      end
+    end
     
     describe "#values" do
-      it "should be an array of random numbers" do
-        @d6.values.should == [2]
-        @d17s.values.should == [5, 16, 1, 17, 9]
-        @mixed.values.should == [10, 1, 11]
+      it "should be an array of the values of the dice" do
+        d6_set.values.each_with_index do |v, i|
+          v.should == d6_set[i].value
+        end
       end
     end
     
     describe "#roll" do
       it "should return the Pool itself" do
-        @d6.roll.length.should == @d6.length
-        @d6.roll.should be_instance_of(Pool)
+        actual = d6_set.roll
+        d6_set.length.times do |i|
+          actual[i].value.should == d6_set[i].value
+          actual[i].sides.should == d6_set[i].sides
+        end
       end
       
-      it "should store the new values" do
-        @d6.roll
-        @d6.values.should == [4]
-        @d17s.roll
-        @d17s.values.should == [17, 5, 16, 12, 12]
-        @mixed.roll
-        @mixed.values.should == [2, 9, 5]
+      it "calls roll on its contents" do
+        d = double("a die")
+        d.should_receive(:roll)
+        Pool.new([d]).roll
       end
       it "can roll only dice below a certain value"
       it "can roll only dice above a certain value"
       it "can roll only dice equal to a certain value"
     end
+
+    describe "#roll_if" do
+      before :each do
+        @d1 = double("a die")
+        @d2 = double("a die")
+      end
+      it "rolls dice when the block returns true" do
+        @d1.should_receive(:roll)
+        Pool.new([@d1]).roll_if {|die| true}
+      end
+      it "doesn't roll dice when the block returns false" do
+        @d1.should_not_receive(:roll)
+        Pool.new([@d1]).roll_if {|die| false}
+      end
+      it "rolls dice that satisfy the block condition" do
+        @d1.stub(:sides).and_return(3)
+        @d2.stub(:sides).and_return(4)
+
+        @d1.should_not_receive(:roll)
+        @d2.should_receive(:roll)
+        Pool.new([@d1, @d2]).roll_if {|die| die.sides > 3}
+      end
+    end
     
     describe "#sum" do
       it "should sum the dice values" do
@@ -136,94 +180,74 @@ module Tabletop
     
     describe "<=>" do
       it "should compare the sums of different pools" do
-        @d17s.should >= @d6
-        @d6.should < Pool.new([Die.new(4, 4)])
+        Pool.new("1/4 1/4").should == Pool.new("2/6")
+        Pool.new("10/10").should == Pool.new("10/50")
+        Pool.new("3/6").should < Pool.new("4/4")
       end
       
       it "should compare pools to numbers" do
-        @d6.should < 10
-        @d6.should == 2
-        @d17s.should <= 49
+        Pool.new("4/8 5/10").should < 10
+        Pool.new("1/6 1/8").should == 2
+        Pool.new("49/50").should <= 49
       end
     end
     
     describe "#sets" do
-      it "should list the sets, in order by height and width" do
-        ore = Pool.new("10d10")
-        ore.sets.should == ["2x9", "2x5", "2x4", "2x2", "1x7", "1x1"]
-        ore.roll
-        ore.sets.should == ["3x10", "2x7", "1x6", "1x5", "1x4", "1x3", "1x2"]
-        ore.roll
-        ore.sets.should == ["3x9", "2x8", "2x7", "1x10", "1x3", "1x1"]
+      it "should group dice in sets, by order of height, then width" do
+        Pool.new("9/10 1/10 5/10 4/10 9/10 5/10 7/10 4/10").sets.should == ["2x9", "2x5", "2x4", "1x7", "1x1"]
       end
     end
     
     describe "#highest" do
       it "should return a pool of the highest-value die" do
-        @d6.highest.should be_instance_of(Pool)
-        @d6.highest.values.should == [2]
-        @d17s.highest.values.should == [17]
-        @mixed.highest.values.should == [11]
+        d6_set.highest.values.should == [6]
       end
       
       it "should return as many items as are specified" do
-        @d6.highest(5).values.should == [2]
-        @d17s.highest(3).values.should == [17, 16, 9]
-        @mixed.highest(2).values.should == [11, 10]
+        d6_set.highest(3).values.should == [4,5,6]
+        d6_set.highest(10).values.should == [2,1,3,4,5,6]
       end
     end
     
     describe "#lowest" do
       it "should return a pool of the lowest-value die." do
-        @d6.lowest.values.should == [2]
-        @d17s.lowest.should be_instance_of(Pool)
-        @d17s.lowest.values.should == [1]
-        @mixed.lowest.values.should == [1]
+        d6_set.lowest.values.should == [1]
       end
       
       it "should return as many items as are specified" do
-          @d6.lowest(5).values.should == [2]
-          @d17s.lowest(3).values.should == [1, 5, 9]
-          @mixed.lowest(2).values.should == [1, 10]
+        d6_set.lowest(3).values.should == [2,1,3]
+        d6_set.lowest(10).values.should == [2,1,3,4,5,6]
       end
     end
     
     describe "#drop_highest" do
       it "should return a new pool missing the highest result" do
-        p = @d17s.drop_highest
-        p.values.should == [5, 16, 1, 9]
-        @d17s.values.should == [5, 16, 1, 17, 9]
+        d6_set.drop_highest.values.should == [2,1,3,4,5]
       end
       
       it "should drop as many items as are specified and are possible" do
-        p = @d17s.drop_highest(2)
-        p.values.should == [5, 1, 9]
-        p = @d6.drop_highest(10)
-        p.values.should == []
+        d6_set.drop_highest(3).values.should == [2,1,3]
+        d6_set.drop_highest(10).values.should == []
       end
     end
 
     describe "#drop_lowest" do
       it "should return a pool missing the lowest result" do
-        p = @d17s.drop_lowest
-        p.values.should == [5, 16, 17, 9]
-        @d17s.values.should == [5, 16, 1, 17, 9]
+        d6_set.drop_lowest.values.should == [2, 3, 4, 5, 6]
       end
       
-      it "should drop as many items as are specified" do
-        p = @d17s.drop_lowest(2)
-        p.values.should == [16, 17, 9]
+      it "should drop as many items as are specified and are possible" do
+        d6_set.drop_lowest(2).values.should == [3,4,5,6]
+        d6_set.drop_lowest(10).values.should == []
       end
     end
 
     describe "#drop" do
       it "should drop any dice of the specified value" do
         ore = Pool.new("10d10")
-        ore.values.should == [4, 1, 5, 7, 9, 2, 9, 5, 2, 4]
-        at_least_two = ore.drop(1)
-        at_least_two.values.should == [4, 5, 7, 9, 2, 9, 5, 2, 4]
-        at_least_three = ore.drop([1,2])
-        at_least_three.values.should == [4, 5, 7, 9, 9, 5, 4]
+        (10..1).each do |i|
+          ore.drop(i).should_not include(i)
+        end
       end
     end