dieroll 0.0.0 → 1.0.0

data/bin/dieroll

@@ -7,17 +7,87 @@ $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'dieroll'
 require 'optparse'
 
-usage_string = "Usage: roll [-r] <roll-string>"
+usage_string =
+  "Usage: roll [--ne --lt --le --eq --ge --gt]"+
+  " [--headers] [-v val] [-r] [-p] <roll-string>"
 
 options = {}
 OptionParser.new do |opts|
   opts.banner = usage_string
   
-  options[:results] = false
-  opts.on('-r','--results','Show full roll results' ) do
+  opts.separator ""
+
+  opts.on('-r','--results','Print full roll results' ) do
     options[:results] = true
   end
 
+  opts.separator ""
+
+  options[:comparisons] = []
+    
+  opts.separator "Odds -"
+  
+  opts.separator "Print chances of rolling:"
+
+  opts.on('--eq','--equal',
+          'the given value') do
+    options[:comparisons] << :equal
+  end
+
+  opts.on('--ne','--not-equal',
+          'any value EXCEPT the given value') do
+    options[:comparisons] << :not_equal
+  end
+
+  opts.on('--lt','--less-than',
+          'less than the given value') do
+    options[:comparisons] << :less_than
+  end
+
+  opts.on('--le','--less-than-or-equal',
+          'less than or equal the given value') do
+    options[:comparisons] << :less_than_or_equal
+  end
+
+  opts.on('--gt','--greater-than',
+          'greater than the given value') do
+    options[:comparisons] << :greater_than
+  end
+
+  opts.on('--ge','--greater-than-or-equal',
+          'greater than or equal the given value') do
+    options[:comparisons] << :greater_than_or_equal
+  end
+
+  opts.separator ""
+
+  opts.on('--headers',
+          'Show headers on the Odds table') do
+    options[:headers] = true
+  end
+
+  opts.separator ""
+  
+  opts.on('-v','--value VALUE',
+          'Sets the value to be used for the Odds switches',
+          "Can be an int or a range 'X-Y'",
+          'Will display all possible results if not set') do |value|
+    value =~ /(-?\d+)-?(-?\d*)/
+    unless($2.empty?)
+      options[:val] = ($1.to_i..$2.to_i)
+    else
+      options[:val] = value.to_i
+    end
+  end
+
+  opts.separator ""
+
+  opts.on('-p','--probability','Print statistical information for the roll') do
+    options[:probability] = true
+  end
+
+  opts.separator ""
+
   opts.on('-h','--help','Display this screen') do
     puts opts
     exit
@@ -31,9 +101,33 @@ else
   abort(usage_string)
 end
 
-dice.roll!
+options.delete(:comparisons)  if options[:comparisons].empty?
+options.delete(:val)  unless options[:comparisons]
+
 if options[:results]
+  dice.roll!
   puts dice.report
-else
-  puts dice.total
+  puts ""
+end
+
+if options[:comparisons]
+  options[:val] ||= :all
+  table = dice.odds.table(options[:val],
+                  options[:comparisons],
+                  options[:headers])
+  table.each do |result_line|
+    puts result_line.join("\t")
+  end
+  puts ""
+end
+
+if options[:probability]
+  puts "Minumum Result:\t\t" + dice.odds.offset.to_s
+  puts "Maximum Result:\t\t" + dice.odds.max_result.to_s
+  puts "Average Result:\t\t" + dice.odds.mean.to_s
+  puts "Standard Deviation:\t" + dice.odds.standard_deviation.round(4).to_s
+end
+
+if options.empty?
+  puts dice.roll
 end

data/lib/dieroll/diceset.rb

@@ -1,7 +1,8 @@
 module Dieroll
   class DiceSet
 
-    def initialize(number_of_dice, sides, sign='+', drop_string)
+    #Create DiceSet object
+    def initialize(number_of_dice, sides, sign='+', drop_string=nil)
       @number_of_dice, @sides, @sign = number_of_dice, sides, sign
       @drop_string = drop_string
       @drops = @drop_string.scan(/[l|h]/)  if !!@drop_string
@@ -11,32 +12,48 @@ module Dieroll
         @dice << Dieroll::Die.new(@sides)
       end
 
-      @last_result = []
+      @last_results = []
       @last_total = nil
     end
 
-    def roll!
-      @last_result = []
+    #Rolls the DiceSet. Returns the result.
+    def roll(save=false)
+      results = []
       @dice.each do |die|
-        @last_result << die.roll!
+        if save
+          results << die.roll!
+        else
+          results << die.roll
+        end
       end
       
-      @last_result.sort!
-      @last_non_dropped = @last_result.dup
+      results.sort!
+      last_non_dropped = results.dup
       if !!@drops
         @drops.each do |drop|
-          @last_non_dropped.shift  if drop == 'l'
-          @last_non_dropped.pop  if drop == 'h'
+          last_non_dropped.shift  if drop == 'l'
+          last_non_dropped.pop  if drop == 'h'
         end
       end
 
-      @last_total = @last_non_dropped.inject(0){|sum, element| sum + element}
-      @last_total *= -1  if @sign == '-'
+      total = last_non_dropped.inject(0){|sum, element| sum + element}
+      total *= -1  if @sign == '-'
+
+      @last_results = results  if save
+      @last_non_dropped = last_non_dropped  if save
+      @last_total = total  if save
 
-      @last_total
+      total
     end
 
-    def to_s
+    #Rolls the DiceSet. Returns the result.
+    #Updates @last_total, @last_result, @last_non_dropped
+    def roll!
+      roll(true)
+    end
+
+    #Returns a string with details of the last roll.
+    def report
       output = "#{@sign}#{@number_of_dice}d#{@sides}"
       output += "/#{@drop_string}"  if !!@drop_string
       output += ": "
@@ -47,5 +64,61 @@ module Dieroll
       output
     end
 
+    #Returns the Odds for the DiceSet. Creates Odds if it doesn't exist.
+    def odds
+      calculate_odds unless !!@odds
+
+      @odds
+    end
+
+    #Returns @last_total as a string.
+    def to_s
+      @last_total.to_s
+    end
+
+    private
+
+    #Creates a new Odds object for the DiceSet.
+    def calculate_odds
+      if !@drops
+        @odds = @dice[0].odds ** @number_of_dice
+        if(@sign == '-')
+          @odds.offset = @sides * @number_of_dice * -1
+        end
+      else
+        possibilities = []
+        num_possibilities = @sides ** @number_of_dice
+
+        current_side = 1
+
+        @number_of_dice.times do |dice|
+          possibilities.sort!
+          num_possibilities.times do |possibility|
+            possibilities[possibility] ||= []
+            possibilities[possibility] << current_side
+            current_side += 1
+            current_side = 1  if current_side > @sides
+          end
+        end
+        
+        combinations_array = []
+        possibilities.each do |possibility|
+          possibility.sort!
+          @drops.each do |drop|
+            possibility.shift  if drop == 'l'
+            possibility.pop  if drop == 'h'
+          end
+          total = possibility.inject(0) {|sum, element| sum + element}
+          combinations_array[total] ||= 0
+          combinations_array[total] += 1
+        end
+        offset = @number_of_dice - @drops.size
+        offset.times do
+          combinations_array.shift
+        end
+        @odds = Dieroll::Odds.new(combinations_array, offset)
+      end
+    end
+
   end
 end

data/lib/dieroll/die.rb

@@ -1,19 +1,48 @@
 module Dieroll
   class Die
 
+    #Create Die object
     def initialize(sides)
       @sides = sides
       @last_result = nil
     end
 
+    #Roll the Die. Returns the result.
+    def roll(save=false)
+      result = rand(1..@sides)
+      @last_result = result  if save
+
+      result
+    end
+
+    #Roll the Die. Returns the result. Saves last_result.
     def roll!
-      @last_result = rand(1..@sides)
+      roll(true)
+    end
+
+    #Returns the Die's Odds object. Creates Odds if it doesn't exist.
+    def odds
+      calculate_odds unless !!@odds
 
-      @last_result
+      @odds
     end
 
+    #Return last_result as a string
     def to_s
-      "#{@last_result}"
+      @last_result.to_s
     end
+
+    private
+
+    #Create a new Odds object for the Die.
+    def calculate_odds
+      combinations_array = []
+      
+      @sides.times do
+        combinations_array << 1
+      end
+      @odds = Dieroll::Odds.new(combinations_array)
+    end
+
   end
 end

data/lib/dieroll/odds.rb

@@ -0,0 +1,164 @@
+module Dieroll class Odds
+    attr_reader :combinations_array, :max_result, :variance,
+                :standard_deviation, :mean, :offset
+
+    def initialize(combinations_array, offset=1)
+      @combinations_array = combinations_array
+      @offset = offset
+      sum_combinations
+      calculate_odds
+      calculate_statistics
+    end
+
+    def *(other)
+      result_array = []
+      @combinations_array.each_with_index do |combination_one, index_one|
+        other.combinations_array.each_with_index do |combination_two, index_two|
+          result_array[index_one + index_two] ||= 0
+          result_array[index_one + index_two] +=
+            combination_one * combination_two
+        end
+      end
+
+      offset = @offset + other.offset
+
+      Odds.new(result_array, offset)
+    end
+
+    def **(number)
+      original = Odds.new(@combinations_array)
+      result = Odds.new(@combinations_array)
+      number -= 1
+      number.times do
+        result *= original
+      end
+
+      result
+    end
+
+    def +(mod)
+      mod += @offset
+
+      Odds.new(@combinations_array, mod)
+    end
+
+    def -(mod)
+      mod = @offset - mod
+
+      Odds.new(@combinations_array, mod)
+    end
+    
+    def offset=(offset)
+      @offset = offset
+      calculate_statistics
+    end
+
+
+    def equal(result)
+      if(result-@offset >= 0 && !!@odds_array[result-@offset])
+        @odds_array[result-@offset]
+      else
+        0
+      end
+    end
+    
+    def not_equal(result)
+      1 - equal(result)
+    end
+
+    def greater_than(result)
+      total_chance = 0
+      @odds_array.each_with_index do |chance, index|
+        if(index+@offset > result)
+          total_chance += chance
+        end
+      end
+
+      total_chance
+    end
+
+    def greater_than_or_equal(result)
+      self.greater_than(result) + self.equal(result)
+    end
+
+    def less_than(result)
+      1 - greater_than_or_equal(result)
+    end
+
+    def less_than_or_equal(result)
+      1 - greater_than(result)
+    end
+
+    def to_s
+      "#{@odds_array}"
+    end
+    
+    def table(value, comparison_array, header=false)
+      valid_comparisons = [:not_equal, :equal,
+                            :less_than, :less_than_or_equal,
+                            :greater_than_or_equal, :greater_than]
+      if value == :all
+        range = (@offset..@max_result)
+      else
+        if value.kind_of?(Range)
+          range = value
+        else
+          range = [value]
+        end
+      end
+
+      result_lines = []
+      if header
+        result_lines << comparison_array
+        result_lines[0].unshift "result"
+      end
+
+      range.each do |result|
+        result_line = [result]
+        comparison_array.each do |comparison|
+          if valid_comparisons.include?(comparison)
+            result_line << self.send(comparison, result).round(4)
+          end
+        end
+        result_lines << result_line
+      end
+
+      result_lines
+    end
+
+    private
+
+    def sum_combinations
+      @combinations_total = @combinations_array.inject(0) do |sum, element|
+        sum + element
+      end
+    end
+
+    def calculate_odds
+      @odds_array = @combinations_array.map do |combination|
+        (combination.to_f / @combinations_total.to_f)
+      end
+    end
+    
+    def calculate_statistics
+      @max_result = @combinations_array.size + @offset - 1
+
+      results_sum = 0
+      total_results = 0
+      (@offset..@max_result).each do |result|
+        results_sum += @combinations_array[result-@offset] * result
+        total_results += @combinations_array[result-@offset]
+      end
+      @mean = results_sum.to_f  / total_results
+
+      variance_sum = 0
+      (@offset..@max_result).each do |result|
+        variance_sum += (result - @mean)**2 *
+                        @combinations_array[result - @offset]
+      end
+      @variance = (variance_sum.to_f / @combinations_total)
+
+      @standard_deviation = (Math.sqrt @variance)
+    end
+  end
+end

data/lib/dieroll/roller.rb

@@ -8,7 +8,7 @@ module::Dieroll
       rand(1..sides)
     end
 
-    # Roll arbitrary 'XdY+Z' string
+    # Roll arbitrary dice notation string
     def self.from_string(string)
       rolls = [0]
       sets = s_to_set(string)
@@ -24,7 +24,7 @@ module::Dieroll
 
       rolls
     end
-    
+
     # Create roller object
     def initialize(string)
       @string = string
@@ -44,45 +44,81 @@ module::Dieroll
       end
     end
 
-    # Determine results of roll
-    def roll!
-      @total = 0
+    # Updates the object to use a new dice notation string
+    def string=(string)
+      @string = string
+      @odds = nil
+      initialize(@string)
+    end
+
+    # Rolls the Roller. Returns the total.
+    def roll(save=false)
+      total = 0
       @dice_sets.each do |set|
-        @total += set.roll!
+        if save
+          total += set.roll!
+        else
+          total += set.roll
+        end
       end
       @mods.each do |mod|
-        @total += mod
+        total += mod
       end
 
-      @total
+      @total = total  if save
+
+      total
+    end
+
+    # Rolls the Roller. Returns the total. Sets @total.
+    def roll!
+      roll(true)
     end
 
     # Return roll result as string
     def report
-      output = "#{@total}\n"
-      output += "#{@string}:\n"
+      output = @total.to_s + "\n"
+      output += @string.to_s + ":\n"
       @dice_sets.each do |set|
-        output += "#{set.to_s}\n"
+        output += set.report + "\n"
       end
       @mods.each do |mod|
         output += "+"  if mod >= 0
-        output += "#{mod}\n"
+        output += mod.to_s + "\n"
       end
       
       output
     end
-    
-    def to_s
-      "#{@total}"
+
+    # Returns @odds. Creates an Odds object if !@odds.
+    def odds
+      calculate_odds unless !!@odds
+
+      @odds
     end
 
-    def string=(string)
-      @string = string
-      initialize(@string)
+    # Returns @total as a string
+    def to_s
+      @total.to_s
     end
 
     private
 
+    # Creates the the Odds object for the roller.
+    def calculate_odds
+      @dice_sets.each_with_index do |set, index|
+        if(index == 0)
+          @odds = set.odds
+        else
+          @odds *= set.odds
+        end
+      end
+
+      @mods.each do |mod|
+        @odds += mod
+      end
+    end
+
     def self.roll(num, sides)
       total = 0
       dice = []
@@ -91,7 +127,8 @@ module::Dieroll
       end
       Dieroll::Result.new(sides, dice)
     end
-    
+
+    # Parse str and return an array to create DiceSets.
     def self.s_to_set(str)
       sets = []
       set_strings = str.scan(/^[^+|-]+|[+|-][^+|-]+/)

data/lib/dieroll.rb

@@ -2,3 +2,4 @@ require 'dieroll/roller'
 require 'dieroll/result'
 require 'dieroll/die'
 require 'dieroll/diceset'
+require 'dieroll/odds'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dieroll
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-17 00:00:00.000000000 Z
+date: 2012-03-25 00:00:00.000000000 Z
 dependencies: []
-description: Dieroll allows for rolling dice described by 'XdY+Z' strings
+description: Dieroll allows for rolling dice described by dice notation
 email: 
 executables:
 - dieroll
@@ -19,6 +19,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/dieroll/roller.rb
+- lib/dieroll/odds.rb
 - lib/dieroll/result.rb
 - lib/dieroll/diceset.rb
 - lib/dieroll/die.rb