fifthed_sim 0.1.0 → 0.2.0

data/lib/fifthed_sim/nodes/less_node.rb

@@ -0,0 +1,46 @@
+require_relative '../dice_expression'
+require_relative '../calculated_fixnum'
+
+module FifthedSim
+  class LessNode < DiceExpression
+    using CalculatedFixnum
+
+    def initialize(lhs, rhs)
+      @lhs, @rhs = lhs, rhs
+    end
+
+    def value
+      [@lhs.value, @rhs.value].min
+    end
+
+    def reroll
+      self.class.new(@lhs.reroll, @rhs.reroll)
+    end
+
+    def max
+      [@lhs.max, @rhs.max].min
+    end
+
+    def min
+      [@lhs.min, @rhs.min].min
+    end
+
+    def distribution
+      @lhs.distribution.convolve_least(@rhs.distribution)
+    end
+
+    def equation_representation
+      "min(#{@lhs.equation_representation}, #{@rhs.equation_representation})"
+    end
+
+    def value_equation(terminal: false)
+      lhs = @lhs.value_equation(terminal: terminal)
+      rhs = @rhs.value_equation(terminal: terminal)
+      "min(#{lhs}, #{rhs})"
+    end
+
+    def expression_equation
+      "min(#{@lhs.expression_equation}, #{@rhs.expression_equation})"
+    end
+  end
+end

data/lib/fifthed_sim/nodes/multi_node.rb

@@ -0,0 +1,135 @@
+require_relative '../distribution'
+require_relative '../dice_expression'
+
+##
+# We sneakily monkey-patch Fixnum here, to allow us to use a nice syntax
+# for factorials.
+#
+# We only do this if somebody hasn't done it already, in case ruby adds this to the standard one day.
+class Fixnum
+  unless self.instance_methods(:false).include?(:factorial)
+    ## 
+    # Mathematical factorial
+    def factorial
+      (1..self).inject(:*) || 1
+    end
+  end
+end
+
+
+##
+# Mathemetical combination
+def combination(n, r)
+  n.factorial / (r.factorial * (n - r).factorial)
+end  
+
+module FifthedSim
+  ##
+  # This class models the result of a roll of multiple dice.
+  # It is filled with the actual result of randomly-rolled dice, but contains
+  # methods to enable the calculation of average values.
+  class MultiNode < DiceExpression
+    def self.d(num, type)
+      self.new(num.times.map{RollNode.roll(type)})
+    end
+
+    ## 
+    # Generally, don't calculate this yourself
+    def initialize(array)
+      unless array.is_a?(Array) && ! array.empty?
+        raise ArgumentError, "Not a valid array"
+      end
+      unless array.all?{|elem| elem.is_a?(RollNode) }
+        raise ArgumentError, "Not all die rolls"
+      end
+      @array = array
+    end
+
+    def reroll
+      self.class.new(@array.map(&:reroll))
+    end
+
+    ##
+    # Did any of our dice crit?
+    def has_crit?
+      @array.any?(&:crit?)
+    end
+
+    ##
+    # Did any of our dice critically fail?
+    def has_critfail?
+      @array.any?(&:critfail?)
+    end
+
+    ##
+    # What is the theoretical average value when we roll this many dice?
+    def average
+      @array.map(&:average).inject(:+)
+    end
+
+    ##
+    # Calculate the value of these dice
+    def value
+      @array.map(&:value).inject(:+)
+    end
+
+    ##
+    # How many dice did we roll?
+    def roll_count
+      @array.count
+    end
+
+    ## 
+    # What kind of dice did we roll?
+    def dice_type
+      @array.first.type
+    end
+
+    ##
+    # The minimum value we could have rolled
+    def min_value
+      roll_count
+    end
+
+    ##
+    # The maximum value we could have rolled 
+    def max_value
+      dice_type * roll_count
+    end
+
+    ## 
+    # Obtain a probability distribution for when we roll this many dice.
+    # This is an instnace of the Distribution class.
+    def distribution
+      total_possible = (dice_type ** roll_count)
+      mapped = min_value.upto(max_value).map do |k|
+        [k, (occurences(k) / total_possible.to_f)]
+      end
+      Distribution.new(Hash[mapped])
+    end
+
+    def value_equation(terminal: false)
+      "(" + @array.map do |a|
+        a.value_equation(terminal: terminal)
+      end.join(", ") + ")"
+    end
+
+    def expression_equation
+      "(" + @array.map do |a|
+        a.expression_equation
+      end.join(", ") + ")"
+    end
+
+    private
+
+    def occurences(num)
+      dice_type = @array.first.type
+      num_dice = @array.size
+      0.upto((num - num_dice) / dice_type).map do |k|
+        ((-1) ** k) * 
+          combination(num_dice, k) *
+          combination(num - (dice_type*k) - 1, num_dice- 1)
+      end.inject(:+)
+    end
+  end
+end

data/lib/fifthed_sim/nodes/multiplication_node.rb

@@ -0,0 +1,25 @@
+require_relative '../dice_expression'
+
+module FifthedSim
+  class MultiplicationNode < DiceExpression
+    using CalculatedFixnum
+    def initialize(lhs, rhs)
+      @lhs = lhs
+      @rhs = rhs
+    end
+
+    def value
+      @lhs.value * @rhs.value
+    end
+
+    def distribution
+      @lhs.distribution.convolve_multiply(@rhs.distribution)
+    end
+
+    def reroll
+      self.class.new(@lhs.reroll, @rhs.reroll)
+    end
+
+    define_binary_op_equations "*"
+  end
+end

data/lib/fifthed_sim/nodes/number_node.rb

@@ -0,0 +1,38 @@
+require_relative '../dice_expression'
+
+module FifthedSim
+  ##
+  # Normally we handle numbers by use of a refinement on Fixnum
+  # However, in some cases, we may have the fixnum as the *start* of an expression.
+  # In this case, we have a problem, because Fixnum#+ is not overloaded to return a DiceNode.
+  # In this case, we must use this, a NumberNode.
+  # NumberNodes wrap a number.
+  class NumberNode < DiceExpression
+    def initialize(arg)
+      unless arg.is_a? Fixnum
+        raise ArgumentError, "#{arg.inspect} is not a fixnum"
+      end
+      @value = arg
+    end
+
+    def distribution
+      Distribution.for(@value)
+    end
+
+    def value
+      @value
+    end
+
+    def reroll
+      self.class.new(@value)
+    end
+
+    def value_equation(terminal: false)
+      @value.to_s
+    end
+
+    def expression_equation
+      @value.to_s
+    end
+  end
+end

data/lib/fifthed_sim/nodes/roll_node.rb

@@ -0,0 +1,88 @@
+require_relative '../dice_expression.rb'
+
+module FifthedSim
+  ##
+  # Model a single roll of the dice.
+  # Users of the library will rarely interact with this class, and will instead manpiulate values based on the DiceResult type.
+  #
+  class RollNode < DiceExpression
+
+    ##
+    # Create a diceresult by rolling a certain type.
+    def self.roll(type)
+      raise ArgumentError, "Must be an Integer" unless type.is_a? Fixnum
+      self.new(SecureRandom.random_number(type) + 1, type)
+    end
+
+    ##
+    # Obtain a DieRoll filled with the average result of this die type
+    # This will round down.
+    def self.average(type)
+      self.new((type + 1) / 2, type)
+    end
+
+    ##
+    # Obtain an average value for this die type, as a float
+    # We're extremely lazy here.
+    def self.average_value(type)
+      self.new(1, type).average
+    end
+
+    def initialize(val, type)
+      unless val.is_a?(Fixnum) && type.is_a?(Fixnum)
+        raise ArgumentError, "Type invald"
+      end
+      @value = val
+      @type = type
+    end
+
+    def reroll
+      self.class.roll(@type)
+    end
+
+    attr_reader :value, :type
+
+    ##
+    # The average roll for a die of this type
+    def average
+      (@type + 1) / 2.0
+    end
+
+    ##
+    # How far away this roll is from the average roll
+    def difference_from_average
+      @value - average
+    end
+
+    ##
+    # Is this roll a critical failure? (AKA, is it a 1?)
+    def critfail?
+      @value == 1
+    end
+
+    ##
+    # Is this roll a critical? (AKA, is it the max value of the dice?)
+    def crit?
+      @value == @type
+    end
+
+    def distribution
+      Distribution.for((1..@type))
+    end
+
+    def value_equation(terminal: false)
+      return value.to_s unless terminal
+      if critfail?
+        Rainbow(value.to_s).color(:red).bright.to_s
+      elsif crit?
+        Rainbow(value.to_s).color(:yellow).bright.to_s
+      else
+        value.to_s
+      end
+    end
+
+    def expression_equation
+      "d#{@type}"
+    end
+  end
+end

data/lib/fifthed_sim/nodes/subtraction_node.rb

@@ -0,0 +1,24 @@
+require_relative '../dice_expression'
+module FifthedSim
+  class SubtractionNode < DiceExpression
+    using CalculatedFixnum
+    def initialize(lhs, rhs)
+      @lhs = lhs
+      @rhs = rhs
+    end
+
+    def value
+      @lhs - @rhs
+    end
+
+    def reroll
+      self.class.new(@lhs.reroll, @rhs.reroll)
+    end
+
+    def distribution
+      @lhs.distribution.convolve_subtract(@rhs.distribution)
+    end
+
+    define_binary_op_equations "-"
+  end
+end

data/lib/fifthed_sim/roll_repl.rb

@@ -0,0 +1,117 @@
+module FifthedSim
+  class RollRepl
+    def initialize(inspect = true, errors = false)
+      @inspect = inspect
+      @errors = errors
+    end
+
+    def run(kill_on_interrupt = false)
+      begin
+        while buf = Readline.readline("> ", true)
+          run_cmd(buf)
+          kill_on_interrupt = false
+        end
+      rescue Interrupt
+        self.exit if kill_on_interrupt
+        puts "Control-C again or 'Exit' to quit"
+        run(true)
+      end
+    end
+
+    def info(cmd)
+      s = cmd.gsub(/info/, "").chomp
+      if s.length > 0
+        run_command(s)
+      end
+      return error_msg("Have nothing to get info of") unless @last_roll
+      lb = ->(x){Rainbow(x).color(:yellow).bright.to_s + ": "}
+      puts (%i(max min percentile).map do |p|
+        lb[p] + @last_roll.public_send(p).to_s
+      end.inject{|m, x| m + ", " + x})
+    end
+
+    def reroll
+      return error_msg("Nothing to reroll") unless @last_roll
+      display_roll(@last_roll.reroll)
+    end
+
+    def run_cmd(cmd)
+      case cmd
+      when /(quit|exit|stop)/
+        self.exit
+      when "rr", "reroll"
+        self.reroll
+      when /info/
+
+        self.info(cmd)
+      when "help"
+        self.help
+      when "inspect"
+        toggle_inspect
+      when "errors"
+        toggle_errors
+      else
+        self.roll(cmd)
+      end
+    end
+
+    def roll(cmd)
+      r = DiceExpression(cmd)
+      @last_roll = r
+      display_roll(r)
+    rescue FifthedSim::Compiler::CompileError => e
+      if e.char
+        display_compile_error(e, cmd)
+      else
+        error_msg("Could not parse expression!")
+      end
+    end
+
+    def display_roll(r)
+      if @inspect
+        puts "  =  " + r.value_equation(terminal: true)
+        puts "  => " + Rainbow(r.value.to_s).underline.bright.to_s
+      else
+        puts r.value.to_s
+      end
+    end
+
+    def error_msg(msg)
+      puts Rainbow(msg).color(:red).bright
+    end
+
+    def display_compile_error(err, cmd)
+      if @errors
+        error_msg("Could not read line: #{err.tree_cause}")
+      else
+        error_msg("Could not read line: #{err.message}")
+      end
+    end
+
+    [:inspect, :errors].each do |m|
+      send(:define_method, "toggle_#{m}") do
+        t = instance_variable_get("@#{m}")
+        puts "#{m}: #{t.inspect} => #{(!t).inspect}"
+        instance_variable_set("@#{m}", !t)
+      end
+    end
+
+    def exit
+      puts "Goodbye."
+      exit!
+    end
+
+    def help
+      cmd = ->(a){ Rainbow(a.to_s).bright.underline + ":" }
+      puts %Q{COMMANDS:
+      #{cmd[:help]} display this message
+      #{cmd[:inspect]} toggle equation inspection
+      #{cmd[:quit]} exit the roller
+      #{cmd[:errors]} toggle in-depth compile errors for dice expressions
+      #{cmd["arrow keys"]} navigate like GNU readline
+      #{cmd[:info]} get info about the previous roll, or a roll on this line.
+      #{cmd["rr, reroll"]} reroll the previous dice
+      }
+    end
+  end
+end

data/lib/fifthed_sim/spell.rb

@@ -0,0 +1,74 @@
+module FifthedSim
+  ##
+  # Spells model save-or-take-damage stuff.
+  # At some point in the future I hope to modify them so they work as other stu
+  class Spell
+    class DefinitionProxy
+      ##
+      def initialize(name, &block)
+        @hash = {
+          name: name
+        }
+        instance_eval(&block)
+      end
+
+      %i(damage save_damage).each do |m|
+        self.send(:define_method, m) do |damage = nil, &block|
+          if block
+            @hash[m] = Damage.define(&block)
+          elsif damage.is_a?(Damage)
+            @hash[m] = damage
+          else
+            raise ArgumentError, "#{damage} is not damage!"
+          end
+        end
+      end
+
+      def save_dc(n)
+        @hash[:save_dc] = n
+      end
+      
+      def save_type(n)
+        @hash[:save_type] = n
+      end
+
+      def attrs
+        @hash
+      end
+    end
+
+    def self.define(name, &block)
+      h = DefinitionProxy.new(name, &block).attrs
+      self.new(h)
+    end
+
+    def initialize(hash)
+      @name = hash[:name]
+      @damage = hash[:damage]
+      @save_damage = hash[:save_damage]
+      @save_type = hash[:save_type]
+      @save_dc = hash[:save_dc]
+    end
+
+    attr_reader :save_dc,
+      :save_type
+
+    def against(other)
+      other.saving_throw(@save_type).test_then do |res|
+        if res >= @save_dc
+          @save_damage.to(other)
+        else
+          @damage.to(other)
+        end
+      end
+    end
+
+    def raw_damage
+      @damage.raw
+    end
+
+    def raw_save_damage
+      @save_damage.raw
+    end
+  end
+end

data/lib/fifthed_sim/stat.rb

@@ -0,0 +1,49 @@
+module FifthedSim
+  class Stat
+    class DefinitionProxy
+      def initialize(&block)
+        @hash = {
+          mod_bonus: 0,
+          save_mod_bonus: 0
+        }
+        instance_eval(&block)
+      end
+
+      %i(value mod_bonus save_mod_bonus).each do |e|
+        self.send(:define_method, e) do |x|
+          @hash[e] = x
+        end
+      end
+
+      attr_reader :hash
+    end
+
+    def self.define(&block)
+      h = DefinitionProxy.new(&block).hash
+      self.new(h)
+    end
+
+    def self.from_value(h)
+      raise ArgumentError, "#{h} not fixnum" unless h.is_a?(Fixnum)
+      self.new({value: h, save_mod: 0, mod_bonus: 0})
+    end
+
+    def initialize(hash)
+      @value = hash[:value]
+      @mod_bonus = (hash[:mod_bonus] || 0)
+      @save_mod_bonus = (hash[:save_mod_bonus] || 0)
+    end
+
+    attr_reader :value,
+      :save_mod_bonus,
+      :mod_bonus
+
+    def mod
+      ((@value - 10) / 2) + @mod_bonus
+    end
+
+    def saving_throw
+      1.d(20) + mod + save_mod_bonus
+    end
+  end
+end

data/lib/fifthed_sim/stat_block.rb

@@ -0,0 +1,57 @@
+require_relative './stat'
+
+module FifthedSim
+  STAT_TYPES = [:str,
+                :dex,
+                :wis,
+                :cha,
+                :con,
+                :int]
+  class StatBlock
+
+
+    class DefinitionProxy
+      def initialize(&block)
+        @hash = {}
+        instance_eval(&block)
+      end
+
+      STAT_TYPES.each do |type|
+        self.send(:define_method, type) do |x = nil, &block|
+          if block
+            @hash[type] = Stat.define(&block)
+          elsif x.is_a?(Stat)
+            @hash[type] = x
+          elsif x.is_a?(Fixnum)
+            @hash[type] = Stat.from_value(x)
+          else
+            raise ArgumentError, "not a stat"
+          end
+        end
+      end
+
+      attr_accessor :hash
+    end
+
+    def self.define(&block)
+      h = DefinitionProxy.new(&block)
+      self.new(h.hash)
+    end
+
+    def initialize(hash)
+      @hash = Hash[hash.map do |k, v|
+        if v.is_a?(Stat)
+          [k, v]
+        else
+          [k, Stat.new(v)]
+        end
+      end]
+    end
+
+    STAT_TYPES.each do |st|
+      self.send(:define_method, st) do
+        @hash[st]
+      end
+    end
+  end
+end

data/lib/fifthed_sim/version.rb

@@ -1,3 +1,5 @@
 module FifthedSim
-  VERSION = "0.1.0"
+  ##
+  # Constant version string
+  VERSION = "0.2.0"
 end

data/lib/fifthed_sim.rb

@@ -1,18 +1,42 @@
 require "fifthed_sim/version"
-require "fifthed_sim/dice_result"
-require "fifthed_sim/die_roll"
-require "fifthed_sim/dice_calculation"
+require "fifthed_sim/dice_expression"
 require "fifthed_sim/distribution"
+require "fifthed_sim/attack"
+require "fifthed_sim/actor"
+require "fifthed_sim/stat_block"
+require "fifthed_sim/damage_types"
+require "fifthed_sim/damage"
+require "fifthed_sim/spell"
+require "fifthed_sim/compiler"
+require "fifthed_sim/roll_repl"
 require "securerandom"
 
 module FifthedSim
+
+  ##
+  # Roll a dice.
+  # Normally, you access this through the monkey-patch on Fixnum.
   def self.d(*args)
-    DiceResult.d(*args)
+    MultiNode.d(*args)
+  end
+
+  def self.make_roll(val, type)
+    RollNode.new(val, type)
+  end
+
+  def self.define_actor(name, &block)
+    Actor.define(name, &block)
   end
 end
 
 class Fixnum
+  ##
+  # Enable you to create dice rolls via `3.d(6)` syntax.
+  # This returns a DiceResult, meaning that you can add them together
+  # to form a calculation.
   def d(o)
     FifthedSim.d(self, o)
   end
+
+
 end