dicechucker 0.6.0 → 0.8.0

data/README.md

@@ -1,53 +1,119 @@
 Dicechucker
 ===========
 
-Dicechucker is a die-rolling library for Ruby that accepts standard die notation (XdY+Z). It can return results either as an integer total, an array of individual die rolls plus the modifier, or as a string describing results in English.
+Dicechucker is a die-rolling library for Ruby that accepts standard
+dice notation (XdYS+Z). S is a fairly new pattern for dice notation
+that refers to special instructions; typically this is either L for
+'drop low' or H for 'drop high'. Dicechucker also supports E for
+'explode'. 
+
+Dicechucker also supports Diesheets, which are collections of diesets
+that can be rolled together. For example, a standard d20 first-level
+character requires seven rolls: one for each of six basic stats, and
+one for hit points. A diesheet can define all seven rolls, so that
+you can generate an entire character all at once.
+
+
+Installation
+------------
+Dicechucker is installed via a gem package: `gem install dicechucker`.
 
 Basic Usage
 -----------
 
-Manually set a Dice object:
-    foo = Dicechucker::Dice.new(number_of_dice, sides_on_die, modifier)
+Please note that usage has changed significantly since the initial
+0.6.0 release:
 
 Parse a string to make a Dice object:
-    foo = Dicechucker::Dice.parse(XdY+Z)`
-
-Basic Rolls:
-    bar = foo.roll  #total only
-    bar = foo.roll(true)  #array of die rolls plus modifier
-    bar = foo.roll_english  #string describing results`
-
-Other Dice methods:
+    foo = Dicechucker.parse(XdYS+Z)
+
+Rolling and getting results:
+    bar = foo.roll  #rolls the dice and gives you a total
+    bar = foo.results  #gives you an array of individual rolls
+    bar = foo.total #gives you the total roll without re-rolling
+    bar = foo.report  #gives you an english description without re-rolling
+    bar = foo.modifier  #gives you only the modifier for the dieset
+    foo.roll  # just rolls the dice
+              # total, results, and report now have different output
+
+Please note that Dicechucker::Dice.new is deprecated. Dice is now a
+parent class that can still be created, but will probably not give you
+the results you're hoping for. Use Dicechucker.parse to create new diesets.
+
+Other Dice Behaviors:
 -------------------
 
-check_dc(dc): rolls the dice and compares them to DC. Returns True if roll is greater than or equal to DC.
-
-drop_high(number_to_drop = 1, individual_results = false): Rolls the dice, and drops the highest number_to_drop results. Returns either a total or an array of individual results.
-
-drop_low(number_to_drop = 1, individual_results = false): Rolls the dice, and drops the lowest number_to_drop results. Returns either a total or an array of individual results.
-
-explode(individual_results = false). Rolls the dice. For each die which has a maximum result (e.g., 6 on a d6), that result is kept and another die is rolled. Returns either a total or an array of individual results.
+Dicechucker imbeds special instructions into the dieset, so that you
+don't need to do anything except .roll the dice. 
 
 Examples
 ------
-To create a die set containing three six-sided dice and a modifier of one:
-    stat_dice = Dicechucker::Dice.new(3, 6, 1)
+Make a dieset comprised of three six-sided dice, with the total
+modified by +1:
+    stat_dice = Dicechucker.parse('3d6+1')
 
-To parse standard notation for same:
-    stat_dice = Dicechucker::Dice.parse('3d6+1')
+To roll the dice and get a total (assume 4, 5, 6 rolled):
+    my_roll = stat_dice.roll  # => 16
 
-To roll the dice and get a total result (assume 4, 5, 6 rolled):
-    stat_dice.roll  # => 16
-
-To roll the dice and get individual dice and the modifier back:
-    stat_dice.roll(true) # => [4, 5, 6, 1]
+To see the individual rolls that got you that total:
+    stat_dice.results # => [4, 5, 6]
 
 To get a plain English result:
-    stat_dice.roll_english # => 'rolled 4, 5, 6 plus one for a total of 16.'
+    stat_dice.report # => 'rolled 4, 5, 6 plus one for a total of 16.'
 
 To roll 4d6+0 and drop the low die (results assume 3, 4, 5, 6 rolled):
-    easy_stat_dice = Dicechucker::Dice.parse('4d6')
-    stat = easy_stat_dice.drop_low  # => 15 
+    easy_stat_dice = Dicechucker.parse('4d6L')
+    stat = easy_stat_dice.roll  # => 15 
+
+If you want to see what the dropped die was:
+    easy_stat_dice.dropped # => 3
+
+Diesheets:
+----------
+
+Diesheets are hash-based for your dice-chucking convenience. 
+
+To set up a die sheet for a standard d20 warrior:
+    warrior = Dicechucker::Diesheet.new({
+        "STR" => "4d6L"
+        "DEX" => "4d6L"
+        "CON" => "4d6L"
+        "INT" => "4d6L"
+        "WIS" => "4d6L"
+        "CHA" => "4d6L"
+        "HP"  => "1d10" })
+    puts warrior  
+        # Gives you the results...
+        #STR = 14
+        #DEX = 12
+        #CON = 15
+        #etc...
+
+Diesheets also support .add to add a dieset, so the above example can
+be shortened greatly:
+    warrior = Dicechucker::Diesheet.new
+    ['STR', 'DEX', 'CON', 'INT', 'WIS', 'CHA'].each do |stat|
+      warrior.add(stat, '4d6L')
+    end
+    warrior.add('HP', '1d10')
+    puts warrior
+
+Finally, each dieset in a diesheet is individually addressable, so if
+you want to see what your warrior rolled for strength - or allow your
+warrior a strength re-roll, you kind GM, you - it's easy to do:
+    warrior['STR'].results  # => [2, 3, 2]
+    warrior['STR'].roll     # => Re-roll that garbage!
+    warrior.puts   # => Gives you the new STR roll and all the other
+                   # => unchanged results
+    
+
+Diesheets are rolled automatically when created. When a dieset is
+added, just that dieset is rolled. When a dieset is removed, nothing
+happens to the rest of the diesets in the diesheet. In other words,
+every dieset is instantiated with a rolled result, but if you want a
+fresh batch of results you'll need to call the .roll method on your 
+diesheet.
+
 
 Copyright
 ---------

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.8.0

data/bin/roll

@@ -1,9 +1,8 @@
 #!/usr/bin/env ruby
 require File.expand_path('../../lib/dicechucker.rb', __FILE__)
-
 begin
-  dice = Dicechucker::Dice.parse(ARGV[0])
-  puts "You #{dice.roll_english}"
+  dice = Dicechucker::parse(ARGV[0])
+  puts "You #{dice.report}"
 rescue => err
   abort "#{err} -- aborting."
 end

data/lib/dicechucker/dice.rb

@@ -1,71 +1,100 @@
-require File.expand_path('../game_logic.rb', __FILE__)
-
 module Dicechucker
   
   class Dice
-    include GameLogic
-
-    class NotationError < ArgumentError
+    attr_accessor :number_of_dice, :sides, :modifier, :results, :total
+    
+    def initialize(dice, sides, modifier)
+      @number_of_dice = dice
+      @sides = sides
+      @modifier = modifier
+      roll
     end
- 
-    PATTERN = /^(?:(?<dice>\d+)d)?(?<size>\d+)(?<mod>[+\-]\d+)?$/
 
-    attr_accessor :dice, :size, :mod
+    def roll
+      roll_dice
+      @total = @results.inject(:+) + @modifier
+    end
 
-    def self.parse(raw)
-      if (match = raw.match(PATTERN))
-        dice = Integer(match[:dice]) rescue 1
-        size = Integer(match[:size]) 
-        mod = Integer(match[:mod]) rescue 0
-        Dice.new(dice, size, mod)
-      else
-        raise NotationError, "Invalid die notation, #{raw}"
+    def report
+      rep = 'rolled '
+      rep << @results.join(', ')
+      if @modifier > 0
+        rep << " plus #{@modifier}"
+      elsif @modifier < 0
+        rep << " minus #{@modifier}"
       end
+      rep << " for a total of #{@total}."
+      rep
     end
-    
-    def initialize(dice, size, mod)
-      @dice = dice
-      @size = size
-      @mod = mod
+
+    def ==(other)
+      [@number_of_dice == other.number_of_dice,
+       @sides == other.sides,
+       @modifier == other.modifier,
+       self.class == other.class].all?
     end
 
-    def roll(individual_rolls = false)
-      dice = roll_dice
-      report(dice, individual_rolls)
+    private
+
+    def roll_dice
+      @results = Array.new(@number_of_dice) { (rand * @sides + 1).to_i}
     end
+    
+  end
+  
+  class DiceDropper < Dice
+    attr_accessor :dropped
 
-    def roll_english
-      dice = roll_dice
-      total = dice.inject(:+) + @mod
-      dice = dice.join(', ')
-      if @mod > 0
-        mod_english = "plus #{@mod} "
-      elsif @mod < 0
-        mod_english = "minus #{@mod.abs} "
-      else
-        mod_english = ''
-      end
-      "rolled #{dice} #{mod_english}for a total of #{total}."
+    def roll
+      roll_dice
+      @dropped = @results.delete_at(@results.index(drop_target))
+      @total = @results.inject(:+) + @modifier
     end
     
-    def ==(other)
-      @dice == other.dice && @size == other.size && @mod == other.mod
+    def report
+      rep = super
+      rep << " Dropped #{@dropped}."
+      rep
     end
 
-    private
+    def drop_target
+      raise NotImplementedError, "drop_target must be overwritten by child classes"
+      #defined only for use by subclasses
+    end
+        
+  end
+  
+  class DiceDropLow < DiceDropper
+    def drop_target
+      @results.min
+    end
+  end
 
-    def report(dice, individual_rolls)
-      if individual_rolls
-        dice << @mod
-      else
-        dice = dice.inject(:+) + @mod
+  class DiceDropHigh < DiceDropper
+    def drop_target
+      @results.max
+    end
+  end
+  
+  class DiceExplode < Dice
+    def roll
+      roll_dice
+      @results.each.with_index do |roll, index|
+        if roll == @sides
+          @results.insert(index + 1, (rand(@sides)+1))
+        end
       end
-      dice
+      @total = @results.inject(:+) + @modifier
     end
-    
-    def roll_dice
-      Array.new(@dice) { (rand * @size + 1).to_i }
+
+  end
+
+  class DieSingle < Dice
+    def report
+      "rolled #{@total}."
     end
   end
+  
 end
 
+ 

data/lib/dicechucker/diesheet.rb

@@ -0,0 +1,44 @@
+module Dicechucker
+
+  class Diesheet
+    attr_accessor :diesets
+
+    def initialize(diesets = {})
+      @diesets = {}
+      diesets.each do |key, value|
+        @diesets[key] = Dicechucker.parse(value)
+      end
+    end
+
+    def [](key)
+      @diesets[key]
+    end
+
+    def add(key, dieset)
+      @diesets[key] = Dicechucker.parse(dieset)
+    end
+
+    def remove(key)
+      @diesets.delete(key)
+    end
+    
+    def roll
+      @diesets.each_value do |value|
+        value.roll
+      end
+    end
+
+    def results
+      to_s
+    end
+        
+    def to_s
+      output = ""
+      @diesets.each do |key, value|
+        output << "#{key.to_s} = #{value.total.to_s}\n"
+      end
+      output
+    end
+
+  end
+end

data/lib/dicechucker.rb

@@ -1,4 +1,45 @@
 module Dicechucker
-  autoload :Dice,      File.expand_path('../dicechucker/dice.rb', __FILE__)
-  autoload :GameLogic, File.expand_path('../dicechucker/game_logic.rb', __FILE__)
+  autoload :Diesheet,  File.expand_path('../dicechucker/diesheet.rb', __FILE__)
+  autoload :Dice,         File.expand_path('../dicechucker/dice.rb', __FILE__)
+  autoload :DieSingle,    File.expand_path('../dicechucker/dice.rb', __FILE__)
+  autoload :DiceDropHigh, File.expand_path('../dicechucker/dice.rb', __FILE__)
+  autoload :DiceDropLow,  File.expand_path('../dicechucker/dice.rb', __FILE__)
+  autoload :DiceExplode,  File.expand_path('../dicechucker/dice.rb', __FILE__)
+
+
+  class NotationError < ArgumentError
+  end
+  
+  PATTERN = /^(?:(?<dice>\d+)d)?(?<size>\d+)(?<logic>[eEhHlL])?(?<mod>[+\-]\d+)?$/
+  
+  def self.parse(raw, reportstyle = :total_only)
+    if (match = raw.match(PATTERN))
+      dice = Integer(match[:dice]) rescue 1
+      size = Integer(match[:size]) 
+      mod = Integer(match[:mod]) rescue 0
+      logic = String(match[:logic]) rescue nil
+      dieset = make_dice(dice, size, logic, mod)
+      dieset.roll
+      dieset
+    else
+      raise NotationError, "Invalid die notation, #{raw}"
+    end
+  end
+  
+  def self.make_dice(dice, size, logic, mod)
+    case logic.upcase
+    when 'L'
+      return DiceDropLow.new(dice, size, mod)
+    when 'H'
+      return DiceDropHigh.new(dice, size, mod)
+    when 'E'
+      return DiceExplode.new(dice, size, mod)
+    end
+    if dice == 1 and mod == 0
+      return DieSingle.new(dice, size, mod)
+    end
+    return Dice.new(dice, size, mod)
+  end
+  
+
 end

data/test/test_dice.rb

@@ -4,49 +4,89 @@ class TestDice < MiniTest::Unit::TestCase
   include Dicechucker
 
   def setup
-    Dice.any_instance.stubs(:rand => 0.5)
+
+  end
+
+  def teardown
+    
   end
   
-  def test_dice_parse_single_implied
-    first = Dice.new(1, 20, 0)
-    second = Dice.parse('20')
+  
+  def test_dice_parse_single_explicit
+    first = DieSingle.new(1, 20, 0)
+    second = Dicechucker.parse('1d20')
     assert_equal first, second
   end
   
-  def test_dice_parse_plural_positive_mod
+  def test_dice_parse_single_implied
+    first = DieSingle.new(1, 20, 0)
+    second = Dicechucker.parse('20')
+    assert first == second
+  end
+  
+  def test_dice_parse_instructions
+    exploder = Dicechucker.parse('6d10E')
+    drop_low = Dicechucker.parse('4d6L')
+    drop_high = Dicechucker.parse('4d3H+2')
+    assert_equal exploder.class, Dicechucker::DiceExplode
+    assert_equal drop_low.class, Dicechucker::DiceDropLow
+    assert_equal drop_high.class, Dicechucker::DiceDropHigh
+  end
+
+  def test_dice_parse_plural_negative_mod
     first = Dice.new(2, 20, -4)
-    second = Dice.parse('2d20-4')
+    second = Dicechucker.parse('2d20-4')
     assert_equal first, second
   end
 
   def test_dice_parse_large_numbers
     first = Dice.new(300, 5000, 2000)
-    second = Dice.parse('300d5000+2000')
+    second = Dicechucker.parse('300d5000+2000')
     assert_equal first, second
   end
   
-  def test_dice_average_single
+  def test_die_roll_single
     testroll = Dice.new(1, 6, 0)
+    testroll.stubs(:rand => 0.5)
     assert_equal testroll.roll, 4
-    
   end
 
   def test_dice_roll_plural
     testroll = Dice.new(2, 6, 0)
+    testroll.stubs(:rand => 0.5)
     assert_equal testroll.roll, 8
   end
 
   def test_dice_average_plural_mod
     testroll = Dice.new(2, 6, 2)
+    testroll.stubs(:rand => 0.5)
     assert_equal testroll.roll, 10
   end
 
-  def test_dice_roll_english
+  def test_dice_roll_report
     testroll = Dice.new(2, 20, 4)
-    result = testroll.roll_english
+    testroll.stubs(:rand => 0.5)
+    testroll.roll
+    result = testroll.report
     sample = 'rolled 11, 11 plus 4 for a total of 26.'
     assert_equal result, sample
   end
 
+  def test_dice_drop_low
+    testroll = Dicechucker.parse('4d6L')
+    testroll.stubs(:rand => 0.5)
+    testroll.roll
+    assert_equal testroll.total, 12
+    assert_equal testroll.dropped, 4
+    assert_equal testroll.report, 'rolled 4, 4, 4 for a total of 12. Dropped 4.'
+  end
+
+  def test_single_die_report
+    testroll = Dicechucker.parse('20')
+    testroll.stubs(:rand => 0.5)
+    testroll.roll
+    assert_equal testroll.report, 'rolled 11.'
+  end
+
 end
 

data/test/test_diesheet.rb

@@ -0,0 +1,61 @@
+require 'helper'
+
+class TestDice < MiniTest::Unit::TestCase
+  include Dicechucker
+
+  def test_diesheet_initialize
+    warrior_dice = Diesheet.new({'STR' => '4d6L',
+                                  'DEX' => '4d6L',
+                                  'CON' => '4d6L',
+                                  'INT' => '4d6L',
+                                  'WIS' => '4d6L',
+                                  'CHA' => '4d6L',
+                                  'HP' => '1d10+3'})
+    assert_equal warrior_dice.diesets['STR'].class, DiceDropLow
+    assert_equal warrior_dice.diesets['HP'].class, Dice
+  end
+
+  def test_diesheet_add
+    warrior_dice = Diesheet.new
+    ['STR', 'DEX', 'CON', 'INT', 'WIS', 'CHA'].each do |stat|
+      warrior_dice.add(stat, '4d6L')
+    end
+    warrior_dice.add('HP', '1d10+3')
+    assert_equal warrior_dice.diesets['STR'].class, DiceDropLow
+    assert_equal warrior_dice.diesets['HP'].class, Dice
+  end
+
+  def test_diesheet_remove
+    dummy_dice = Diesheet.new('First' => '2d6', 'Second' => '2d6')
+    dummy_dice.remove('Second')
+    assert_equal dummy_dice['Second'], nil
+    assert_equal dummy_dice['First'].class, Dice
+  end
+  
+
+  def test_diesheet_accessibility
+    warrior_dice = Diesheet.new
+    ['STR', 'DEX', 'CON', 'INT', 'WIS', 'CHA'].each do |stat|
+      warrior_dice.add(stat, '4d6L')
+    end
+    warrior_dice.add('HP', '1d10+3')
+    assert_equal warrior_dice['STR'].class, DiceDropLow
+    assert_equal warrior_dice['HP'].class, Dice
+    assert_equal warrior_dice['STR'].total.class, Fixnum
+    assert_equal warrior_dice['STR'].results.class, Array
+  end
+
+  def test_diesheet_roll
+    dummydice = Diesheet.new('First' => '1d6', 'Second' => '1d6')
+    dummydice.roll
+  end
+  
+  def test_diesheet_to_s
+    dummydice = Diesheet.new('First' => '1d6', 'Second' => '2d6')
+    output = dummydice.to_s
+    assert_equal output.class, String
+  end
+  
+  
+  
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 6
+  - 8
   - 0
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Mark Tabler
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-06 00:00:00 -07:00
+date: 2010-10-20 00:00:00 -07:00
 default_executable: roll
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -48,10 +48,10 @@ files:
 - bin/roll
 - lib/dicechucker.rb
 - lib/dicechucker/dice.rb
-- lib/dicechucker/game_logic.rb
+- lib/dicechucker/diesheet.rb
 - test/helper.rb
 - test/test_dice.rb
-- test/test_game_logic.rb
+- test/test_diesheet.rb
 has_rdoc: true
 homepage: http://github.com/marktabler/dicechucker
 licenses: []
@@ -86,5 +86,5 @@ specification_version: 3
 summary: dice notation (XdY+Z) library
 test_files: 
 - test/helper.rb
-- test/test_game_logic.rb
+- test/test_diesheet.rb
 - test/test_dice.rb

data/lib/dicechucker/game_logic.rb

@@ -1,29 +0,0 @@
-module Dicechucker
-  module GameLogic
-
-    def check_dc(dc)
-      self.roll >= dc
-    end
-    
-    def explode(individual_rolls = false)
-      dice = roll_dice
-      dice.each do |roll|
-        if roll == @size
-          dice << (rand(@size)+1)
-        end
-      end
-      report(dice, individual_rolls) 
-    end
-    
-    def drop_high(number_to_drop = 1, individual_rolls = false)
-      dice = roll_dice.sort.reverse.drop(number_to_drop)
-      report(dice, individual_rolls)
-    end
-    
-    def drop_low(number_to_drop = 1, individual_rolls = false)
-      dice = roll_dice.sort.drop(number_to_drop)
-      report(dice, individual_rolls)
-    end
-
-  end
-end

data/test/test_game_logic.rb

@@ -1,33 +0,0 @@
-require 'helper'
-
-class TestLogic < MiniTest::Unit::TestCase
-  include Dicechucker
-
-  def setup
-    Dice.any_instance.stubs(:rand => 0.5)
-  end
-
-  def test_dice_drop_low
-    testroll = Dice.new(100, 6, 0)
-    result = testroll.drop_low(10, true)
-    assert_equal result.size, 91 #90 dice plus 1 modifier of 0
-  end
-
-  def test_dice_drop_high
-    testroll = Dice.new(100, 6, 0)
-    result = testroll.drop_high(10, true)
-    assert_equal result.size, 91 #90 dice plus 1 modifier of 0
-  end
-
-  def test_explode
-    testroll = Dice.new(100, 6, 0)
-    result = testroll.explode(true)
-    assert_equal result.size, 101 #all random rolls are 4, nothing explodes
-  end
-
-  def test_check_dc
-    testroll = Dice.new(1, 20, 2)
-    assert testroll.check_dc(14) == false
-    assert testroll.check_dc(13) == true
-  end
-end