tabletop 0.0.1 → 0.1.0

data/.gitignore

@@ -1,3 +1,4 @@
 Gemfile.lock
 .DS_Store
-pkg/
+pkg/
+*.gem

data/README.markdown

@@ -2,41 +2,141 @@
 
 Tabletop aims to provide a simple way of describing, automating and tracking the tools and tasks involved in "analog" games, determining results from the motions and properties of various dice and chips.
 
-Currently, you can roll dice with it.
+Currently, you can create pools of dice, and rolls that compare them to different possible results.
 
 ## Installation
 
     gem install tabletop
+    
+    require 'tabletop'
 
-## Usage
+## Dice
 
-Just `require 'tabletop'` and off you go!  The easiest way to create a pool of dice is exactly the way you'd expect.
+Dice are pretty straightforward.  They've got a number of sides, set on instantiation (defaulting to 6), and a current value between that number and 1 inclusive, which can be set on instantiation, or directly. They can be rolled, which gives them a new random value.
 
-    3.d6           #=> [3 (d6), 3 (d6), 4 (d6)]
-    2.d10 + 1.d8   #=> [2 (d10), 6 (d10), 8 (d8)]
-    6.d17          #=> [8 (d17), 3 (d17), 7 (d17), 16 (d17), 11 (d17), 10 (d17)]
+    d6 = Die.new
+    d6.sides     #=> 6
+    d6.value     #=> 4
+    d6.roll
+    d6.value     #=> 2
+    
+    d8 = Die.new(8, 4)
+    d8.sides     #=> 8
+    d8.to_s      #=> "[3]/d8"
     
-Pools are arrays of Dice objects that have a few nice extra functions.
+One fun special kind of die is a "Fudge Die".  They are a special kind of three-sided die that have three possible values: -1, 0, or 1.  Those are usually expressed as '-', ' ' and '+', though. 
+
+    f = FudgeDie.new
+    f.sides      #=> 3
+    f.value      #=> 0
+    f.to_s       #=> "[ ]"
+
+### Pools
+
+Pools are essentially arrays of Dice objects with some extra helpful methods.
 
-    d&d_strength = 3.d6.roll.sum #=> 13
-    ore_character = 10.d10.sets #=> ["3x2", "2x8", "1x7", "1x6", "1x4", "1x3", "1x1"]
-    cortex_result = (1.d8 + 2.d6 + 1.d4).highest(2).sum  #=> 9
+The _best_ way to create one is exactly the way you'd expect: the same old d-notation we've been using for decades.  You can even combine them with `+`.
+
+    3.d6           #=> [[3]/d6, [3]/d6, [4]/d6]
+    2.d10 + 1.d8   #=> [[2]/d10, [6]/d10, [8]/d8]
     
-Dice are pretty straightforward.
+You can also create them by passing Pool.new a literal array of dice, or (slightly more interesting) a string in die notation.
+
+The methods are common operations you might do on a pool of dice: summing, counting sets, dropping the lowest or highest valued dice, dropping all _but_ the lowest or highest valued dice, even dropping any dice  a specified list of values. 
 
-    d = Die.new
-    d.sides     #=> 6
-    d.result    #=> 4
-    d.roll      #=> "2 (d6)"
+    d&d = 3.d6.sum    #=> 13
+    ore = 10.d10.sets #=> ["3x2", "2x8", "1x7", "1x6", "1x4", "1x3", "1x1"]
+    cortex = (1.d8 + 2.d6).drop([1]).highest(2).sum  #=> 9
+    tsoy = (4.dF).drop_lowest.sum  #=> 2
 
-## Note on Patches/Pull Requests
+You can also #roll an entire pool, or you can interact with individual dice in the array using array indices (`[]`).
+  
+When pools are compared to each other or to numbers with <=>, it's assumed you're actually interested in their sum.  The same thing happens if you try to add a number to them.
+
+    d&d_alt = 4.d4 + 4   #=> 17
+    1.d20 > 2.d10        #=> false
+    
+### Rolls
+
+Rolls are very much under construction, but they allow you to automate randomly determining results in a variety of ways.
+
+Rolls have a lot of options.  Let's start by taking an example from one of my favorite games, Apocalypse World.
+
+>When you open your brain to the world’s psychic maelstrom, roll+weird. On a hit, the MC will tell you something new and interesting about the current situation, and might ask you a question or two; answer them. On a 10+, the MC will give you good detail. On a 7–9, the MC will give you an impression.
+
+(In the parlance of the game, a "hit" is getting a 7 or higher on 2d6, plus a stat.)
+
+Here's how I'd write it out in Tabletop.
+
+    cool = [-1, 0, 1, 2, 3].sample #=> get a random stat
+    
+    open_brain = Roll.new(2.d6) {
+      modifier cool
+      at_least 7, "the MC will tell you something new and interesting about the current situation"
+      equals (7..9), "...but it's just an impression"
+      at_least 10, "...and it's a good detail"
+    }
+    
+Simple, right?  `add` sets a value to be permanently added for the purposes of determining results.  `at_least` and `equals` take an integer (or a range, in the case of `equals`) as their first parameter, and then one or more results to trigger if the pools result meets the stated condition.
+
+Once they've been instantiated, Rolls have two important methods. 
+
+#### #roll
  
+This method which re-rolls all the dice in the pool, and returns the Roll object.  It can take an options hash as a parameter.  Notably, one of the options is `:modifier`, which sets a temporary modifier for that roll only; it's cleared the next time `roll` is called.
+    
+    bad_luck = -1
+    open_brain.roll(:modifier => bad_luck)
+
+#### #effects
+
+This method returns an array, based on the current state of the pool, and any conditions and modifiers. Here's what I can tell you about the Array:
+
+* Its first element is the "result" of the current pool, which is by default the sum of the values of its dice, plus any static or per-roll modifiers.
+* The second and subsequent elements are the results of any satisfied conditions.
+* If no conditions are satisfied, then the second and final element of the array is `nil`
+
+So, possible results for our cool AW roll:
+
+    open_brain.roll.effects #=> [4, nil]
+    open_brain.roll.effects #=> [8, "the MC will tell you something new and interesting about the current situation", "...but it's just an impression"]
+    roll, *effects = open_brain.roll.effects 
+    puts roll               #=> 10 
+    puts effects            #=> ["the MC will tell you something new and interesting about the current situation", "...and it's a good detail"]
+    
+Just these few functions already give enough functionality to do different kinds of rolls, but there's a lot more in store.
+
+One last thing I'll briefly note is that Rolls can be nested. 
+
+    rps = Roll.new(1.d3) {
+      equals 1, "rock"
+      equals 2, "paper"
+      equals 3, "scissors"
+    }
+    jkp = Roll.new(1.d3) {
+      equals 1, "guu"
+      equals 2, "choki"
+      equals 3, "paa"
+    }
+    fist_game = Roll.new(1.d2) {
+      equals 1, "Rock Paper Scissors", rps
+      equals 2, "JanKenPon", jkp 
+    }
+    fist_game.roll.effects   #=> [2, "JanKenPon", [1, "guu"]]
+
+This can lead to some surprisingly sophisticated constructions.  Remember that "tables" are really just a special case of a roll!
+
+## How to contribute
+
+*First and most importantly*, any complaints or suggestions, *regardless of coding knowledge*, are *always welcome* at <nick.novitski@gmail.com>.
+
+But, if you're feeling up to it, you can always do more.  You probably already know the drill by this point.
+
 * Fork the project.
 * Create a topic branch
 * Make tests that describe your feature addition or bug fix.
 * Write code that passes those tests
-* Commit, without altering the rakefile or version.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Commit, without altering the version.
 * Send me a pull request.
 
 ## Copyright

data/lib/tabletop/die.rb

@@ -1,59 +1,62 @@
 module Tabletop
   class Die
     include Comparable
-    attr_reader :sides, :result
-    def initialize(sides=6, result=nil)
-      if sides <= 0
+    attr_reader :sides, :value
+    def initialize(sides=6, init_value=nil)
+      if sides <= 1
         raise ArgumentError, "Die cannot have #{sides} sides"
       end
       unless sides.kind_of? Integer
         raise ArgumentError, "Parameter must be Integer, not #{sides.class}"
       end
       @sides = sides
-      if result.nil?
-        result = roll
+      if init_value.nil?
+        init_value = roll
       else
-        raise ArgumentError unless valid_result?(result)
+        raise ArgumentError unless valid_value?(init_value)
       end
-      @result = result
+      @value = init_value
     end
     def roll
-      @result = rand(sides)+1
+      @value = rand(sides)+1
     end
-    def inspect
-      "#{@result} (d#{@sides})"
+    
+    def to_s
+      "[#{value}]/d#{sides}"
     end
-    def result=(new_result)
-      raise ArgumentError unless valid_result?(new_result)  
-      @result = new_result
+    
+    def value=(new_value)
+      raise ArgumentError unless valid_value?(new_value)  
+      @value = new_value
     end
     def <=>(operand)
-      @result <=> operand.to_int
+      @value <=> operand.to_int
     end
     def to_int
-      @result
+      @value
     end
     
     protected
-    def valid_result?(result)
-      result > 0 and result <= @sides
+    def valid_value?(val)
+      val > 0 and val <= @sides
     end
   end
   
   class FudgeDie < Die
-    def initialize(result = nil)
-      super(3, result)
+    def initialize(init_value = nil)
+      super(3, init_value)
     end
     def roll
-      @result = rand(sides)-1
-    end
-    def inspect
-      "[#{['-', ' ', '+'][@result+1]}] (dF)"
+      @value = rand(sides)-1
     end
     
+    def to_s
+      "[#{['-', ' ', '+'][@value+1]}]"
+    end
+  
     protected
-    def valid_result?(result)
-      [1,0,-1].include?(result)
+    def valid_value?(val)
+      [1,0,-1].include?(val)
     end
   end
 end

data/lib/tabletop/pool.rb

@@ -35,8 +35,8 @@ module Tabletop
         sum <=> operand.to_int
     end
       
-    def results
-      map {|die| die.result}
+    def values
+      map {|die| die.value}
     end
     def dice
       fudge = nil
@@ -66,7 +66,7 @@ module Tabletop
       self
     end
     def sum
-      inject(0) {|sum, d| sum + d.result}
+      inject(0) {|sum, d| sum + d.value}
     end
     def to_int
       sum
@@ -74,17 +74,15 @@ module Tabletop
     def sets
       result = {}
       each do |die|
-        result[die.result] = count {|d| d.result == die.result}
+        result[die.value] = count {|d| d.value == die.value}
       end
       result.sort_by{|height, width| [width, height] }.collect {|i| i[1].to_s+"x"+i[0].to_s}.reverse
     end
     def highest(n=1)
-      sorted = sort_by {|d| d.result}.reverse
-      Pool.new(sorted.first(n))
+      Pool.new(sort.reverse.first(n))
     end
     def lowest(n=1)
-      sorted = sort_by {|d| d.result}
-      Pool.new(sorted.first(n))
+      Pool.new(sort.first(n))
     end
     def drop_highest(n=1)
       Pool.new(self-highest(n))
@@ -94,7 +92,7 @@ module Tabletop
     end
     def drop(to_drop)
       to_drop = [to_drop].flatten #turn it into an array if it isn't one.
-      kept = reject{|die| to_drop.any?{|drop_value| die.result == drop_value }}
+      kept = reject{|die| to_drop.any?{|drop_value| die.value == drop_value }}
       return Pool.new(kept)
     end
     
@@ -104,9 +102,9 @@ module Tabletop
       new_pool =[]
       union.each do |die| 
         if die.class == FudgeDie
-          new_pool << FudgeDie.new(die.result)
+          new_pool << FudgeDie.new(die.value)
         else
-          new_pool << Die.new(die.sides, die.result)
+          new_pool << Die.new(die.sides, die.value)
         end
       end
       Pool.new(new_pool)

data/lib/tabletop/roll.rb

@@ -0,0 +1,138 @@
+require_relative 'pool'
+
+module Tabletop
+  
+  class Possibility
+    attr_reader :outcomes, :conditions
+    
+    def initialize(outcomes, conditions)
+      @outcomes = outcomes
+      @conditions = conditions
+    end
+  end
+    
+  class Roll
+    attr_reader :pool, :possibilities
+    
+    def initialize(pool=nil, &block)
+      if pool
+        raise ArgumentError if pool.class != Tabletop::Pool
+      end
+      @pool = pool
+      @possibilities = []
+      @die_sides = nil
+      @static_modifier = 0
+      @roll_modifier = 0
+      @result_set = false
+      instance_eval(&block)
+      unless @result_set
+        set_result(:sum)
+      end
+    end
+    
+    def effects
+      results = []
+      
+      if @difficulty
+        results << "Success" if result >= @difficulty
+      end
+      
+      @possibilities.each do |poss|
+        if meets?(poss)
+          poss.outcomes.each do |outcome|
+            if Roll === outcome
+              results << outcome.roll.effects
+            else
+              results << outcome
+            end
+          end
+        end
+      end
+      
+          
+      if results.empty?
+        results << nil 
+      end
+      
+      results.unshift(result)
+    end
+    
+    def roll(opts={})
+      @roll_modifier = opts[:modifier] ? opts[:modifier] : 0
+      if @die_sides
+        if opts[:pool] 
+          @pool = opts[:pool].dX(@die_sides)
+        else
+          raise ArgumentError
+        end
+      end
+      if opts[:difficulty]
+        @difficulty = opts[:difficulty]
+      end
+      @pool.roll
+      self 
+    end
+    
+    def meets?(p)
+      answer = true
+      if p.conditions[:>=]
+        if p.conditions[:>=] > sum
+          answer = false
+        end
+      end
+      if p.conditions[:==]
+        answer = false if p.conditions[:==] != sum
+      end
+      answer
+    end
+    
+    def sum
+      @pool.sum + @static_modifier + @roll_modifier
+    end
+    
+    # instance_eval methods
+    
+    ## Possibility-creating methods
+    def at_least(value, *outcomes)
+      @possibilities << Possibility.new(outcomes, :>= => value)
+    end
+    
+    def equals(values, *outcomes)
+      if values.class == Range
+        values.each do |val|
+          @possibilities << Possibility.new(outcomes, :== => val)
+        end
+      else
+        @possibilities << Possibility.new(outcomes, :== => values)
+      end
+    end
+    
+    def set_result(symbol, args={})
+      if symbol == :count
+        @count_at_least = args[:at_least]
+        @count_doubles = args[:doubles]
+        def result
+          normal = @pool.count {|die| die.value >= @count_at_least}
+          extra = @count_doubles ? @pool.count {|die| die.value == @count_doubles} : 0
+          normal + extra
+        end
+      else
+        def result
+          sum
+        end
+      end
+      @result_set = true
+    end
+    
+    # instance-variable-setting methods
+    def add(mod)
+      @static_modifier = mod
+    end
+    
+    def sides(num_sides)
+      @die_sides = num_sides
+    end
+    
+  end
+  
+end

data/lib/tabletop/version.rb

@@ -1,3 +1,3 @@
 module Tabletop
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/tabletop.rb

@@ -1,3 +1,4 @@
 require_relative 'fixnum'
 require_relative 'tabletop/die'
 require_relative 'tabletop/pool'
+require_relative 'tabletop/roll'

data/spec/die_spec.rb

@@ -2,187 +2,170 @@ require 'spec_helper'
 
 module Tabletop
   describe Die do
+    
     before :each do
       @d6_2 = Die.new(6, 2)
       @d6_3 = Die.new(6, 3)
     end
+    
     describe "#sides" do
       it "can be accessed" do
-        d = Die.new(6)
-        d.sides.should == 6
-        d = Die.new(20)
-        d.sides.should == 20
-        d = Die.new(7)
-        d.sides.should equal(7)
+        (2..10).each do |i|
+          Die.new(i).sides.should == i
+        end
       end
+      
       it "is 6 by default" do
-        d = Die.new
-        d.sides.should equal(6)
+        Die.new.sides.should == 6
       end
-      it "cannot be 0 or less" do
+      
+      it "cannot be 1 or less" do
         lambda { Die.new(0) }.should raise_error(ArgumentError)
+        lambda { Die.new(1) }.should raise_error(ArgumentError)
         lambda { Die.new(-5) }.should raise_error(ArgumentError)
       end
+      
       it "cannot be a non-integer" do
         lambda { Die.new(0.1) }.should raise_error(ArgumentError)
         lambda { Die.new(5.7694) }.should raise_error(ArgumentError)
         lambda { Die.new("foof") }.should raise_error(ArgumentError)
       end
     end
-    describe "#result" do
-      before :each do
-        Random.srand(10)
-      end
+    
+    describe "#value" do
       it "should be random on instantiation by default" do 
-        d = Die.new
-        d.result.should equal(2)
-        d = Die.new(10)
-        d.result.should equal(5)
-        d = Die.new(50)
-        d.result.should equal(16)
+        Random.srand(10)
+        Die.new.value.should == 2
+        Die.new(10).value.should == 5
+        Die.new(50).value.should == 16
       end
+      
       it "can be set to a given value on instantiation" do
-        Die.new(6, 5).result.should == 5
-        Die.new(10, 2).result.should == 2
+        Die.new(6, 5).value.should == 5
+        Die.new(10, 2).value.should == 2
       end
+      
       it "cannot be a non-integer" do
         lambda { Die.new(0.1) }.should raise_error(ArgumentError)
         lambda { Die.new(5.7694) }.should raise_error(ArgumentError)
         lambda { Die.new("foof") }.should raise_error(ArgumentError)
       end
     end
-    describe "#result=" do
+    
+    describe "#value=" do
       it "can only be set to an integer i, where 0 < i <= sides" do
         d = Die.new
-        lambda { d.result = 0 }.should raise_error(ArgumentError)
-        lambda { d.result = -5 }.should raise_error(ArgumentError)
-        lambda { d.result = 7 }.should raise_error(ArgumentError)
+        lambda { d.value = 0 }.should raise_error(ArgumentError)
+        lambda { d.value = -5 }.should raise_error(ArgumentError)
+        lambda { d.value = 7 }.should raise_error(ArgumentError)
         d = Die.new(10)
-        d.result = 7
-        lambda { d.result = 22 }.should raise_error(ArgumentError)
+        d.value = 7
+        lambda { d.value = 22 }.should raise_error(ArgumentError)
       end
     end
+    
     describe "#roll" do
       before(:each) do
         Random.srand(10)
       end
+      
       context "six sides" do
-        it "should return a random result between 1 and @sides" do
-          d = Die.new
-          #d.roll.should == 2 # This result gets swallowed by the init roll
-          d.roll.should == 6
-          d.roll.should == 5
-          d.roll.should == 1
-        end
-        it "should alter the result appropriately" do
-          d = Die.new
-          #d.roll # Covered by the initial roll
-          d.result.should == 2 
-          d.roll
-          d.result.should == 6
-          d.roll
-          d.result.should == 5
-          d.roll
-          d.result.should == 1
+        before(:each) do
+          @d6 = Die.new #=> 2
         end
-      end
-      context "eleven sides" do
-        it "should return a random result between 1 and @sides" do 
-          d = Die.new(11)
-          # d.roll.should == 10 # This result gets swallowed by the init roll
-          d.roll.should == 5
-          d.roll.should == 1
-          d.roll.should == 2
+        
+        it "should return a random result between 1 and @sides" do
+          @d6.roll.should == 6
+          @d6.roll.should == 5
+          @d6.roll.should == 1
         end
-        it "should alter the result appropriately" do
-          d = Die.new(11)
-          #d.roll # covered by the initial roll
-          d.result.should == 10
-          d.roll
-          d.result.should == 5
-          d.roll
-          d.result.should == 1
-          d.roll
-          d.result.should == 2
+        
+        it "should alter the value appropriately" do
+          10.times do
+            @d6.roll.should == @d6.value
+          end
         end
       end      
     end
-    describe "#inspect" do
-      before(:each) do
-        Random.srand(10)
-      end
-      it "should be interesting" do
-        Die.new.inspect.should == "2 (d6)"
-        Die.new.inspect.should == "6 (d6)"
+    
+    describe "#to_str" do      
+      it "should tell you the die's value" do
+        5.times do
+          d = Die.new(rand(10)+3)
+          "#{d}".should == "[#{d.value}]/d#{d.sides}"
+        end
       end
     end
+    
     describe "#to_int" do
-      it "returns the result" do
+      it "returns the value" do
         d = Die.new
-        d.to_int.should == d.result
+        d.to_int.should == d.value
       end
     end
+    
     describe "<=>" do
       it "compares numeric objects with the die's value" do
-        (@d6_3 < 4).should be_true
-        (@d6_3 < 2).should be_false
-        (@d6_3 > 2).should be_true
-        (@d6_3 > 4).should be_false
-        (@d6_3 >= 3).should be_true
-        (@d6_3 >= 10).should be_false
-        (@d6_3 <= 3).should be_true
-        (@d6_3 <= 2).should be_false
-        (@d6_3 == 3).should be_true
-        (@d6_3 == 6).should be_false
+        (1..10).each do |i|
+          (@d6_3 <=> i) == (3 <=> i)
+        end
       end
+      
       it "compares dice with each other by value" do
-        (@d6_3 > @d6_2).should be_true
-        (@d6_3 < @d6_2).should be_false
-        (@d6_2 < @d6_3).should be_true
-        (@d6_2 > @d6_3).should be_false
-        (@d6_3 == @d6_2).should be_false
+        (@d6_3 <=> @d6_2) == (3 <=> 2)
       end
     end
   end
+  
   describe FudgeDie do
     before(:each) do
       Random.srand(10)
       @fudge = FudgeDie.new
     end
+    
     describe "#sides" do
       it "is always 3" do
         @fudge.sides.should == 3
       end
     end
-    describe "#result" do
+    
+    describe "#value" do
       it "can be set on instantiation" do
-        FudgeDie.new(1).result.should == 1
-        FudgeDie.new(0).result.should == 0
-        FudgeDie.new(-1).result.should == -1
+        FudgeDie.new(1).value.should == 1
+        FudgeDie.new(0).value.should == 0
+        FudgeDie.new(-1).value.should == -1
       end
+      
       it "is randomly rolled if not set" do
-        @fudge.result.should == 0
+        @fudge.value.should == 0
       end
+      
       it "can only be one of either -1, 0, or 1" do
+        [-1, 0, 1].each do |v|
+          FudgeDie.new(v)
+        end
         lambda {FudgeDie.new(2)}.should raise_error(ArgumentError)
         lambda {FudgeDie.new(0.6)}.should raise_error(ArgumentError)
         lambda {FudgeDie.new("5")}.should raise_error(ArgumentError)
       end
     end
-    describe "#result=" do
+    
+    describe "#value=" do
       it "cannot be set to anything but -1, 0, or 1" do
-        lambda {@fudge.result = 2}.should raise_error(ArgumentError)
-        lambda {@fudge.result = 0.6}.should raise_error(ArgumentError)
-        lambda {@fudge.result = "5"}.should raise_error(ArgumentError)
-        @fudge.result = 1
-        @fudge.result.should == 1
+        lambda {@fudge.value = 2}.should raise_error(ArgumentError)
+        lambda {@fudge.value = 0.6}.should raise_error(ArgumentError)
+        lambda {@fudge.value = "5"}.should raise_error(ArgumentError)
+        [-1, 0, 1].each do |v|
+          @fudge.value = v
+        end
       end
     end
-    describe "#inspect" do
-      it "should look like plusses, minuses and spaces" do
-        FudgeDie.new(1).inspect.should == "[+] (dF)"
-        FudgeDie.new(0).inspect.should == "[ ] (dF)"
-        FudgeDie.new(-1).inspect.should == "[-] (dF)"
+    
+    describe "#to_s" do
+      it "should return cute little dice with symbols" do
+        FudgeDie.new(1).to_s.should == "[+]"
+        FudgeDie.new(0).to_s.should == "[ ]"
+        FudgeDie.new(-1).to_s.should == "[-]"
       end
     end
   end

data/spec/fixnum_spec.rb

@@ -8,6 +8,7 @@ module Tabletop
         4.d7.dice.should == ["4d7"]
         10.d100.class.should == Pool
       end
+      
       it "shows up in respond_to?(:dN)" do
         1.respond_to?(:d50).should be_true
       end

data/spec/pool_spec.rb

@@ -9,6 +9,7 @@ module Tabletop
       @mixed = Pool.new("2d10 d20") 
       @fudge = Pool.new("3dF")
     end
+    
     describe "#dice" do
       it "should return an array of dice notation" do
         @mixed.dice.should == ["2d10","d20"]
@@ -18,31 +19,36 @@ module Tabletop
         Pool.new("d20 2dF 2d10").dice.should == ["2d10","d20", "2dF"]
       end
     end
+    
     describe "[]" do
       it "should access Die objects" do
         @d6[0].class.should == Die
         @fudge[0].class.should == FudgeDie
       end
     end
+    
     describe "+" do
       it "should join Pools into new Pools" do
         (@mixed + @d17s).class == Pool
         (@d6 + @fudge).class == Pool
       end
+      
       it "should persist die types" do
         (@d6 + @fudge)[1].class.should == FudgeDie
       end
+      
       it "should join pools without rolling them" do
         merge = @d6 + @d17s
-        merge.results.should == [2, 5, 16, 1, 17, 9]
+        merge.values.should == [2, 5, 16, 1, 17, 9]
         merge.roll
-        merge.results.should == [4, 17, 5, 16, 12, 12]
+        merge.values.should == [4, 17, 5, 16, 12, 12]
       end
+      
       it "creates genuinely new pools" do
         merge = @d6 + @d17s
         merge.roll
-        @d6.results.should == [2]
-        @d17s.results.should == [5, 16, 1, 17, 9]
+        @d6.values.should == [2]
+        @d17s.values.should == [5, 16, 1, 17, 9]
       end
       
       it "should alter #dice accordingly" do
@@ -54,69 +60,83 @@ module Tabletop
         (@d17s + @mixed).dice.should == ["2d10","5d17","d20"]
         (@mixed + @fudge).dice.should == ["2d10", "d20", "3dF"]
       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
       end
+      
       it "should add literal dice arrays as if they were pools" do
         g = @d6 + [Die.new(6,3), Die.new(10, 4)]
-        g.results.should == [2, 3, 4]
+        g.values.should == [2, 3, 4]
         g.dice.should == ["2d6", "d10"]
         g.roll
-        @d6.results.should == [2]
+        @d6.values.should == [2]
       end
+      
       it "should reject adding anything else" do
         lambda {@d6 + "foof"}.should raise_error(ArgumentError)
         lambda {@d6 + [Die.new, Object.new]}.should raise_error(ArgumentError)
       end
     end
-    describe "#results" do
+    
+    describe "#values" do
       it "should be an array of random numbers" do
-        @d6.results.should == [2]
-        @d17s.results.should == [5, 16, 1, 17, 9]
-        @mixed.results.should == [10, 1, 11]
+        @d6.values.should == [2]
+        @d17s.values.should == [5, 16, 1, 17, 9]
+        @mixed.values.should == [10, 1, 11]
       end
     end
+    
     describe "#roll" do
       it "should return the Pool itself" do
         @d6.roll.length.should == @d6.length
         @d6.roll.class.should == @d6.class
       end
+      
       it "should store the new values" do
         @d6.roll
-        @d6.results.should == [4]
+        @d6.values.should == [4]
         @d17s.roll
-        @d17s.results.should == [17, 5, 16, 12, 12]
+        @d17s.values.should == [17, 5, 16, 12, 12]
         @mixed.roll
-        @mixed.results.should == [2, 9, 5]
+        @mixed.values.should == [2, 9, 5]
       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 "#sum" do
       it "should sum the dice values" do
-        @d6.sum.should == 2 
-        @d17s.sum.should == 48
-        @mixed.sum.should == 22
-        @fudge.sum.should == -1
+        5.times do
+          p = 10.d6
+          p.sum.should == p.values.inject(:+)
+        end
       end
+      
       it "should be aliased to #to_int" do
-        @d6.to_int.should == @d6.sum 
-        @d17s.to_int.should == @d17s.sum
-        @mixed.to_int.should == @mixed.sum
-        @fudge.to_int.should == @fudge.sum
+        5.times do
+          p = 10.d6
+          p.to_int.should == p.sum
+        end
       end
     end
+    
     describe "<=>" do
       it "should compare the sums of different pools" do
         @d17s.should >= @d6
         @d6.should < Pool.new([Die.new(4, 4)])
       end
+      
       it "should compare pools to numbers" do
         @d6.should < 10
         @d6.should == 2
         @d17s.should <= 49
       end
     end
+    
     describe "#sets" do
       it "should list the sets, in order by height and width" do
         ore = Pool.new("10d10")
@@ -127,67 +147,78 @@ module Tabletop
         ore.sets.should == ["3x9", "2x8", "2x7", "1x10", "1x3", "1x1"]
       end
     end
+    
     describe "#highest" do
       it "should return a pool of the highest-value die" do
         @d6.highest.class.should == Pool
-        @d6.highest.results.should == [2]
-        @d17s.highest.results.should == [17]
-        @mixed.highest.results.should == [11]
+        @d6.highest.values.should == [2]
+        @d17s.highest.values.should == [17]
+        @mixed.highest.values.should == [11]
       end
+      
       it "should return as many items as are specified" do
-        @d6.highest(5).results.should == [2]
-        @d17s.highest(3).results.should == [17, 16, 9]
-        @mixed.highest(2).results.should == [11, 10]
+        @d6.highest(5).values.should == [2]
+        @d17s.highest(3).values.should == [17, 16, 9]
+        @mixed.highest(2).values.should == [11, 10]
       end
     end
+    
     describe "#lowest" do
       it "should return a pool of the lowest-value die." do
-        @d6.lowest.results.should == [2]
+        @d6.lowest.values.should == [2]
         @d17s.lowest.class.should == Pool
-        @d17s.lowest.results.should == [1]
-        @mixed.lowest.results.should == [1]
+        @d17s.lowest.values.should == [1]
+        @mixed.lowest.values.should == [1]
       end
+      
       it "should return as many items as are specified" do
-          @d6.lowest(5).results.should == [2]
-          @d17s.lowest(3).results.should == [1, 5, 9]
-          @mixed.lowest(2).results.should == [1, 10]
+          @d6.lowest(5).values.should == [2]
+          @d17s.lowest(3).values.should == [1, 5, 9]
+          @mixed.lowest(2).values.should == [1, 10]
       end
     end
+    
     describe "#drop_highest" do
       it "should return a new pool missing the highest result" do
         p = @d17s.drop_highest
-        p.results.should == [5, 16, 1, 9]
-        @d17s.results.should == [5, 16, 1, 17, 9]
+        p.values.should == [5, 16, 1, 9]
+        @d17s.values.should == [5, 16, 1, 17, 9]
       end
+      
       it "should drop as many items as are specified and are possible" do
         p = @d17s.drop_highest(2)
-        p.results.should == [5, 1, 9]
+        p.values.should == [5, 1, 9]
         p = @d6.drop_highest(10)
-        p.results.should == []
+        p.values.should == []
       end
     end
+
     describe "#drop_lowest" do
       it "should return a pool missing the lowest result" do
         p = @d17s.drop_lowest
-        p.results.should == [5, 16, 17, 9]
-        @d17s.results.should == [5, 16, 1, 17, 9]
+        p.values.should == [5, 16, 17, 9]
+        @d17s.values.should == [5, 16, 1, 17, 9]
       end
+      
       it "should drop as many items as are specified" do
         p = @d17s.drop_lowest(2)
-        p.results.should == [16, 17, 9]
+        p.values.should == [16, 17, 9]
       end
     end
+
     describe "#drop" do
       it "should drop any dice of the specified value" do
         ore = Pool.new("10d10")
-        ore.results.should == [4, 1, 5, 7, 9, 2, 9, 5, 2, 4]
+        ore.values.should == [4, 1, 5, 7, 9, 2, 9, 5, 2, 4]
         at_least_two = ore.drop(1)
-        at_least_two.results.should == [4, 5, 7, 9, 2, 9, 5, 2, 4]
+        at_least_two.values.should == [4, 5, 7, 9, 2, 9, 5, 2, 4]
         at_least_three = ore.drop([1,2])
-        at_least_three.results.should == [4, 5, 7, 9, 9, 5, 4]
+        at_least_three.values.should == [4, 5, 7, 9, 9, 5, 4]
       end
     end
+    
     context "pool has been emptied" do
     end
+
   end
 end

data/spec/roll_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+module Tabletop
+  describe Roll do
+    
+    describe "#pool" do
+      it "accesses the roll's pool" do
+        d20 = Roll.new(1.d20) do
+        end
+        d20.pool.class.should == Pool
+        d20.pool.length.should == 1
+        d20.pool[0].sides.should == 20
+      end
+    end
+    
+    context "when used as an attribute or skill roll" do
+      
+      context "for Apocalypse World" do
+    
+        it "can be used with a static difficulty and dice pool, and both static and dynamic modifiers" do
+          cool = 1
+          under_fire = Roll.new(2.d6) do
+            add cool
+            at_least 10, "You do it"
+            equals (7..9), "You flinch, hesitate, or stall"
+          end
+          20.times do 
+            mod = [1, 0, -1].sample
+            if mod != 0
+              under_fire.roll(:modifier => mod)
+            else
+              under_fire.roll
+            end
+            if under_fire.pool.sum + cool + mod >= 10
+              effect = "You do it"
+            elsif under_fire.pool.sum + cool + mod >= 7
+              effect = "You flinch, hesitate, or stall"
+            end
+            under_fire.effects.should == [under_fire.pool.sum + cool + mod, effect]
+          end
+        end
+      end
+      
+      context "in Exalted" do
+        before :each do
+          @exalted = Roll.new do
+            set_result :count, :at_least=>7, :doubles=>10
+            sides 10
+          end
+        end
+        
+        def count_successes(pool)
+          pool.count {|die| die.value >= 7 } + pool.count {|die| die.value == 10 }
+        end
+        
+        it "can be instantiated without a complete pool" do
+          @exalted.roll(:pool=>6)
+          @exalted.pool.length.should == 6
+          @exalted.pool.each do |die|
+            die.sides.should == 10
+          end
+          @exalted.roll(:pool=>10)
+          @exalted.pool.length.should == 10
+          lambda {@exalted.roll}.should raise_error(ArgumentError)
+        end
+        
+        it "can count successes" do
+          @exalted.roll(:pool=>10)
+          10.times do
+            @exalted.effects.should == [count_successes(@exalted.pool), nil]
+          end
+        end
+        
+        it "can determine success" do
+          (1..10).each do |i|
+            @exalted.roll(:pool=>6, :difficulty=>i)
+            effect = (count_successes(@exalted.pool) >= i) ? "Success" : nil
+            @exalted.effects.should == [count_successes(@exalted.pool), effect]
+          end
+        end
+      end
+            
+      
+    end
+    
+    context "when used like a table" do
+      it "can have nested results" do
+        rps = Roll.new(1.d3) {
+          equals 1, "rock"
+          equals 2, "paper"
+          equals 3, "scissors"
+        }
+        jkp = Roll.new(1.d3) {
+          equals 1, "guu"
+          equals 2, "choki"
+          equals 3, "paa"
+        }
+        fist_game = Roll.new(1.d2) {
+          equals 1, "Rock Paper Scissors", rps
+          equals 2, "JanKenPon", jkp 
+        }
+        a, b, c = fist_game.roll.effects
+        
+        [1,2].include?(a).should be_true
+        
+        if a == 1
+          b.should == "Rock Paper Scissors"
+        else
+          b.should == "JanKenPon"
+        end
+        
+        [1,2,3].include?(c[0]).should be_true
+        
+        b[1].class.should == String
+        
+      end
+      before :each do
+        ill_fortune = Roll.new(1.d10) do
+          equals 1, "Accident"
+          equals 2, "Maltreatment"
+          equals 3, "Disease"
+          equals 4, "Dropped"
+          equals 5, "Parental Loss"
+          equals 6, "Family Loss"
+          equals 7, "Torment"
+          equals 8, "Homeless"
+          equals 9, "Ghost"
+          equals 10, "Prying Eyes"
+        end
+        good_fortune = Roll.new(1.d10) do
+          equals 1, "Dreamer"
+          equals 2, "Childhood Patron"
+          equals 3, "Active Youth"
+          equals 4, "Apt Pupil"
+          equals 5, "Save a Life"
+          equals 6, "First Love"
+          equals 7, "Childhood Friend"
+          equals 8, "Heirloom"
+          equals 9, "Spirit Blessing"
+          equals 10, "Temple Assistant"
+        end
+        @childhood_event = Roll.new(1.d10) do
+          equals (1..4), "Roll on ill fortune table", ill_fortune
+          equals (5..8), "Roll on good fortune table", good_fortune
+          equals (9..10), "Roll on both ill and good fortune tables", ill_fortune, good_fortune
+        end
+      end
+      
+      it "can compose multiple nested results" do
+        20.times do
+          @childhood_event.roll
+          if @childhood_event.effects[0] >= 9
+            @childhood_event.effects.length.should == 4
+          else
+            @childhood_event.effects.length.should == 3
+          end
+        end
+      end
+      
+      
+    end
+    
+  end
+end

data/tabletop.gemspec

@@ -20,8 +20,11 @@ Gem::Specification.new do |s|
   s.rubygems_version = '1.3.7'
   s.specification_version = 3
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {spec,features}/*`.split("\n")
+  ignores = File.readlines(".gitignore").grep(/\S+/).map {|s| s.chomp }
+  dotfiles = [".gitignore"]
+  
+  s.files = Dir["**/*"].reject {|f| File.directory?(f) || ignores.any? {|i| File.fnmatch(i, f) } } + dotfiles
+  s.test_files = s.files.grep(/^spec\//)
   s.require_paths = ['lib']
 
   s.add_development_dependency 'rspec'

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: tabletop
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 1
-  version: 0.0.1
+  prerelease: 
+  version: 0.1.0
 platform: ruby
 authors: 
 - Nick Novitski
@@ -14,73 +10,62 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-10 00:00:00 -07:00
-default_executable: 
+date: 2011-08-10 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
+  prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: bundler
-  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
+  prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: bueller
-  prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
+  prerelease: false
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: rake
-  prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
+  prerelease: false
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: rdoc
-  prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
+  prerelease: false
   version_requirements: *id005
 description: Tabletop aims to provide a simple way of describing, automating and tracking the tools and tasks involved in "analog" games, determining results from the motions and properties of various dice and chips.
 email: nicknovitski@gmail.com
@@ -92,22 +77,23 @@ extra_rdoc_files:
 - LICENSE
 - README.markdown
 files: 
-- .gitignore
 - Gemfile
-- LICENSE
-- README.markdown
-- Rakefile
 - lib/fixnum.rb
-- lib/tabletop.rb
 - lib/tabletop/die.rb
 - lib/tabletop/pool.rb
+- lib/tabletop/roll.rb
 - lib/tabletop/version.rb
+- lib/tabletop.rb
+- LICENSE
+- Rakefile
+- README.markdown
 - spec/die_spec.rb
 - spec/fixnum_spec.rb
 - spec/pool_spec.rb
+- spec/roll_spec.rb
 - spec/spec_helper.rb
 - tabletop.gemspec
-has_rdoc: true
+- .gitignore
 homepage: http://github.com/njay/tabletop
 licenses: []
 
@@ -121,6 +107,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: -2668007910377914487
       segments: 
       - 0
       version: "0"
@@ -129,15 +116,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 1
-      - 3
-      - 7
       version: 1.3.7
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.7
 signing_key: 
 specification_version: 3
 summary: A Ruby DSL for role-playing games
@@ -145,4 +128,5 @@ test_files:
 - spec/die_spec.rb
 - spec/fixnum_spec.rb
 - spec/pool_spec.rb
+- spec/roll_spec.rb
 - spec/spec_helper.rb