games_dice 0.1.2 → 0.1.3

data/README.md

@@ -54,11 +54,10 @@ Or install it yourself as:
 ## Library API
 
 Although you can refer to the documentation for the contained classes, and use it if needed to
-build some exotic dice systems, the recommended way to use GamesDice is to create GamesDice::Dice
-objects via the factory methods from the GamesDice module, and then use those objects to simulate
-dice rolls, explain the results or calculate probabilties as required.
+build some exotic dice systems, all you need to know to access the core features is described
+here.
 
-### GamesDice factory methods
+### GamesDice factory method
 
 #### GamesDice.create
 
@@ -217,23 +216,54 @@ A die modifier can also be a single letter plus an integer value, e.g.
 
     1d6r1
 
-More complex die modifiers are possible, with parameters supplied in square brackets, and multiple
-modifiers should combine as expected e.g.
+You can add comma-seperated parameters to a modifier by using a ":" (colon) character after the
+modifier letter, and a "." (full stop) to signify the end of the parameters. What parameters are
+accepted, and what they mean, depends on the modifier:
 
-    5d10r[10,add]k2
+    5d10r:>8,add.
+
+You can use more than one modifier. Modifiers should be separated by a "." (full stop) character, although
+this is optional if you use modifiers without parameters:
+
+    5d10r:10,add.k2
+    5d10xk2
+    5d10x.k2
+
+are all equivalent.
 
 #### Rerolls
 
 You can specify that dice rolling certain values should be re-rolled, and how that re-roll should be
 interpretted.
 
-The simple form specifies a low value that will automatically trigger a one-time replacement:
+The simple form specifies a low value that will automatically trigger a re-roll and replace:
 
     1d6r1
 
 When rolled, this die will score from 1 to 6. If it rolls a 1, it will roll again automatically
 and use that result instead.
 
+The full version of this modifier, allows you to specify from 1 to 3 parameters:
+
+    1d10r:[VALUE_COMPARISON],[REROLL_TYPE],[LIMIT].
+
+Where:
+
+ * VALUE_COMPARISON is one of >, >=, == (default), <= < plus an integer to set conditions on when the reroll should occur
+ * REROLL_TYPE is one of
+  * replace (default) - use the new value in place of existing value for the die
+  * 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
+ * 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.    #
+    1d20r:<=10,use_best,1. # Roll a 20-sided die, re-roll a result if 10 or lower, and use best result
+
 #### Maps
 
 You can specify that the value shown on each die is converted to some other set of values. If
@@ -264,7 +294,7 @@ short codes.
 
 This is an alias for "exploding" dice:
 
-    5d10x
+    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.

data/lib/games_dice/parser.rb

@@ -3,16 +3,17 @@ require 'parslet'
 # converts string dice descriptions to data usable for the GamesDice::Dice constructor
 class GamesDice::Parser < Parslet::Parser
 
-  # Descriptive language examples (capital letters stand in for integers)
-  #  NdXk[Z,worst]     -  a roll of N dice, sides X, keep worst Z results and sum them
-  #  NdXr[Z,add]       -  a roll of N dice, sides X, re-roll and add on a result of Z
-  #  NdXr[Y..Z,add]    -  a roll of N dice, sides X, re-roll and add on a result of Y..Z
-  #  NdXm[>=Z,A]       -  mapped dice, values greater than or equal to Z score A (unmapped values score 0 by default)
+  # 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.
 
-  # These are the Parslet rules that define the dice grammar
   rule(:integer) { match('[0-9]').repeat(1) }
   rule(:range) { integer.as(:range_start) >> str('..') >> integer.as(:range_end) }
   rule(:dlabel) { match('[d]') }
+  rule(:space) { match('\s').repeat(1) }
+  rule(:space?) { space.maybe }
+  rule(:underscore) { str('_').repeat(1) }
+  rule(:underscore?) { space.maybe }
+
   rule(:bunch_start) { integer.as(:ndice) >> dlabel >> integer.as(:sides) }
 
   rule(:reroll_label) { match(['r']).as(:reroll) }
@@ -23,12 +24,33 @@ class GamesDice::Parser < Parslet::Parser
   rule(:single_modifier) { alias_label }
   rule(:modifier_label) {  reroll_label | keep_label | map_label }
   rule(:simple_modifier) { modifier_label >> integer.as(:simple_value) }
-  rule(:complex_modifier) { modifier_label >> str('[') >> str(']') } # TODO: param extraction
+  rule(:comparison_op) { str('>=') | str('<=') | str('==') | str('>') | str('<') }
+  rule(:ctl_string) { match('[a-z_]').repeat(1) }
+  rule(:output_string) { match('[A-Za-z0-9_]').repeat(1) }
+
+  rule(:opint_or_int) { (comparison_op.as(:comparison) >> integer.as(:compare_num)) | integer.as(:compare_num) }
+  rule(:comma) { str(',') }
+  rule(:stop) { str('.') }
+
+  rule(:condition_only) { opint_or_int.as(:condition) }
+
+  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_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(:reroll_params) { condition_type_and_num | condition_and_type | condition_only }
+  rule(:map_params) { condition_num_and_output | condition_and_num | condition_only }
+
+  rule(:full_reroll) { reroll_label >> str(':') >> reroll_params >> stop }
+  rule(:full_map) { map_label >> str(':') >> map_params >> stop }
+
+  rule(:complex_modifier) { full_reroll | full_map }
 
-  rule(:bunch_modifier) { single_modifier | simple_modifier }
+  rule(:bunch_modifier) { complex_modifier | ( single_modifier >> stop.maybe ) | ( simple_modifier >> stop.maybe ) }
   rule(:bunch) { bunch_start >> bunch_modifier.repeat.as(:mods) }
-  rule(:space) { match('\s').repeat(1) }
-  rule(:space?) { space.maybe }
+
   rule(:operator) { match('[+-]').as(:op) >> space? }
   rule(:add_bunch) { operator >> bunch >> space? }
   rule(:add_constant) { operator >> integer.as(:constant) >> space? }
@@ -116,8 +138,18 @@ class GamesDice::Parser < Parslet::Parser
     out_hash[:rerolls] ||= []
     if reroll_mod[:simple_value]
       out_hash[:rerolls] << [ reroll_mod[:simple_value].to_i, :>=, :reroll_replace, 1 ]
+      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
+    type = ( 'reroll_' + ( reroll_mod[:type] || 'replace' ) ).to_sym
+
+    if reroll_mod[:num]
+      out_hash[:rerolls] << [ v, op, type, reroll_mod[:num].to_i ]
+    else
+      out_hash[:rerolls] << [ v, op, type ]
     end
-    # TODO: Handle complex descriptions
   end
 
   # Called for any parsed keeper mode
@@ -137,7 +169,22 @@ class GamesDice::Parser < Parslet::Parser
       out_hash[:maps] << [ map_mod[:simple_value].to_i, :<=, 1 ]
       return
     end
-    # TODO: Handle complex descriptions
+
+    # Typical
+  end
+
+  # The dice description language uses (r).op.x, whilst GamesDice::RerollRule uses x.op.(r), so
+  # as well as converting to a symbol, we must reverse sense of input to constructor
+  OP_CONVERSION = {
+    '==' => :==,
+    '>=' => :<=,
+    '>' => :<,
+    '<' => :>,
+    '<=' => :>=,
+  }
+
+  def get_op_symbol parsed_op_string
+    OP_CONVERSION[ parsed_op_string.to_s ]
   end
 
 end # class Parser

data/lib/games_dice/version.rb

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

data/spec/readme_spec.rb

@@ -146,3 +146,74 @@ describe GamesDice::Probabilities do
   end
 
 end  # describe GamesDice::Probabilities
+
+describe 'String Dice Description' do
+
+  before :each do
+    srand(35241)
+  end
+
+  describe "'1d6'" do
+    it "returns expected results from rolling" do
+      d = GamesDice.create '1d6'
+      (1..20).map { |n| d.roll }.should == [6, 3, 2, 3, 4, 6, 4, 2, 6, 3, 3, 5, 6, 6, 3, 6, 5, 2, 1, 4]
+    end
+  end
+
+  describe "'2d6 + 1d4'" do
+    it "returns expected results from rolling" do
+      d = GamesDice.create '2d6 + 1d4'
+      (1..5).map { |n| d.roll }.should == [11, 10, 12, 12, 14]
+    end
+  end
+
+  describe "'1d100 + 1d20 - 5'" do
+    it "returns expected results from rolling" do
+      d = GamesDice.create '1d100 + 1d20 - 5'
+      (1..5).map { |n| d.roll }.should == [75, 78, 24, 102, 32]
+    end
+  end
+
+  describe "'1d10x'" do
+    it "returns expected results from rolling" do
+      d = GamesDice.create '1d10x'
+      (1..20).map { |n| d.roll }.should == [2, 3, 4, 7, 6, 7, 4, 2, 6, 3, 7, 5, 6, 7, 6, 6, 5, 19, 4, 19]
+    end
+  end
+
+  describe "'1d6r1'" do
+    it "returns expected results from rolling" do
+      d = GamesDice.create '1d6r1'
+      (1..20).map { |n| d.roll }.should == [6, 3, 2, 3, 4, 6, 4, 2, 6, 3, 3, 5, 6, 6, 3, 6, 5, 2, 4, 2]
+    end
+  end
+
+  describe "'5d10r:10,add.k2'" do
+    it "returns expected results from rolling" do
+      d = GamesDice.create '5d10r:10,add.k2'
+      (1..5).map { |n| d.roll }.should == [13, 13, 14, 38, 15]
+    end
+  end
+
+  describe "'3d10m6'" do
+    it "returns expected results from rolling" do
+      d = GamesDice.create '3d10m6'
+      (1..6).map { |n| d.roll }.should == [0, 3, 1, 1, 3, 2]
+    end
+  end
+
+  describe "'5d10k2'" do
+    it "returns expected results from rolling" do
+      d = GamesDice.create '5d10k2'
+      (1..5).map { |n| d.roll }.should == [13, 13, 14, 19, 19]
+    end
+  end
+
+  describe "'5d10x'" do
+    it "returns expected results from rolling" do
+      d = GamesDice.create '5d10x'
+      (1..5).map { |n| d.roll }.should == [22, 22, 31, 53, 25]
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: games_dice
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-21 00:00:00.000000000 Z
+date: 2013-05-28 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: -2496597161129373974
+      hash: -4383036419295474875
 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: -2496597161129373974
+      hash: -4383036419295474875
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24