games_dice 0.1.3 → 0.2.0

data/README.md

@@ -2,33 +2,33 @@
 
 [![Build Status](https://travis-ci.org/neilslater/games_dice.png?branch=master)](http://travis-ci.org/neilslater/games_dice)
 
-A library for simulating dice, intended for constructing a variety of dice systems as used in
-role-playing and board games.
+A library for simulating dice. Use it to construct dice-rolling systems used in role-playing and board games.
 
 ## Description
 
-GamesDice is a gem to automate or simulate a variety of dice rolling systems found in board games and
-role-playing games.
+GamesDice can emulate a variety of rules-driven dice systems that are used to generate integer results
+within a game.
 
-GamesDice is designed for systems used to generate integer results, and that do not require the
-player to make decisions or apply other rules from the game. There are no game mechanics implemented
-in GamesDice (such as the chance to hit in a combat game).
-
-The main features of GamesDice are
+The main features of GamesDice are:
 
  * Uses string dice descriptions, the basics of which are familiar to many game players e.g. '2d6 + 3'
- * Supports common features of dice systems automatically:
+ * Supports some common features of dice systems:
    * Re-rolls that replace or modify the previous roll
    * Counting number of "successes" from a set of dice
    * Keeping the best, or worst, results from a set of dice
  * Can explain how a result was achieved in terms of the individual die rolls
- * Can calculate probabilities and expected values (experimental feature)
+ * Can calculate probabilities and expected values (with some limitations)
+
+There are no game mechanics implemented in GamesDice, such as the chance to hit in a fantasy combat
+game. There is no support for player interaction within a roll, such as player choice on whether or
+not to re-roll a specific die within a combined set. These things are of course possible if you use the
+gem as-is, and add them as features within your project code.
 
 ## Special Note on Versions Prior to 1.0.0
 
-The author is using this code as an exercise in gem "best practice". As such, the gem
-will have a limited set of functionality prior to version 1.0.0, and there should be
-many small release increments before then.
+As of version 0.2.0, the gem has the same feature set as planned for version
+1.0.0. Versions between 0.2.0 and 1.0.0 are being used mainly to improve
+code quality, documentation and performance.
 
 ## Installation
 
@@ -91,6 +91,17 @@ Returns the value from the last call to roll. This will be nil if no roll has be
     dice.roll
     dice.result      # => 12
 
+#### dice.explain_result
+
+Returns a string that attempts to show how the result from the last call to roll was composed
+from individual results. This will be nil if no roll has been made yet.
+
+    dice.explain_result    # => nil
+    dice.roll              # => 12
+    dice.explain_result    # => "3d6: 4 + 2 + 6 = 12"
+
+The exact format is the subject of refinement in future versions of the gem.
+
 #### dice.max
 
 Returns the maximum possible value from a roll of the dice. Dice with the possibility of rolling
@@ -255,13 +266,13 @@ Where:
   * add - add result of reroll to running total, and ignore any subtract rules
   * subtract - subtract result of reroll from running total, and reverse sense of any further add results
   * use_best - use the new value if it is higher than the existing value
-  * use_worst - use the new value if it is higher than the existing value
+  * use_worst - use the new value if it is lower than the existing value
  * LIMIT is an integer that sets the maximum number of times that the rule can be triggered, the default is 1000
 
 Examples:
 
     1d6r:1.                # Same as "1d6r1"
-    1d10r:10,replace,1.    #
+    1d10r:10,replace,1.    # Roll a 10-sided die, re-roll a result of 10 and take the value of the second roll
     1d20r:<=10,use_best,1. # Roll a 20-sided die, re-roll a result if 10 or lower, and use best result
 
 #### Maps
@@ -275,6 +286,24 @@ The simple form specifies a value above which the result is considered to be 1,
 
 When rolled, this will score from 0 to 3 - the number of the ten-sided dice that scored 6 or higher.
 
+The full version of this modifier, allows you to specify from 1 to 3 parameters:
+
+    3d10m:[VALUE_COMPARISON],[MAP_VALUE],[DESCRIPTION].
+
+Where:
+
+ * VALUE_COMPARISON is one of >, >= (default), ==, <= < plus an integer to set conditions on when the map should occur
+ * MAP_VALUE is an integer that will be used in place of a result from a die, default value is 1
+  * maps are tested in order that they are declared, and first one that matches is applied
+  * when at least one map has been defined, all unmapped values default to 0
+ * DESCRIPTION is a word or character to use to denote the map in any explanation
+
+Examples:
+
+    9d6x.m:10.                 # Roll 9 six-sided "exploding" dice, and count 1 for any result of 10 or more
+    9d6x.m:10,1,S.             # Same as above, but with each success marked with "S" in the explanation
+    5d10m:>=6,1,S.m:==1,-1,F.  # Roll 5 ten-sided dice, count 1 for any result of 6 or more, or -1 for any result of 1
+
 #### Keepers
 
 You can specify that only a sub-set of highest or lowest dice values will contribute to the final
@@ -287,6 +316,30 @@ The simple form indicates the number of highest value dice to keep.
 When rolled, this will score from 2 to 20 - the sum of the two highest scoring ten-sided dice, out of
 five.
 
+The full version of this modifier, allows you to specify from 1 to 2 parameters:
+
+    5d10k:[KEEP_NUM],[KEEP_TYPE].
+
+Where:
+
+ * KEEP_NUM is an integer specifying the number of dice to keep.
+ * KEEP_TYPE is one of
+  * best   - keep highest values and add them together
+  * worst  - keep lowest values and add them together
+
+Examples:
+
+    4d6k:3.r:1,replace,1.      # Roll 4 six-sided dice, re-roll any 1s, and keep best 3.
+    2d20k:1,worst.             # Roll 2 twenty-sided dice, return lowest of the two results.
+
+#### Combinations
+
+ * When there are many modifiers, they are applied in strict order:
+  * First by type: re-rolls, maps, keepers
+  * Then according to the order they were specified
+ * A maximum of one re-roll modifier, and one map modifier are applied to each individual die rolled
+ * Only one keepers modifier is applied per dice type. Specifying a second one will cause an error
+
 #### Aliases
 
 Some combinations of modifiers crop up in well-known games, and have been allocated single-character
@@ -296,8 +349,8 @@ This is an alias for "exploding" dice:
 
     5d10x    # Same as '5d10r:10,add.'
 
-When rolled, this will score from 5 to theoretically any number, as results of 10 on any die mean that
-die rolls again and the result is added on.
+When rolled, this will score from 5 to theoretically any higher number, as results of 10 on any
+die mean that die rolls again and the result is added on.
 
 ## Contributing
 
@@ -306,3 +359,6 @@ die rolls again and the result is added on.
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+I am always interested to receive information about dice rolling schemes that this library could or
+should include in its repertoire.

data/lib/games_dice/bunch.rb

@@ -81,6 +81,12 @@ class GamesDice::Bunch
   # after calling #roll, this is set to the final integer value from using the dice as specified
   attr_reader :result
 
+  # Needs refinement. Returns best available string description of the bunch.
+  def label
+    return @name if @name != ''
+    return @ndice.to_s + 'd' + @sides.to_s
+  end
+
   # either nil, or an array of GamesDice::RerollRule objects that are assessed on each roll of #single_die
   # Reroll types :reroll_new_die and :reroll_new_keeper do not affect the #single_die, but are instead
   # assessed in this container object

data/lib/games_dice/dice.rb

@@ -66,4 +66,35 @@ class GamesDice::Dice
     end
   end
 
+  def explain_result
+    return nil unless @result
+    explanations = @bunches.map { |bunch| bunch.label + ": " + bunch.explain_result }
+
+    if explanations.count == 0
+      return @offset.to_s
+    end
+
+    if explanations.count == 1
+      if @offset !=0
+        return explanations[0] + '. ' + array_to_sum( [ @bunches[0].result, @offset ] )
+      else
+        return explanations[0]
+      end
+    end
+
+    bunch_values = @bunch_multipliers.zip(@bunches).map { |m,b| m * b.result }
+    bunch_values << @offset if @offset != 0
+    explanations << array_to_sum( bunch_values )
+    return explanations.join('. ')
+  end
+
+  private
+
+  def array_to_sum array
+    sum_parts = [ array.first < 0 ? '-' + array.first.abs.to_s : array.first.to_s ]
+    sum_parts += array.drop(1).map { |n| n < 0 ? '- ' + n.abs.to_s : '+ ' + n.to_s }
+    sum_parts += [ '=', array.inject(:+) ]
+    sum_parts.join(' ')
+  end
+
 end # class Dice

data/lib/games_dice/parser.rb

@@ -3,10 +3,9 @@ require 'parslet'
 # converts string dice descriptions to data usable for the GamesDice::Dice constructor
 class GamesDice::Parser < Parslet::Parser
 
-  # These are the Parslet rules that define the dice grammar. It's an inefficient and over-complex
-  # use of Parslet, and could do with logical a clean-up.
-
+  # Parslet rules that define the dice string grammar.
   rule(:integer) { match('[0-9]').repeat(1) }
+  rule(:plus_minus_integer) { ( match('[+-]') >> integer ) | integer }
   rule(:range) { integer.as(:range_start) >> str('..') >> integer.as(:range_end) }
   rule(:dlabel) { match('[d]') }
   rule(:space) { match('\s').repeat(1) }
@@ -33,20 +32,25 @@ class GamesDice::Parser < Parslet::Parser
   rule(:stop) { str('.') }
 
   rule(:condition_only) { opint_or_int.as(:condition) }
+  rule(:num_only) { integer.as(:num) }
+
 
   rule(:condition_and_type) { opint_or_int.as(:condition) >> comma >> ctl_string.as(:type) }
-  rule(:condition_and_num) { opint_or_int.as(:condition) >> comma >> integer.as(:num) }
+  rule(:condition_and_num) { opint_or_int.as(:condition) >> comma >> plus_minus_integer.as(:num) }
 
   rule(:condition_type_and_num) { opint_or_int.as(:condition) >> comma >> ctl_string.as(:type) >> comma >> integer.as(:num) }
-  rule(:condition_num_and_output) { opint_or_int.as(:condition) >> comma >> integer.as(:num) >> comma >> ctl_string.as(:output) }
+  rule(:condition_num_and_output) { opint_or_int.as(:condition) >> comma >> plus_minus_integer.as(:num) >> comma >> output_string.as(:output) }
+  rule(:num_and_type) { integer.as(:num)  >> comma >> ctl_string.as(:type) }
 
   rule(:reroll_params) { condition_type_and_num | condition_and_type | condition_only }
   rule(:map_params) { condition_num_and_output | condition_and_num | condition_only }
+  rule(:keeper_params) { num_and_type | num_only }
 
   rule(:full_reroll) { reroll_label >> str(':') >> reroll_params >> stop }
   rule(:full_map) { map_label >> str(':') >> map_params >> stop }
+  rule(:full_keepers) { keep_label >> str(':') >> keeper_params >> stop }
 
-  rule(:complex_modifier) { full_reroll | full_map }
+  rule(:complex_modifier) { full_reroll | full_map | full_keepers }
 
   rule(:bunch_modifier) { complex_modifier | ( single_modifier >> stop.maybe ) | ( simple_modifier >> stop.maybe ) }
   rule(:bunch) { bunch_start >> bunch_modifier.repeat.as(:mods) }
@@ -58,13 +62,11 @@ class GamesDice::Parser < Parslet::Parser
   rule(:expressions) { dice_expression.repeat.as(:bunches) }
   root :expressions
 
-  def parse dice_description, dice_name = nil
+  def parse dice_description
     dice_description = dice_description.to_s.strip
-    dice_name ||= dice_description
     # Force first item to start '+' for simpler parse rules
     dice_description = '+' + dice_description unless dice_description =~ /\A[+-]/
     dice_expressions = super( dice_description )
-
     { :bunches => collect_bunches( dice_expressions ), :offset => collect_offset( dice_expressions ) }
   end
 
@@ -137,9 +139,10 @@ class GamesDice::Parser < Parslet::Parser
   def collect_reroll_rule reroll_mod, out_hash
     out_hash[:rerolls] ||= []
     if reroll_mod[:simple_value]
-      out_hash[:rerolls] << [ reroll_mod[:simple_value].to_i, :>=, :reroll_replace, 1 ]
+      out_hash[:rerolls] << [ reroll_mod[:simple_value].to_i, :>=, :reroll_replace ]
       return
     end
+
     # Typical reroll_mod: {:reroll=>"r"@5, :condition=>{:compare_num=>"10"@7}, :type=>"add"@10}
     op = get_op_symbol( reroll_mod[:condition][:comparison] || '==' )
     v = reroll_mod[:condition][:compare_num].to_i
@@ -154,12 +157,16 @@ class GamesDice::Parser < Parslet::Parser
 
   # Called for any parsed keeper mode
   def collect_keeper_rule keeper_mod, out_hash
+    raise "Cannot set keepers for a bunch twice" if out_hash[:keep_mode]
     if keeper_mod[:simple_value]
       out_hash[:keep_mode] = :keep_best
       out_hash[:keep_number] = keeper_mod[:simple_value].to_i
       return
     end
-    # TODO: Handle complex descriptions
+
+    # Typical keeper_mod: {:keep=>"k"@5, :num=>"1"@7, :type=>"worst"@9}
+    out_hash[:keep_number] = keeper_mod[:num].to_i
+    out_hash[:keep_mode] = ( 'keep_' + ( keeper_mod[:type] || 'best' ) ).to_sym
   end
 
   # Called for any parsed map mode
@@ -170,7 +177,19 @@ class GamesDice::Parser < Parslet::Parser
       return
     end
 
-    # Typical
+    # Typical map_mod: {:map=>"m"@4, :condition=>{:compare_num=>"5"@6}, :num=>"2"@8, :output=>"Qwerty"@10}
+    op = get_op_symbol( map_mod[:condition][:comparison] || '>=' )
+    v = map_mod[:condition][:compare_num].to_i
+    out_val = 1
+    if map_mod[:num]
+      out_val = map_mod[:num].to_i
+    end
+
+    if map_mod[:output]
+      out_hash[:maps] << [ v, op, out_val, map_mod[:output].to_s ]
+    else
+      out_hash[:maps] << [ v, op, out_val ]
+    end
   end
 
   # The dice description language uses (r).op.x, whilst GamesDice::RerollRule uses x.op.(r), so

data/lib/games_dice/version.rb

@@ -1,3 +1,3 @@
 module GamesDice
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/spec/parser_spec.rb

@@ -24,9 +24,9 @@ describe GamesDice::Parser do
 
     it "should parse 'NdXrY' as 'roll N times X-sided dice, re-roll and replace a Y or less (once)'" do
       variations = {
-        '1d6r1' => { :bunches => [{:ndice=>1, :sides=>6, :multiplier=>1, :rerolls=>[ [1,:>=,:reroll_replace,1] ]}], :offset => 0 },
-        '2d20r7' => { :bunches => [{:ndice=>2, :sides=>20, :multiplier=>1, :rerolls=>[ [7,:>=,:reroll_replace,1] ]}], :offset => 0 },
-        '1d8r2' => { :bunches => [{:ndice=>1, :sides=>8, :multiplier=>1, :rerolls=>[ [2,:>=,:reroll_replace,1] ]}], :offset => 0 },
+        '1d6r1' => { :bunches => [{:ndice=>1, :sides=>6, :multiplier=>1, :rerolls=>[ [1,:>=,:reroll_replace] ]}], :offset => 0 },
+        '2d20r7' => { :bunches => [{:ndice=>2, :sides=>20, :multiplier=>1, :rerolls=>[ [7,:>=,:reroll_replace] ]}], :offset => 0 },
+        '1d8r2' => { :bunches => [{:ndice=>1, :sides=>8, :multiplier=>1, :rerolls=>[ [2,:>=,:reroll_replace] ]}], :offset => 0 },
       }
 
       variations.each do |input,expected_output|
@@ -68,7 +68,7 @@ describe GamesDice::Parser do
 
     it "should successfully parse combinations of modifiers in any valid order" do
       variations = {
-        '5d10r1x' => { :bunches => [{:ndice=>5, :sides=>10, :multiplier=>1, :rerolls=>[ [1,:>=,:reroll_replace,1], [10,:==,:reroll_add] ]}], :offset => 0 },
+        '5d10r1x' => { :bunches => [{:ndice=>5, :sides=>10, :multiplier=>1, :rerolls=>[ [1,:>=,:reroll_replace], [10,:==,:reroll_add] ]}], :offset => 0 },
         '3d6xk2' => { :bunches => [{:ndice=>3, :sides=>6, :multiplier=>1, :rerolls=>[ [6,:==,:reroll_add] ], :keep_mode=>:keep_best, :keep_number=>2 }], :offset => 0 },
         '4d6m8x' => { :bunches => [{:ndice=>4, :sides=>6, :multiplier=>1, :maps=>[ [8,:<=,1] ], :rerolls=>[ [6,:==,:reroll_add] ] }], :offset => 0 },
       }

data/spec/readme_spec.rb

@@ -57,6 +57,25 @@ describe GamesDice::Dice do
     end
   end
 
+  describe "#explain_result" do
+    it "attempts to show how the result from the last call to roll was composed" do
+      expected_results = [
+        "3d6: 3 + 6 + 2 = 11",
+        "3d6: 4 + 5 + 6 = 15",
+        "3d6: 3 + 6 + 2 = 11",
+        "3d6: 5 + 6 + 1 = 12"
+        ]
+      expected_results.each do |expected|
+        dice.roll
+        dice.explain_result.should == expected
+      end
+    end
+
+    it "will be nil if no roll has been made yet" do
+      dice.explain_result.should be_nil
+    end
+  end
+
   describe "#max" do
     it "returns the maximum possible value from a roll of the dice" do
       dice.max.should == 18
@@ -210,9 +229,155 @@ describe 'String Dice Description' do
   end
 
   describe "'5d10x'" do
-    it "returns expected results from rolling" do
+    it "is the same as '5d10r:10,add.'" do
+      srand(235241)
       d = GamesDice.create '5d10x'
-      (1..5).map { |n| d.roll }.should == [22, 22, 31, 53, 25]
+      results1 = (1..50).map { d.roll }
+
+      srand(235241)
+      d = GamesDice.create '5d10r:10,add.'
+      results2 = (1..50).map { d.roll }
+
+      results1.should == results2
+    end
+  end
+
+  describe "'1d6r:1.'" do
+    it "should return same as '1d6r1'" do
+      srand(235241)
+      d = GamesDice.create '1d6r:1.'
+      results1 = (1..50).map { d.roll }
+
+      srand(235241)
+      d = GamesDice.create '1d6r1'
+      results2 = (1..50).map { d.roll }
+
+      results1.should == results2
+    end
+  end
+
+  describe "'1d10r:10,replace,1.'" do
+    it "should roll a 10-sided die, re-roll a result of 10 and take the value of the second roll" do
+      d = GamesDice.create '1d10r:10,replace,1.'
+      (1..27).map { d.roll }.should == [2, 3, 4, 7, 6, 7, 4, 2, 6, 3, 7, 5, 6, 7, 6, 6, 5, 9, 4, 9, 8, 3, 1, 6, 7, 1, 1]
+    end
+  end
+
+  describe "'1d20r:<=10,use_best,1.'" do
+    it "should roll a 20-sided die, re-roll a result if 10 or lower, and use best result" do
+      d = GamesDice.create '1d20r:<=10,use_best,1.'
+      (1..20).map { d.roll }.should == [ 18, 19, 20, 20, 3, 11, 7, 20, 15, 19, 6, 16, 17, 16, 15, 11, 9, 15, 20, 16 ]
+    end
+  end
+
+  describe "'5d10r:10,add.k2', '5d10xk2' and '5d10x.k2'" do
+    it "should all be equivalent" do
+      srand(135241)
+      d = GamesDice.create '5d10r:10,add.k2'
+      results1 = (1..50).map { d.roll }
+
+      srand(135241)
+      d = GamesDice.create '5d10xk2'
+      results2 = (1..50).map { d.roll }
+
+      srand(135241)
+      d = GamesDice.create '5d10x.k2'
+      results3 = (1..50).map { d.roll }
+
+      results1.should == results2
+      results2.should == results3
+    end
+  end
+
+  describe "'5d10r:>8,add.'" do
+    it "returns expected results from rolling" do
+      d = GamesDice.create '5d10r:>8,add.'
+      (1..5).map { |n| d.roll }.should == [22, 22, 31, 64, 26]
+    end
+  end
+
+  describe "'9d6x.m:10.'" do
+    it "returns expected results from rolling" do
+      d = GamesDice.create '9d6x.m:10.'
+      (1..5).map { |n| d.roll }.should == [1, 2, 1, 1, 1]
+    end
+    it "can be explained as number of exploding dice scoring 10+" do
+      d = GamesDice.create '9d6x.m:10.'
+      (1..5).map { |n| d.roll; d.explain_result }.should == [
+            "9d6: [6+3] 9, 2, 3, 4, [6+4] 10, 2, [6+3] 9, 3, 5. Successes: 1",
+            "9d6: [6+6+3] 15, [6+5] 11, 2, 1, 4, 2, 1, 3, 5. Successes: 2",
+            "9d6: 1, [6+6+1] 13, 2, 1, 1, 3, [6+1] 7, 5, 4. Successes: 1",
+            "9d6: [6+4] 10, 3, 4, 5, 5, 1, [6+3] 9, 3, 5. Successes: 1",
+            "9d6: [6+3] 9, 3, [6+5] 11, 4, 2, 2, 1, 4, 5. Successes: 1"
+      ]
+    end
+  end
+
+  describe "'9d6x.m:10,1,S.'" do
+    it "returns expected results from rolling" do
+      d = GamesDice.create '9d6x.m:10,1,S.'
+      (1..5).map { |n| d.roll }.should == [1, 2, 1, 1, 1]
+    end
+    it "includes the string 'S' next to each success" do
+      d = GamesDice.create '9d6x.m:10,1,S.'
+      (1..5).map { |n| d.roll; d.explain_result }.should == [
+            "9d6: [6+3] 9, 2, 3, 4, [6+4] 10 S, 2, [6+3] 9, 3, 5. Successes: 1",
+            "9d6: [6+6+3] 15 S, [6+5] 11 S, 2, 1, 4, 2, 1, 3, 5. Successes: 2",
+            "9d6: 1, [6+6+1] 13 S, 2, 1, 1, 3, [6+1] 7, 5, 4. Successes: 1",
+            "9d6: [6+4] 10 S, 3, 4, 5, 5, 1, [6+3] 9, 3, 5. Successes: 1",
+            "9d6: [6+3] 9, 3, [6+5] 11 S, 4, 2, 2, 1, 4, 5. Successes: 1"
+      ]
+    end
+  end
+
+  describe "'5d10m:>=6,1,S.m:==1,-1,F.'" do
+    it "returns expected results from rolling" do
+      d = GamesDice.create '5d10m:>=6,1,S.m:==1,-1,F.'
+      (1..10).map { |n| d.roll }.should == [2, 2, 4, 3, 2, 1, 1, 3, 3, 0]
+    end
+    it "includes the string 'S' next to each success, and 'F' next to each 'fumble'" do
+      d = GamesDice.create '5d10m:>=6,1,S.m:==1,-1,F.'
+      (1..5).map { |n| d.roll; d.explain_result }.should ==  [
+            "5d10: 2, 3, 4, 7 S, 6 S. Successes: 2",
+            "5d10: 7 S, 4, 2, 6 S, 3. Successes: 2",
+            "5d10: 7 S, 5, 6 S, 7 S, 6 S. Successes: 4",
+            "5d10: 6 S, 5, 10 S, 9 S, 4. Successes: 3",
+            "5d10: 10 S, 9 S, 8 S, 3, 1 F. Successes: 2"
+        ]
+    end
+  end
+
+  describe "'4d6k:3.r:1,replace,1.'" do
+    it "represents roll 4 six-sided dice, re-roll any 1s, and keep best 3." do
+      d = GamesDice.create '4d6k:3.r:1,replace,1.'
+      (1..10).map { |n| d.roll }.should == [12, 14, 14, 18, 11, 17, 11, 15, 14, 14]
+    end
+    it "includes re-rolls and keeper choice in explanations" do
+      d = GamesDice.create '4d6k:3.r:1,replace,1.'
+      (1..5).map { |n| d.roll; d.explain_result }.should ==  [
+          "4d6: 6, 3, 2, 3. Keep: 3 + 3 + 6 = 12",
+          "4d6: 4, 6, 4, 2. Keep: 4 + 4 + 6 = 14",
+          "4d6: 6, 3, 3, 5. Keep: 3 + 5 + 6 = 14",
+          "4d6: 6, 6, 3, 6. Keep: 6 + 6 + 6 = 18",
+          "4d6: 5, 2, [1|4] 4, 2. Keep: 2 + 4 + 5 = 11"
+      ]
+    end
+  end
+
+  describe "'2d20k:1,worst.'" do
+    it "represents roll 2 twenty-sided dice, return lowest of the two results" do
+      d = GamesDice.create '2d20k:1,worst.'
+      (1..10).map { |n| d.roll }.should == [18, 6, 2, 3, 5, 10, 15, 1, 7, 10]
+    end
+    it "includes keeper choice in explanations" do
+      d = GamesDice.create '2d20k:1,worst.'
+      (1..5).map { |n| d.roll; d.explain_result }.should ==  [
+          "2d20: 18, 19. Keep: 18",
+          "2d20: 20, 6. Keep: 6",
+          "2d20: 20, 2. Keep: 2",
+          "2d20: 3, 11. Keep: 3",
+          "2d20: 5, 7. Keep: 5"
+      ]
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: games_dice
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-28 00:00:00.000000000 Z
+date: 2013-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -112,7 +112,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4383036419295474875
+      hash: 4046591063539756555
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -121,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4383036419295474875
+      hash: 4046591063539756555
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24