fifthed_sim 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 68200fa0518a4975d872ed4583404f3a3e5a6a9f
-  data.tar.gz: a89f5017dcfeca2e354ee3173694139ed9f3c1a8
+  metadata.gz: 0087fa99f564c98c6d462c20828beb2acf4146be
+  data.tar.gz: 26b12a81c991271aa16d25f9479b0859188f33e5
 SHA512:
-  metadata.gz: ba637784bc60f87a409327852fc3468e901d96b7701d17ea9cc5fcb0e853be09da6f4fb79dd14d4c0b48381fc551d0f47a9b2f79eac317283c0a2678b1537c8f
-  data.tar.gz: f828486f33596455f97f861738aa8e0646f9de188f0073cb889afa8f8566e2b512b64a47b00617cb059aa62a6347c331d926bd88497b4e05d40f7326b8c3cae3
+  metadata.gz: d1c996014ded703a1caa63f3be5f2a9fdedd5dace5bfb588829248aa92705a90f54c21ffe50f8890cf2be6abc930096fcb15ebeb5954b4350c9d0cbcc2ce0b16
+  data.tar.gz: 4eb2c588b583539b52f3a5122c1e17a95f9b0b394b80806b6cd5bf8c70196ef4fab891395d0044c870739d8791c128c450898a9948de24138022224067d1c38e

data/.travis.yml

@@ -1,7 +1,6 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.2.2
   - 2.1.1
   - 2.3.0
   - 2.4.0

data/HelpWanted.md

@@ -0,0 +1,23 @@
+# Help Wanted
+
+This file contains a list of improvements we desire for this gem.
+If you can help out, feel free to make a pull request on the [Github](https://github.com/AnthonySuper/FifthedSim)
+
+
+## Top and Bottom Nodes
+Some dice games require that you roll a certain amount of dice, and take the top or bottom rolls.
+For example, to apply *disadvantage* in D&D, you roll 2d20 and take the lowest D20.
+
+For the case of choosing between two dice calculations, we use the `.or_less` and `.or_greater` methods.
+Unfortunately, these are not the only types of top and bottom calculations used in games.
+Rolling a stat in D&D, for example, is `4d6 (drop lowest)`.
+
+Finding a generic distribution for this is, as it turns out, hard to do efficiently.
+The simple way is to take all possible combinations of rolls, drop the lowest, count the remaining values, and create a distribution from this information.
+Unfortunately, the number of combinations of rolls is `dice_type^dice_number`, which is an exponential calculation.
+
+If you know of a better formula, we'd love to hear about it.
+You can either [open an issue](https://github.com/AnthonySuper/FifthedSim/issues/new) describing it, or create a pull request yourself.
+
+If there does not exist a better formula, we'd also love to hear about it.
+You can [open an issue](https://github.com/AnthonySuper/FifthedSim/issues/new) with a link to a proof that this operation cannot be done any quicker, and we will implement the brute-force solution.

data/README.md

@@ -1,8 +1,151 @@
 # FifthedSim
+[![Build Status](https://travis-ci.org/AnthonySuper/FifthedSim.svg?branch=master)](https://travis-ci.org/AnthonySuper/FifthedSim)
+
 
 This is a gem to simulate a game that you play with dice on a d20 system.
 It is unfinished, but intends to enable a user to run simulations, or to see the overall probability of things which happen.
 
+## Usage
+
+### Executable
+
+If you just want to roll dice, simply install the gem and type "diceroll".
+This will bring up a Dice REPL, which has some nice functionality.
+Just type a dice expression, and you will get a result:
+
+```
+> d20 + 3d6
+  => 18 + (3 2 6)
+  =  29
+```
+You can also get some info about a roll by typing `info`.
+Type `help` to see all the commands.
+
+### Dice Expressions
+
+This gem generalizes the use of dice into *DiceExpressions*, which is an expression representing a calculation done on dice.
+This expression is *lazily evaluated*, which means that it does not turn into an actual numerical value until you call `.to_i` or `.value` on it.
+
+DiceExpressions are more powerful than simply rolling dice and doing math on the results, as we can both reuse them and do statistics on them.
+This allows us to figure out a variety of useful information.
+
+Dice expressions are almost always constructed via the `Fixnum#d` method:
+
+```ruby
+1.d(20)
+```
+
+From here, mathematical operations work as normal:
+
+```ruby
+result = (1.d(20) + 3 + 2.d(6)) / (1.d(4) * 2 * 1.d(2))
+```
+
+As mentioned earlier, we can get a numeric value from this expression:
+
+```ruby
+result.value # -> 2
+```
+
+We can also reroll this expression, to get another DiceExpression with a new value:
+
+```ruby
+result.reroll.value # -> 6
+```
+
+More interestingly, we can do statistics on this value.
+We can obtain a `Distribution` of possible results for a given dice expression easily:
+
+```ruby
+distribution = result.distribution
+```
+
+Now, let's see how likely our value of 2 was.
+Let's also see what percentile our value is in.
+
+```ruby
+distribution.percent_exactly(2) # -> 0.199305...
+distribution.percentile_of(2) # -> 0.475694...
+```
+
+So our roll wasn't terrible, but it wasn't great as well.
+
+#### Combinations
+`DiceExpressions` are a powerful construct, because they allow combinations with arbitrary functions, while still being a `DiceExpression`.
+To use an example, let's try to model the damage of a kobold's dagger attack against a player character with 12 AC.
+
+The kobold rolls `1d20 + 4` to hit.
+If he gets a 12 or higher, he does `1d4 + 2` damage to this player.
+Let's model this attack:
+
+```ruby
+attack = (1.d(20) + 4).test_then do |result|
+  if result < 12
+    0.to_dice_expression
+  else
+    1.d(4) + 2
+  end
+end
+```
+
+This is just a `DiceExpression`, so we can get its value, and reroll it:
+
+```ruby
+attack.value # => 0, the poor guy missed
+attack.reroll.value # => 3, he hit... and critfailed damage.
+```
+
+Even more interestingly, however, we can do *statistics* on it.
+Let's see the chance of him doing at least one damage:
+
+```ruby
+attack.distribution.percent_greater(0) # => 0.65, 65% of doing damage
+```
+What about the average damage per attack?
+
+```ruby
+attack.average # => 2.925
+```
+
+As long as the block passed to `test_then` is *pure* (IE, the same input maps to the same output, regardless of anything else that happens in the program), then we can do any kind of calculation we want inside of it.
+This is useful in a variety of situations.
+
+### Simulation
+FifthedSim was originally designed to simulate D&D 5e games.
+Doing this is still under construction, but it's coming along nicely.
+
+Simulation is based on *Actors*.
+An Actor represents a character or NPC in the game.
+Actors are defined with a nice DSL:
+
+```ruby
+actor = FifthedSim.define_actor("Bobby") do
+  base_ac 10
+  stats do
+    str 10
+    dex do
+      value 18
+      save_mod_bonus 5
+    end
+    wis 8
+    cha 16
+    con 14
+    int 12
+  end
+  attack "rapier" do
+    to_hit 5
+    damage do
+      piercing 1.d(6)
+    end
+  end
+end
+```
+
+Construction based on YAML or JSON is still a work in progress.
+Actors are intended to be used to simulate battles.
+This is currently a work in progress, although simulating individual attacks and such *does* currently work.
+
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -19,10 +162,6 @@ Or install it yourself as:
 
     $ gem install fifthed_sim
 
-## Usage
-
-See the rdoc for now.
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -32,7 +171,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/anthonysuper/fifthedsim.
-
+Please see the [HelpWanted.md](HelpWanted.md) file for specific patches we are looking for.
 
 ## License
 

data/bin/console

@@ -3,12 +3,6 @@
 require "bundler/setup"
 require "fifthed_sim"
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start
+require "pry"
+Pry.start

data/bin/playground

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "fifthed_sim"
+
+
+require "pry"
+require 'ostruct'
+require 'csv'
+
+iron_will = FifthedSim::Attack.define "Sword of Iron Will" do
+  to_hit 9
+  damage do
+    slashing 2.d(6) + 5
+  end
+  crit_threshold 19
+  crit_damage do 
+    slashing 7.d(6) + 5
+  end
+end
+
+class FakeMonster 
+  def initialize(ac = 18); @ac = ac; end;
+  def resistant_to?(_); false; end;
+  def immune_to?(_); false; end;
+  attr_accessor :ac
+end
+
+
+def write_csv(d, filename= "data.csv")
+  m = d.map
+  keys = m.keys.sort
+  CSV.open(filename, "wb") do |csv|
+    csv << ["Outcome", *keys]
+    csv << ["Chance", *keys.map{|k| m[k]}]
+  end
+end
+
+
+hit = iron_will.against(FakeMonster.new)
+
+binding.pry

data/exe/diceroll

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "../lib"))
+
+require 'fifthed_sim'
+require 'readline'
+
+
+
+FifthedSim::RollRepl.new.run

data/fifthed_sim.gemspec

@@ -17,9 +17,13 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.executables << 'diceroll'
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "parslet", "~> 1.7.1"
+  spec.add_dependency "rainbow", "~> 2.0.0"
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry", "~> 0.10.4"
 end

data/lib/fifthed_sim/actor.rb

@@ -0,0 +1,80 @@
+module FifthedSim
+  class Actor
+    class DefinitionProxy
+      def initialize(name, &block)
+        @attrs = {
+          name: name,
+          attacks: {},
+          spells: {},
+          base_ac: 10
+        }
+        instance_eval(&block)
+      end
+
+      attr_reader :attrs
+
+      def attack(name, &block)
+        if block_given? && name.is_a?(String)
+          @attrs[:attacks][name] = Attack.define(name, &block)
+        elsif name.is_a?(Attack)
+          @attrs[:attacks][name.name] << name
+        else
+          raise ArgumentError, "must be an attack"
+        end
+      end
+
+      def spell(name, &block)
+        if block_given? && name.is_a?(String)
+          @attrs[:spells][name] = Spell.define(name, &block)
+        elsif name.is_a?(Spell)
+          @attrs[:spells][name.name] << name
+        else
+          raise ArgumentError, "must be a spell"
+        end
+      end
+
+      def stats(n = nil, &block)
+        if n && n.is_a?(StatBlock)
+          @attrs[:stats] = n
+        elsif block
+          @attrs[:stats] = StatBlock.define(&block)
+        else
+          raise ArgumentError, "Must be a statblock"
+        end
+      end
+
+      def base_ac(num)
+        @attrs[:base_ac] = num
+      end
+    end
+
+    def self.define(name, &block)
+      d = DefinitionProxy.new(name, &block)
+      return self.new(d.attrs)
+    end
+
+    ASSIGNABLE_ATTRS = [:base_ac, 
+                        :name, 
+                        :attacks, 
+                        :spells]
+    def initialize(attrs)
+      attrs.to_a.keep_if{ |(k, v)| ASSIGNABLE_ATTRS.include?(v) }
+        .each { |(k, v)| self.instance_variable_set("@#{k}", v) }
+    end
+
+    def random_attack
+      @attacks.keys.sample
+    end
+
+    ##
+    # TODO: Implement armor
+    def ac
+      base_ac
+    end
+
+    attr_reader :base_ac,
+      :name,
+      :attacks,
+      :spells
+  end
+end

data/lib/fifthed_sim/attack.rb

@@ -0,0 +1,86 @@
+require_relative './damage'
+module FifthedSim
+  ##
+  # Model an attack vs AC
+  class Attack
+    class DefinitionProxy
+      def initialize(name, &block)
+        @attrs = {
+          name: name,
+          to_hit: 0,
+          damage: nil,
+          crit_threshold: 20,
+          crit_damage: nil
+        }
+        instance_eval(&block)
+      end
+
+      attr_reader :attrs
+
+      def to_hit(num)
+        @attrs[:to_hit] = num
+      end
+
+      def damage(arg = nil, &block)
+        if block_given?
+          @attrs[:damage] = Damage.define(&block)
+        else
+          damage_check(arg)
+          @attrs[:damage] = arg
+        end
+      end
+
+      def crit_damage(arg = nil, &block)
+        if block_given?
+          @attrs[:crit_damage] = Damage.define(&block)
+        else
+          damage_check(arg)
+        end
+      end
+
+      def crit_threshold(thr)
+        @attrs[:crit_threshold] = thr
+      end
+
+      protected
+      def damage_check(arg)
+        unless arg.is_a? Damage
+          raise TypeError, "#{arg.inspect} is not Damage"
+        end
+      end
+    end
+
+    def self.define(name, &block)
+      d = DefinitionProxy.new(name, &block)
+      self.new(d.attrs)
+    end
+
+    def initialize(attrs)
+      @name = attrs[:name]
+      @to_hit = attrs[:to_hit]
+      @damage = attrs[:damage]
+      @crit_threshold = attrs[:crit_threshold]
+      @crit_damage = attrs[:crit_damage]
+    end
+
+    def hit_roll
+      1.d(20) + @to_hit
+    end
+
+    def against(other)
+      hit_roll.test_then do |res|
+        if res < other.ac
+          0.to_dice_expression
+        elsif res > other.ac && res < (@crit_threshold + @to_hit)
+          @damage.to(other)
+        else
+          @crit_damage.to(other)
+        end
+      end
+    end
+
+    def raw_damage
+      @damage.raw
+    end
+  end
+end

data/lib/fifthed_sim/calculated_fixnum.rb

@@ -0,0 +1,57 @@
+module FifthedSim
+  module CalculatedFixnum
+    refine Fixnum do
+      def value
+        self
+      end
+
+      def average
+        self
+      end
+
+      def has_critfail?
+        false
+      end
+
+      def has_crit?
+        false
+      end
+
+      def distance_from_average
+        0
+      end
+
+      def distribution
+        FifthedSim::Distribution.for_number(self)
+      end
+
+      def average?
+        true
+      end
+
+      def below_average?
+        false
+      end
+
+      def above_average?
+        false
+      end
+
+      def difference_from_average
+        0
+      end
+
+      def reroll
+        self
+      end
+
+      def value_equation(terminal: false)
+        self.to_s
+      end
+
+      def expression_equation
+        self.to_s
+      end
+    end
+  end
+end

data/lib/fifthed_sim/compiler/parser.rb

@@ -0,0 +1,46 @@
+require 'parslet'
+
+class FifthedSim::Compiler 
+  class Parser < Parslet::Parser
+    root :addition
+    rule(:space) { match('\s').repeat(1) }
+    rule(:space?) { space.maybe }
+    rule(:lparen) { str("(") >> space? }
+    rule(:rparen) { str(")") >> space? }
+    rule(:comma) { str(",") >> space? }
+    rule(:number) { match('[0-9]').repeat(1).as(:number) }
+    rule(:number?) { number.maybe }
+    rule(:dice) do
+      (number?.as(:die_count) >> str("d") >> number.as(:die_type) >> space?)
+        .as(:dice)
+    end
+    rule(:base_term) { (dice | number) >> space? } 
+    rule(:primary) { lparen >> addition >> rparen | base_term }
+
+    rule(:add_op) { match('\+|-').as(:op) >> space? }
+    rule(:addition) do
+     (multiplication.as(:lhs) >> add_op >> addition.as(:rhs)) |
+        multiplication
+    end
+
+    rule(:mult_op) { match('\*|/').as(:op) >> space? }
+
+    rule(:multiplication) do 
+      (mult_term.as(:lhs) >> (mult_op >> addition.as(:rhs))) |
+        mult_term
+    end
+
+    rule(:mult_term) do
+      primary | funcall
+    end
+    
+    rule(:ident) { match('[a-zA-z]').repeat(1) }
+
+    rule(:arglist) do
+      addition >> (comma >> addition).repeat
+    end
+
+    rule(:funcall) { ident.as(:ident) >> lparen >> arglist.as(:args) >> rparen }
+    rule(:expression) { funcall | multiplication | addition | base_term }
+  end
+end

data/lib/fifthed_sim/compiler/transform.rb

@@ -0,0 +1,28 @@
+require 'parslet'
+
+class FifthedSim::Compiler
+  class Transform < Parslet::Transform
+    rule(:number => simple(:x)) { Integer(x) }
+    rule(dice: {die_count: simple(:c), die_type: simple(:t)}) do
+      if c
+        c.d(t)
+      else
+        FifthedSim::RollNode.roll(t)
+      end
+    end
+    rule(op: simple(:op), lhs: simple(:lhs), rhs: simple(:rhs)) do
+      lhs.to_dice_expression.public_send(op, rhs.to_dice_expression)
+    end
+    FUNC_MAP = {
+      "max" => :or_greater,
+      "min" => :or_least
+    }
+    FUNC_MAP.each do |k, v|
+      rule(ident: k, args: sequence(:args)) do |d|
+        d[:args].inject do |mem, arg|
+          mem.to_dice_expression.public_send(v, arg)
+        end
+      end
+    end
+  end
+end

data/lib/fifthed_sim/compiler.rb

@@ -0,0 +1,51 @@
+module FifthedSim
+  class Compiler
+    def self.parse(str)
+      begin
+        Parser.new.parse(str)
+      rescue Parslet::ParseFailed => e
+        msg = e.message
+        raise CompileError.new(e)
+      end
+    end
+
+    def self.compile(str)
+      tree = self.parse(str)
+      transformed = Transform.new.apply(tree)
+      if transformed.is_a? DiceExpression
+        transformed
+      else
+        raise TransformError.new(transformed)
+      end
+    end
+
+    class CompileError < StandardError
+      def initialize(err)
+        msg = err.message
+        super(msg)
+        @line = msg.match(/line (\d+)/)[1].to_i
+        @char = msg.match(/char (\d+)/)[1].to_i
+        @tree_cause = err.cause.ascii_tree
+      end
+      attr_reader :line
+      attr_reader :char
+      attr_reader :tree_cause
+    end
+
+    class TransformError < CompileError
+      def initialize(hash)
+        @message = "Could not transform"
+        if hash.is_a? Hash
+          @source_hash = hash
+          @line, @char = hash.values.keep_if{|x| x.is_a? Parslet::Slice}
+            .first.line_and_column
+        end
+      end
+
+      attr_reader :source_hash, :message
+    end
+  end
+end
+
+require_relative './compiler/parser'
+require_relative './compiler/transform'