dicebag 3.2.1 → 3.3.0

data/lib/dicebag/roll_part.rb

@@ -1,5 +1,4 @@
-# Encoding: UTF-8
-
+# DiceBag Module
 module DiceBag
   # This represents the xDx part of the dice string.
   class RollPart < SimplePart
@@ -10,42 +9,49 @@ module DiceBag
     attr_reader :parts
     attr_reader :options
     attr_reader :tally
+    attr_reader :reroll_count
 
     def initialize(part)
-      @total  = nil
-      @tally  = []
-      @value  = part
-      @count  = part[:count]
-      @sides  = part[:sides]
-      @notes  = part[:notes] || []
+      super part
 
-      # Our Default Options
-      @options = { explode: 0, drop: 0, keep: 0, reroll: 0, target: 0 }
+      @total   = nil
+      @tally   = []
+      @count   = part[:count]
+      @sides   = part[:sides]
+      @notes   = part[:notes]
+      @options = default_options
 
       @options.update(part[:options]) if part.key?(:options)
     end
 
+    # Our Default Options
+    #
+    # Note the absence of :explode, that is handled below.
+    def default_options
+      {
+        drop:       0,
+        keep:       0,
+        keeplowest: 0,
+        reroll:     0,
+        target:     0,
+        failure:    0
+      }
+    end
+
     def notes
       @notes.empty? ? '' : @notes.join("\n")
     end
 
-    # Checks to see if this instance has rolled yet
-    # or not.
+    # Checks to see if this instance has rolled yet or not.
     def rolled?
       @total.nil? ? false : true
     end
 
-    # Rolls a single die from the xDx string.
-    def roll_die
-      num = 0
-      num = rand(sides) + 1 while num <= @options[:reroll]
-
-      num
-    end
-
     def roll
       generate_results
 
+      return __roll_for_keep_lowest if @options[:keeplowest].positive?
+
       @results.sort!
       @results.reverse!
 
@@ -60,12 +66,21 @@ module DiceBag
 
       # Set the total.
       handle_total
+    end
 
-      self
+    def __roll_for_keep_lowest
+      @tally = @results.dup
+
+      @tally.sort!
+      @tally.reverse!
+      @results.sort!
+
+      handle_keeplowest
+      handle_total
     end
 
-    # Gets the total of the last roll; if there is no
-    # last roll, it calls roll() first.
+    # Gets the total of the last roll; if there is no last roll, it
+    # calls roll() first.
     def total
       roll if @total.nil?
 
@@ -81,25 +96,43 @@ module DiceBag
     def generate_results
       @results = []
 
+      explode = @options.key?(:explode)
+
       count.times do
-        r = roll_die
+        roll = roll_die
 
-        @results.push(r)
+        @results.push(roll)
 
-        handle_explode(r) unless @options[:explode].zero?
+        handle_explode(roll) if explode
       end
     end
 
-    def handle_explode(r)
-      while r >= @options[:explode]
-        r = roll_die
+    # Rolls a single die from the xDx string.
+    def roll_die
+      num = __roll_die
 
-        @results.push(r)
+      # Handle Reroll
+      if options[:reroll].positive?
+        num = __roll_die while num <= @options[:reroll]
+      end
+
+      num
+    end
+
+    def handle_explode(roll)
+      # If the explode value is nil (allowed!) then default to the
+      # number of sides.
+      val = @options[:explode] || sides
+
+      while roll >= val
+        roll = roll_die
+
+        @results.push(roll)
       end
     end
 
     def handle_drop
-      return unless @options[:drop] > 0
+      return unless @options[:drop].positive?
 
       # Note that we invert the drop value here.
       range = 0...-(@options[:drop])
@@ -108,23 +141,60 @@ module DiceBag
     end
 
     def handle_keep
-      return unless @options[:keep] > 0
+      return unless @options[:keep].positive?
 
       range = 0...@options[:keep]
 
       @results = @results.slice range
     end
 
+    def handle_keeplowest
+      return unless @options[:keeplowest].positive?
+
+      range = 0...@options[:keeplowest]
+
+      @results = @results.slice range
+    end
+
+    # If we have a target number, count how many rolls in the results
+    # are >= than this number and subtract the number <= the failure
+    # threshold, otherwise we just add up all the numbers.
     def handle_total
-      # If we have a target number, count how many rolls
-      # in the results are >= than this number, otherwise
-      # we just add up all the numbers.
-      @total = if @options[:target] && @options[:target] > 0
-                 @results.count { |r| r >= @options[:target] }
-               else
-                 # I think reduce(:+) is ugly, but it's very fast.
-                 @results.reduce(:+)
-               end
+      tpos = @options[:target].positive?
+      fpos = @options[:failure].positive?
+
+      # Just add up the results.
+      return __simple_total unless tpos || fpos
+
+      # Add up successes and subtract failures.
+      return __target_and_failure_total if tpos
+
+      # Just tally failures.
+      @total = 0 - __failure_total
+    end
+
+    def __roll_die
+      rand(sides) + 1
+    end
+
+    def __simple_total
+      # I think reduce(:+) is ugly, but it's very fast.
+      @total = @results.reduce(:+)
+    end
+
+    def __target_and_failure_total
+      tcount = __target_total
+      fcount = __failure_total
+
+      @total = tcount - fcount
+    end
+
+    def __target_total
+      @results.count { |r| r >= @options[:target] }
+    end
+
+    def __failure_total
+      @results.count { |r| r <= @options[:failure] }
     end
   end
 end

data/lib/dicebag/roll_part_string.rb

@@ -1,11 +1,8 @@
-# Encoding: UTF-8
-
-# This encapsulates the RollPart string
-# generation methods.
+# This encapsulates the RollPart string generation methods.
 module RollPartString
-  # This takes the @parts hash and recreates the xDx
-  # string. Optionally, passing true to the method will
-  # remove spaces form the finished string.
+  # This takes the @parts hash and recreates the xDx string. Optionally,
+  # passing true to the method will remove spaces from the finished
+  # string.
   def to_s(no_spaces = false)
     @parts = []
 
@@ -13,14 +10,20 @@ module RollPartString
     to_s_explode
     to_s_drop
     to_s_keep
+    to_s_keeplowest
     to_s_reroll
     to_s_target
+    to_s_failure
 
     join_str = no_spaces ? '' : ' '
 
     @parts.join join_str
   end
 
+  def inspect
+    "<#{self.class.name} #{self}>"
+  end
+
   private
 
   def to_s_xdx
@@ -31,11 +34,11 @@ module RollPartString
   end
 
   def to_s_explode
-    return if @options[:explode].zero?
+    return unless @options.key?(:explode)
 
-    e = (@options[:explode] == sides) ? @options[:explode] : ''
+    e = @options[:explode].nil? ? 'e' : format('e%s', @options[:explode])
 
-    @parts.push format('e%s', e)
+    @parts.push e
   end
 
   def to_s_drop
@@ -50,6 +53,12 @@ module RollPartString
     @parts.push format('k%s', @options[:keep])
   end
 
+  def to_s_keeplowest
+    return if @options[:keeplowest].zero?
+
+    @parts.push format('kl%s', @options[:keeplowest])
+  end
+
   def to_s_reroll
     return if @options[:reroll].zero?
 
@@ -61,4 +70,10 @@ module RollPartString
 
     @parts.push format('t%s', @options[:target])
   end
+
+  def to_s_failure
+    return if @options[:failure].zero?
+
+    @parts.push format('f%s', @options[:failure])
+  end
 end

data/lib/dicebag/roll_string.rb

@@ -1,7 +1,4 @@
-# Encoding: UTF-8
-
-# This encapsulates the Roll class' string
-# generation methods.
+# This encapsulates the Roll class' string generation methods.
 module RollString
   def to_s(no_spaces = false)
     @parts = []
@@ -13,6 +10,10 @@ module RollString
     no_spaces ? str.tr(' ', '') : str
   end
 
+  def inspect
+    "<#{self.class.name} #{self}>"
+  end
+
   private
 
   def to_s_tree
@@ -30,22 +31,22 @@ module RollString
   end
 
   def to_s_add(value)
-    _op_value '+', value
+    __op_value '+', value
   end
 
   def to_s_sub(value)
-    _op_value '-', value
+    __op_value '-', value
   end
 
   def to_s_mul(value)
-    _op_value '*', value
+    __op_value '*', value
   end
 
   def to_s_div(value)
-    _op_value '/', value
+    __op_value '/', value
   end
 
-  def _op_value(op, value)
-    "#{op}#{value}"
+  def __op_value(oper, value)
+    "#{oper}#{value}"
   end
 end

data/lib/dicebag/simple_part.rb

@@ -1,8 +1,7 @@
 module DiceBag
-  # The most simplest of a part. If a given part of
-  # a dice string is not a Label, Fixnum, or a xDx part
-  # it will be an instance of this class, which simply
-  # returns the value given to it.
+  # The most simplest of a part. If a given part of a dice string is not
+  # a Label, Fixnum, or a xDx part it will be an instance of this class,
+  # which simply returns the value given to it.
   class SimplePart
     attr_reader :value
 
@@ -17,5 +16,9 @@ module DiceBag
     def to_s
       value
     end
+
+    def inspect
+      "<#{self.class.name} #{self}>"
+    end
   end
 end

data/lib/dicebag/static_part.rb

@@ -1,10 +1,11 @@
+# DiceBag module
 module DiceBag
-  # This represents a static, non-random number part
-  # of the dice string.
+  # This represents a static, non-random number part of the dice string.
   class StaticPart < SimplePart
     def initialize(num)
-      num    = num.to_i if num.is_a?(String)
-      @value = num
+      num = num.to_i if num.is_a?(String)
+
+      super num
     end
 
     def total
@@ -14,5 +15,9 @@ module DiceBag
     def to_s
       value.to_s
     end
+
+    def inspect
+      "<#{self.class.name} #{self}>"
+    end
   end
 end

data/lib/dicebag/systems/dnd.rb

@@ -0,0 +1,65 @@
+# This models a D20 roll used in various D&D versions for rolling a d20
+# +/-mod to equal or exceed a DC value.
+#
+# This is a very simple version, but could easily be expanded on.
+#
+# Usage:
+#
+#     die = D20.new
+#
+#     die.roll 5, 15  => [:success, 17]
+#     die.roll -3, 12 => [:fail, 9]
+class D20
+  attr_reader :mod
+  attr_reader :dc
+
+  def self.roll(mod = 0, difficulty = 10)
+    new(mod, difficulty).roll
+  end
+
+  def initialize(mod = 0, difficulty = 10)
+    @mod   = mod.to_i
+    @dc    = difficulty.to_i
+    @dstr  = "1d20 #{stringify_mod}"
+    @roll  = DiceBag::Roll.new @dstr
+  end
+
+  def roll
+    total = roll_for_result.total
+    sym   = total >= dc ? :success : :failure
+
+    [sym, total]
+  end
+
+  def stringify_mod
+    return "+#{@mod}" if @mod.positive?
+
+    return @mod.to_s  if @mod.negative?
+
+    ''
+  end
+
+  def roll_for_result
+    @roll.roll
+  end
+end
+
+# Roll a d20 with Advantage
+class D20Advantage < D20
+  def roll_for_result
+    r1 = @roll.roll
+    r2 = @roll.roll
+
+    r1 > r2 ? r1 : r2
+  end
+end
+
+# Roll a d20 with Disadvantage
+class D20Disadvantage < D20
+  def roll_for_result
+    r1 = @roll.roll
+    r2 = @roll.roll
+
+    r1 < r2 ? r1 : r2
+  end
+end

data/lib/dicebag/systems/fudge.rb

@@ -0,0 +1,80 @@
+require 'dicebag'
+
+# This handles Fudge RPG type of rolls.
+#
+# This probably isn't (it *totally* isn't!) the most effecient way to do
+# this, but shows how to examine DiceBag objects to get what you need
+# for wonky dice systems.
+module Fudge
+  # This models a standard Fudge RPG dice pool.
+  class Roll < DiceBag::Roll
+    def initialize(number = 4)
+      @number = number
+      @total  = nil
+      @tally  = nil
+
+      # This is a very silly way to do this, since there is no need to
+      # actually add the dice together here. But we need all of the d6's
+      # together in the same roll.
+      dstr = (['1d6'] * number).join(' + ')
+
+      super(dstr)
+    end
+
+    def roll
+      super
+
+      generate_tally
+
+      @total = @tally.count('+') - @tally.count('-')
+
+      [@total, tally_to_s]
+    end
+
+    def total
+      roll unless @total
+
+      @total
+    end
+
+    def tally
+      roll unless @tally
+
+      @tally
+    end
+
+    def to_s
+      base = "#{@number}dF"
+
+      "#{base} #{tally_to_s} => #{@total}" if @total
+
+      base
+    end
+
+    private
+
+    def generate_tally
+      @tally = @sections.map { |s| gen_symbol s.total }.sort.reverse
+    end
+
+    def gen_symbol(total)
+      case total
+      when 1, 2 then '-'
+      when 3, 4 then ' '
+      when 5, 6 then '+'
+      end
+    end
+
+    def tally_to_s
+      return '[]' unless @tally
+
+      "[#{@tally.join('][')}]"
+    end
+  end
+
+  DF = Roll.new
+
+  def self.roll(num = 4)
+    Roll.new(num).roll
+  end
+end

data/lib/dicebag/systems/gurps.rb

@@ -0,0 +1,52 @@
+require 'dicebag'
+
+# This models the standard GURPS 3d6 dice pool used for attribute/skill
+# tests.
+#
+# This will return an array of [status, result] where:
+# - status is one of:
+#   :success, :failure, :critical_success, or :critical_failure
+# - result is the actual dice roll total.
+class GURPS < DiceBag::Roll
+  def self.roll(target, mod = 0)
+    new.roll(target, mod)
+  end
+
+  def initialize
+    super('3d6')
+  end
+
+  def roll(target, mod = 0)
+    mod = 0 unless mod.is_a?(Integer)
+
+    @total_target = target + mod
+    @total        = super().total
+
+    figure_success
+    figure_failure
+
+    [figure_result, @total]
+  end
+
+  private
+
+  def figure_success
+    @crit_success = [3, 4]
+
+    @crit_success.push(5) if @total_target >= 15
+    @crit_success.push(6) if @total_target >= 16
+  end
+
+  def figure_failure
+    @crit_failure = [18]
+
+    @crit_failure.push(17) if @total_target <= 15
+  end
+
+  def figure_result
+    return :critical_success if @crit_success.include?(@total)
+    return :critical_failure if @crit_failure.include?(@total)
+
+    @total <= @total_target ? :success : :failure
+  end
+end

data/lib/dicebag/systems/savage_worlds.rb

@@ -0,0 +1,31 @@
+require 'dicebag'
+
+module SavageWorlds
+  # Models a single Savage World die, with attributes for max and half
+  # values.
+  #
+  # Since all Savage Worlds Trait (Attributes + Skills) dice can
+  # explode, that option is included automatically.
+  class SWDie < DiceBag::Roll
+    attr_reader :maximum
+    attr_reader :half
+
+    def initialize(sides, mod = 0)
+      @maximum = sides
+      @half    = (sides / 2) + (mod / 2)
+
+      dstr = mod.zero? ? "1d#{sides}e" : "1d#{sides}e #{mod}"
+
+      super(dstr)
+    end
+  end
+
+  D4             = SWDie.new(4)
+  D6             = SWDie.new(6)
+  D8             = SWDie.new(8)
+  D10            = SWDie.new(10)
+  D12            = SWDie.new(12)
+  WildDie        = SWDie.new(6)
+  NoTrait        = SWDie.new(4, -2)
+  NoTraitWildDie = SWDie.new(6, -2)
+end

data/lib/dicebag/systems/standard.rb

@@ -0,0 +1,19 @@
+require 'dicebag'
+
+# Module for standard polyhedral dice types.
+module Standard
+  # Models a single, simple die.
+  class Die < DiceBag::Roll
+    def initialize(sides)
+      super("1d#{sides}")
+    end
+  end
+
+  D4   = Die.new(4)
+  D6   = Die.new(6)
+  D8   = Die.new(8)
+  D10  = Die.new(10)
+  D12  = Die.new(12)
+  D20  = Die.new(20)
+  D100 = Die.new(100)
+end

data/lib/dicebag/systems/storyteller.rb

@@ -0,0 +1,45 @@
+require 'dicebag'
+
+# This is actually modeling the "Storytelling" system dice, not the
+# older "Storyteller" system dice, but I personally find "Storytelling"
+# kind of a silly name, so I prefer the older name. :D
+module Storyteller
+  # This is a models a pool of Storyteller dice.
+  class Pool < DiceBag::Roll
+    def initialize(number = 1, success = 8)
+      @number  = number
+      @success = success
+      @result  = nil
+
+      super("#{number}d10e t#{success}")
+    end
+
+    def roll
+      @result = super
+    end
+
+    def successes
+      roll unless @result
+
+      @result.total
+    end
+
+    def tally
+      roll unless @result
+
+      @result.sections[0].tally
+    end
+
+    def to_s
+      "#{@number}d10/#{@success}"
+    end
+  end
+
+  def self.roll(number = 1, success = 8)
+    Pool.new(number, success).roll
+  end
+
+  def self.chance
+    Pool.new(1, 10).roll
+  end
+end