fifthed_sim 0.1.0 → 0.2.0

data/lib/fifthed_sim/damage.rb

@@ -0,0 +1,54 @@
+require_relative './damage_types'
+require_relative './calculated_fixnum'
+module FifthedSim
+  class Damage
+    using CalculatedFixnum
+
+    class DefinitionProxy
+      def initialize(&block)
+        @attrs = {}
+        instance_eval(&block)
+      end
+
+      attr_accessor :attrs
+
+      DAMAGE_TYPES.each do |type|
+        self.send(:define_method, type) do |arg|
+          @attrs[type] = DiceExpression(arg)
+        end
+      end
+    end
+
+    def self.define(&block)
+      h = DefinitionProxy.new(&block).attrs
+      self.new(h)
+    end
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    ##
+    # Obtain a dice roll of how much damage we're doing to a particular enemy
+    def to(enemy)
+      mapped = @hash.map do |k, v|
+        if enemy.immune_to?(k)
+          0.to_dice_expression
+        elsif enemy.resistant_to?(k)
+          (v / 2)
+        else
+          v
+        end
+      end
+      if mapped.empty?
+        0.to_dice_expression
+      else
+        mapped.inject{|memo, x| memo + x}
+      end
+    end
+    
+    def raw
+      @hash.values.inject{|s, k| s + k}
+    end
+  end
+end

data/lib/fifthed_sim/damage_types.rb

@@ -0,0 +1,39 @@
+module FifthedSim
+  class DamageTypes
+    def self.convert(t)
+      ret = case t
+            when String
+              t.to_sym
+            when Symbol
+              t
+            else
+              raise ArgumentError, "Cannot convert to damage type"
+            end
+      unless self.valid_damage_type?(ret)
+        raise InvalidDamageType, "#{ret} is not a type of damage"
+      end
+      ret
+    end
+
+    def self.valid_damage_type?(sym)
+      DAMAGE_TYPES.include? sym
+    end
+
+    class InvalidDamageType < StandardError
+    end
+  end
+
+  DAMAGE_TYPES = %i(slashing
+                    bludgeoning
+                    piercing
+                    fire
+                    cold
+                    poison
+                    acid
+                    psychic
+                    necrotic
+                    radiant
+                    lightning
+                    thunder
+                    force)
+end

data/lib/fifthed_sim/dice_expression.rb

@@ -0,0 +1,134 @@
+require 'rainbow'
+
+module FifthedSim
+  ##
+  # This is an abstract dice expression class
+  class DiceExpression
+
+    def to_i
+      value
+    end
+
+    def to_f
+      value.to_f
+    end
+
+    def average
+      distribution.average
+    end
+
+    def +(other)
+      AdditionNode.new(self, other.to_dice_expression)
+    end
+
+    def -(other)
+      SubtractionNode.new(self, other.to_dice_expression)
+    end
+
+    def /(other)
+      DivisionNode.new(self, other.to_dice_expression)
+    end
+
+    def *(other)
+      MultiplicationNode.new(self, other.to_dice_expression)
+    end
+
+    def or_greater(other)
+      GreaterNode.new(self, other.to_dice_expression)
+    end
+
+    def or_least(other)
+      LessNode.new(self, other.to_dice_expression)
+    end
+
+    def percentile
+      distribution.percent_lower_equal(value)
+    end
+
+    def max
+      distribution.max
+    end
+
+    def min
+      distribution.min
+    end
+
+    ##
+    # Takes a block, which should take a single argument
+    # This block should return another DiceExpression type, based on the result of this DiceExpression.
+    def test_then(&block)
+      BlockNode.new(self, &block)
+    end
+
+    {"above_" => :>, "below_" => :<, "" => :==}.each do |k,v|
+      define_method "#{k}average?" do
+        value.public_send(v, average)
+      end
+    end
+
+    ##
+    # Get this difference of the average value and the current value.
+    # For example, if the average is 10 and we have a value of 20, it will return 10.
+    # Meanwhile, if the average is 10 and we have a value of 2, it will return -8.
+    def difference_from_average
+      value - average
+    end
+
+    def range
+      (min..max)
+    end
+
+    def to_dice_expression
+      self.dup
+    end
+
+    protected
+
+    def self.define_binary_op_equations(op)
+      self.send(:define_method, :value_equation) do |terminal: false|
+        lhs = instance_variable_get(:@lhs).value_equation(terminal: terminal)
+        rhs = instance_variable_get(:@rhs).value_equation(terminal: terminal)
+        "(#{lhs} #{op} #{rhs}"
+      end
+
+      self.send(:define_method, :expression_equation) do
+        lhs = instance_variable_get(:@lhs)
+        rhs = instance_variable_get(:@rhs)
+        "(#{lhs.expression_equation} #{op} #{rhs.expression_equation})"
+      end
+    end
+  end
+end
+
+##
+# Allow .to_dice_expression on Fixnum
+class Fixnum
+  def to_dice_expression
+    FifthedSim::NumberNode.new(self)
+  end
+end
+
+class String
+  def to_dice_expression
+    FifthedSim::Compiler.compile(self)
+  end
+end
+
+##
+# C-style conversion, yay
+def DiceExpression(arg)
+  return arg.to_dice_expression if arg.respond_to? :to_dice_expression
+  throw ArgumentError, "Cannot convert #{arg.class} to DiceExpression"
+end
+    
+
+require_relative './nodes/multi_node'
+require_relative './nodes/addition_node'
+require_relative './nodes/roll_node'
+require_relative './nodes/block_node'
+require_relative './nodes/division_node'
+require_relative './nodes/greater_node'
+require_relative './nodes/less_node'
+require_relative './nodes/number_node'
+require_relative './nodes/multiplication_node'
+require_relative './nodes/subtraction_node'

data/lib/fifthed_sim/distribution.rb

@@ -1,72 +1,271 @@
+require 'set'
+
 module FifthedSim
+  ##
+  # Models a probabilistic distribution.
   class Distribution
+    ##
+    # Get a distrubtion for a number.
+    # This will be a uniform distribution with P = 1 at this number and P = 0 elsewhere.
     def self.for_number(num)
-      self.new({num => 1}, 1)
+      self.new({num => 1.0})
+    end
+
+    def self.for_range(rng)
+      size = rng.size.to_f
+      e = 1.0 / size
+      self.new(Hash[rng.map{|x| [x, e]}])
+    end
+
+    def self.for(obj)
+      case obj
+      when Fixnum
+        self.for_number(obj)
+      when Range
+        self.for_range(obj)
+      else
+        raise ArgumentError, "can't amke a distribution for that"
+      end
     end
 
-    def initialize(map, total_possible)
+    ##
+    # We initialize class with a map of results to occurences, and a total number of possible different occurences.
+    # Generally, you will not ever initialize this yourself.
+    def initialize(map)
       keys = map.keys
       @max = keys.max
       @min = keys.min
-      @map = map
-      @total_possible = total_possible
+      @map = map.dup
+      @map.default = 0
     end
 
     attr_reader :total_possible,
       :min,
       :max
 
+
     def range
-      (@max..@min)
+      (@min..@max)
     end
 
     def map
       @map.dup
     end
 
-    def probability_map
-      Hash[@map.map{|k, v| [k, v / @total_possible.to_f]}]
+    def average
+      map.map{|k, v| k * v}.inject(:+)
+    end
+
+    ##
+    # Obtain a new distribution of values.
+    # When block.call(value) for this distribution is true, we will allow
+    # values from the second distribution.
+    # Otherwise, the value will be zero.
+    #
+    # This is mostly used in hit calculation - AKA, if we're higher than an AC, then we hit, otherwise we do zero damage
+    def hit_when(other, &block)
+      hit_prob = map.map do |k, v|
+        if block.call(k)
+          v
+        else
+          nil
+        end
+      end.compact.inject(:+)
+      miss_prob = 1 - hit_prob
+      omap = other.map
+      h = Hash[omap.map{|k, v| [k, v * hit_prob]}]
+      h[0] = (h[0] || 0) + miss_prob
+      Distribution.new(h)
+    end
+
+    ##
+    # Takes a block or callable object.
+    # This function will call the callable with all possible outcomes of this distribution.
+    # The callable should return another distribution, representing the possible values when this possibility happens.
+    # This will then return a value of those possibilities.
+    #
+    # An example is probably helpful here.
+    # Let's consider the case where a monster with +0 to hit is attacking a creature with AC 16 for 1d4 damage, and crits on a 20.
+    # If we want a distribution of possible outcomes of this attack, we can do:
+    #
+    #   1.d(20).distribution.results_when do |x|
+    #     if x < 16
+    #       Distribution.for_number(0)
+    #     elseif x < 20
+    #       1.d(4).distribution
+    #     else
+    #       2.d(4).distribution
+    #     end
+    #   end
+    def results_when(&block)
+      h = Hash.new{|h, k| h[k] = 0}
+      range.each do |v|
+        prob = @map[v]
+        o_dist = block.call(v)
+        o_dist.map.each do |k, v|
+          h[k] += (v * prob)
+        end
+      end
+      Distribution.new(h)
+    end
+
+    def percent_within(range)
+      percent_where{|x| range.contains? x}
+    end
+
+    def percent_where(&block)
+      @map.to_a
+        .keep_if{|(k, v)| block.call(k)}
+        .map{|(k, v)| v}
+        .inject(:+)
     end
 
     def percent_exactly(num)
       return 0 if num < @min || num > @max
-      @map[num] / @total_possible.to_f
+      @map[num] || 0
+    end
+
+    def variance
+      avg = average
+      @map.map do |k, v|
+        ((k - avg)**2) * v
+      end.inject(:+)
+    end
+
+    def std_dev
+      Math.sqrt(variance)
+    end
+
+    def percent_lower(n)
+      num = n - 1
+      return 0.0 if num < @min
+      return 1.0 if num > @max
+      @min.upto(num).map(&map_proc).inject(:+)
+    end
+
+    def percent_greater(n)
+      num = n + 1
+      return 0.0 if num > @max
+      return 1.0 if num < @min
+      num.upto(@max).map(&map_proc).inject(:+)
     end
 
-    def percent_least(num)
-      return 0 if num < @min
-      return 1 if num >= @max
-      
-      n = @min.upto(num).map(&map_proc).inject(:+)
-      n / @total_possible.to_f
+    def percent_lower_equal(num)
+      percent_lower(num + 1)
     end
 
+    def percent_greater_equal(num)
+      percent_greater(num - 1)
+    end
+
+    alias_method :percentile_of,
+      :percent_lower_equal
+
+
+
     def convolve(other)
       h = {}
       abs_min = [@min, other.min].min
       abs_max = [@max, other.max].max
       min_possible = @min + other.min
       max_possible = @max + other.max
-      tp = @total_possible * other.total_possible
       # TODO: there has to be a less stupid way to do this right?
       v = min_possible.upto(max_possible).map do |val|
         sum = abs_min.upto(abs_max).map do |m|
           percent_exactly(m) * other.percent_exactly(val - m)
         end.inject(:+)
-        [val, (sum * tp).to_i]
+        [val, sum]
+      end
+      self.class.new(Hash[v])
+    end
+
+    ##
+    # TODO: Optimize this
+    def convolve_subtract(other)
+      h = Hash.new{|h, k| h[k] = 0}
+      range.each do |v1|
+        other.range.each do |v2|
+          h[v1 - v2] += percent_exactly(v1) * other.percent_exactly(v2)
+        end
+      end
+      self.class.new(h)
+    end
+
+    ##
+    # Get the distribution of a result from this distribution divided by
+    # one from another distribution.
+    # If the other distribution may contain zero this will break horribly.
+    def convolve_divide(other)
+      throw ArgumentError, "Divisor may be zero" if other.min < 1
+      h = Hash.new{|h, k| h[k] = 0}
+      # We can do this faster using a sieve, but be lazy for now
+      # TODO: Be less lazy
+      range.each do |v1|
+        other.range.each do |v2|
+          h[v1 / v2] += percent_exactly(v1) * other.percent_exactly(v2)
+        end
+      end
+      self.class.new(h)
+    end
+
+    def convolve_multiply(other)
+      h = Hash.new{|h, k| h[k] = 0}
+      range.each do |v1|
+        other.range.each do |v2|
+          h[v1 * v2] += percent_exactly(v1) * other.percent_exactly(v2)
+        end
+      end
+      self.class.new(h)
+    end
+
+
+    def convolve_greater(other)
+      h = Hash.new{|h, k| h[k] = 0}
+      # for each value
+      range.each do |s|
+        (s..other.max).each do |e|
+          h[e] += (other.percent_exactly(e) * percent_exactly(s))
+        end
+        h[s] += (other.percent_lower(s) * percent_exactly(s))
       end
-      self.class.new(Hash[v], tp)
+      self.class.new(h)
     end
 
+    def convolve_least(other)
+      h = Hash.new{|h, k| h[k] = 0}
+      range.each do |s|
+        (other.min..s).each do |e|
+          h[e] += (other.percent_exactly(e) * percent_exactly(s))
+        end
+        h[s] += (other.percent_greater(s + 1) * percent_exactly(s))
+      end
+      self.class.new(h)
+    end
+
+    COMPARE_EPSILON = 0.00001
     def ==(other)
-      @map == other.map &&
-        @total_possible == other.total_possible
+      omap = other.map
+      max_possible = (@max / other.min)
+      same_keys = (Set.new(@map.keys) == Set.new(omap.keys))
+      same_vals = @map.keys.each do |k|
+        (@map[k] - other.map[k]).abs <= COMPARE_EPSILON
+      end
+      same_keys && same_vals
+    end
+
+    def text_histogram(cols = 60)
+      max_width = @max.to_s.length
+      justwidth = max_width + 1
+      linewidth = (cols - justwidth)
+      range.map do |v|
+        "#{v}:".rjust(justwidth) + ("*" * (percent_exactly(v) * linewidth))
+      end.join("\n")
     end
 
     private
     def map_proc
       return Proc.new do |arg|
-        res = @map[arg]
+        @map[arg]
       end
     end
   end

data/lib/fifthed_sim/nodes/addition_node.rb

@@ -0,0 +1,75 @@
+require_relative '../dice_expression'
+require_relative '../calculated_fixnum'
+
+module FifthedSim
+  class AdditionNode < DiceExpression
+    using CalculatedFixnum
+
+    def initialize(*values)
+      values.each(&method(:check_type))
+      @components = values.flatten
+    end
+
+    def +(other)
+      check_type(other)
+      self.class.new(*@components, other)
+    end
+
+    def value
+      # Symbol::& uses send, so refinements would break
+      # How sad
+      @components.map{|x| x.value}.inject(:+)
+    end
+
+    def dice
+      self.class.new(*@components.find_all{|x| x.is_a?(RollNode)})
+    end
+
+    def average
+      @components.map{|x| x.average}.inject(:+)
+    end
+
+    def has_critfail?
+      @components.any?{|x| x.has_critfail?}
+    end
+
+    def has_crit?
+      @components.any?{|x| x.has_crit?}
+    end
+
+    def distribution
+      # TODO: Maybe figure out how to minimize convolution expense?
+      @components.map{|x| x.distribution}.inject do |memo, p|
+        memo.convolve(p)
+      end
+    end
+
+    def reroll
+      self.class.new(*@components.map{|x| x.reroll})
+    end
+
+
+    def value_equation(terminal: false)
+      arglist = @components.map do |c|
+        c.value_equation(terminal: terminal)
+      end.inject{|m, x| m + "+ #{x}"}
+      "(#{arglist})"
+    end
+
+    def expression_equation
+      "(" + @components.map do |c|
+        c.expression_equation
+      end.inject{|m, x| m + "+ #{x}"} + ")"
+    end
+
+    private
+    ALLOWED_TYPES = [DiceExpression,
+                     Fixnum]
+
+    def check_type(obj)
+      unless ALLOWED_TYPES.any?{|x| obj.kind_of?(x)}
+        raise TypeError, "#{obj.inspect} is not a DiceExpression"
+      end
+    end  
+  end
+end

data/lib/fifthed_sim/nodes/block_node.rb

@@ -0,0 +1,46 @@
+require_relative '../dice_expression'
+require_relative '../calculated_fixnum'
+require_relative '../distribution'
+
+module FifthedSim
+  class BlockNode < DiceExpression
+    using CalculatedFixnum
+
+    def initialize(arg, &block)
+      @arg = arg
+      @block = block
+      @current_expression = block.call(arg.value)
+      @current_value = @current_expression.value
+    end
+
+    def value
+      @current_value
+    end
+
+    def reroll
+      self.class.new(@arg.reroll, &@block)
+    end
+
+    def distribution
+      @arg.distribution.results_when(&distribution_block)
+    end
+
+    def value_equation(terminal: false)
+      arg = @arg.value_equation(terminal: terminal)
+      ce = @current_expression.value_equation(terminal: terminal)
+      "blockNode(#{arg} => #{ce})"
+    end
+
+    protected
+
+    def distribution_block
+      h = Hash[@arg.range.map do |k|
+        [k, @block.call(k).distribution]
+      end]
+      require 'pry'
+      proc do |x|
+        h.fetch(x)
+      end
+    end
+  end
+end

data/lib/fifthed_sim/nodes/division_node.rb

@@ -0,0 +1,26 @@
+require_relative '../dice_expression'
+require_relative '../calculated_fixnum'
+module FifthedSim
+  class DivisionNode < DiceExpression
+    using CalculatedFixnum
+
+    def initialize(num, div)
+      @lhs = num
+      @rhs = div
+    end
+
+    def value
+      @lhs.value / @rhs.value
+    end
+
+    def reroll
+      self.class.new(@lhs.reroll, @rhs.reroll)
+    end
+
+    def distribution
+      @lhs.distribution.convolve_divide(@rhs.distribution)
+    end
+
+    define_binary_op_equations "/"
+  end
+end

data/lib/fifthed_sim/nodes/greater_node.rb

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