dice_roller 0.0.1

data/bin/dice_roller

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'dice_roller'
+
+DiceRoller::Cli.new(ARGV)

data/lib/dice_roller/cli.rb

@@ -0,0 +1,102 @@
+require 'optparse'
+
+# this class handles parsing the command-line options
+# and calling the appropriate actions
+class DiceRoller::Cli
+  attr_reader :four, :six, :eight, :ten, :twelve, :twenty, :percentile, :type, :minimum, :reroll, :subtract
+  
+  def initialize(args)
+    # default the number of each type of dice to zero
+    four = six = eight = ten = twelve = twenty = percentile = 0
+    
+    # default result set to sum
+    type = :sum
+
+    # default minimum value for success to 8
+    minimum = 8
+
+    # default reroll value to 10
+    reroll = 10
+
+    # default to ones not subtracting successes
+    subtract = false
+    
+    options = OptionParser.new do |opts|
+      opts.banner = "Usage: dice-roller"
+      
+      opts.on("--four dice", Integer, "number of four-sided dice to roll") do |dice|
+        @four = dice
+      end
+      
+      opts.on("--six dice", Integer, "number of six-sided dice to roll") do |dice|
+        @six = dice
+      end
+      
+      opts.on("--eight dice", Integer, "number of eight-sided dice to roll") do |dice|
+        @eight = dice
+      end
+      
+      opts.on("--ten dice", Integer, "number of ten-sided dice to roll") do |dice|
+        @ten = dice
+      end
+      
+      opts.on("--twelve dice", Integer, "number of twelve-sided dice to roll") do |dice|
+        @twelve = dice
+      end
+      
+      opts.on("--twenty dice", Integer, "number of twenty-sided dice to roll") do |dice|
+        @twenty = dice
+      end
+      
+      opts.on("--percentile dice", Integer, "number of percentile dice to roll") do |dice|
+        @percentile = dice
+      end
+      
+      opts.on("--type [sum|successes]", [:sum, :successes], "select type of result (sum, successes)") do |t|
+        @type = t
+
+        if @type.nil?
+          puts opts
+          exit
+        end
+      end
+
+      opts.on("--reroll number", Integer, "rolling this or above rolls another ten-sided dice") do |val|
+        @reroll = val
+      end
+
+      opts.on("--rote", "make this roll a rote action") do |flag|
+        # DiceRoller::DicePool interprets a reroll value of 0 as a rote action
+        @reroll = 0 if flag
+      end
+
+      opts.on("--min number", Integer, "minimum value to be considered a success") do |min|
+        @minimum = min
+      end
+
+      opts.on("--[no-]sub", "cause ones to subtract from the success total") do |flag|
+        @subtract = flag
+      end
+    end
+    
+    begin
+      options.parse!(args)
+    rescue OptionParser::MissingArgument => e
+      puts "Missing argument"
+      puts options
+      exit
+    rescue OptionParser::InvalidArgument => e
+      puts "Invalid argument"
+      puts options
+      exit
+    rescue OptionParser::InvalidOption => e
+      puts "Invalid option"
+      puts options
+      exit
+    end
+    
+    return if $TEST
+    
+    ::DiceRoller.new(@four, @six, @eight, @ten, @twelve, @twenty, @percentile, @type, @reroll, @minimum, @subtract)
+  end
+end

data/lib/dice_roller/dice.rb

@@ -0,0 +1,18 @@
+# A class representing a single dice. Rolling this dice returns the result
+class DiceRoller::Dice
+  attr_accessor :faces
+  attr_reader :value
+
+  # create a single dice
+  #
+  # faces: the number of sides on the dice
+  def initialize(faces = 6)
+    @faces = faces
+    @value = nil
+  end
+
+  # roll the dice, storing and returning the resuilt
+  def roll()
+    @value = rand(@faces) + 1
+  end
+end

data/lib/dice_roller/dice_pool.rb

@@ -0,0 +1,107 @@
+# A class representing a bunch of dice (many objects of class Dice).
+# Rolling this die pool returns an object of the DiceResult class
+class DiceRoller::DicePool
+  attr_accessor :num_four, :num_six, :num_eight, :num_ten, :num_twelve, :num_twenty, :num_percentile, :result
+
+  # create a pool of Dice with different numbers of sides
+  #
+  # num_four: the number of four-sided dice in the pool
+  # num_six: the number of six-sided dice in the pool
+  # num_eight: the number of eight-sided dice in the pool
+  # num_ten: the number of ten-sided dice in the pool
+  # num_twelve: the number of twelve-sided dice in the pool
+  # num_twenty: the number of twenty-sided dice in the pool
+  # num_percentile: the number of percentile (100-sided) dice in the pool
+  def initialize(four = 0, six = 0, eight = 0, ten = 0, twelve = 0, twenty = 0, percentile = 0)
+    @num_four = four
+    @num_six = six
+    @num_eight = eight
+    @num_ten = ten
+    @num_twelve = twelve
+    @num_twenty = twenty
+    @num_percentile = percentile
+
+    @result = ::DiceRoller::DiceResult.new
+  end
+
+  # roll the dice in the pool, with options. by default, roll_pool returns
+  # the numer of successes rolled
+  #
+  # success_value: on 10-sided dice, the minimum value to be considered a success
+  # sum_num: instead of displaying successes, display the total value rolled on all dice
+  # number_successes: instead of returning the sum total rolled, return the successes
+  # one_cancels: 1s rolled on a d10 subtract from the total successes
+  # roll_again: the number on a d10 above which another d10 should be rolled
+  def roll_pool(success_value = 8, sum_num = false, number_successes = true, one_cancels = false, roll_again = 10)
+    sum_value = 0
+    successes = 0
+    ones = 0
+    rerolls = 0
+    rote_rerolls = 0
+    roll_again = roll_again.to_i
+    rote = false
+
+    if roll_again == 0
+      roll_again = 10
+      rote = true
+    end
+
+    # set up a single dice of each type and an array to store their results
+    four_sided = ::DiceRoller::Dice.new(4)
+    four_results = []
+
+    six_sided = ::DiceRoller::Dice.new(6)
+    six_results = []
+
+    eight_sided = ::DiceRoller::Dice.new(8)
+    eight_results = []
+
+    ten_sided = ::DiceRoller::Dice.new(10)
+    ten_results = []
+
+    twelve_sided = ::DiceRoller::Dice.new(12)
+    twelve_results = []
+
+    twenty_sided = ::DiceRoller::Dice.new(20)
+    twenty_results =  []
+
+    percentile = ::DiceRoller::Dice.new(100)
+    percentile_results = []
+
+    # roll dem bones!
+    @num_four.times do
+      four_results << four_sided.roll
+    end
+    @num_six.times do
+      six_results << six_sided.roll
+    end
+    @num_eight.times do
+      eight_results << eight_sided.roll
+    end
+    @num_ten.times do
+      ten_results << ten_sided.roll
+    end
+    @num_twelve.times do
+      twelve_results << twelve_sided.roll
+    end
+    @num_twenty.times do
+      twenty_results << twenty_sided.roll
+    end
+    @num_percentile.times do
+      percentile_results << percentile.roll
+    end
+
+    ::DiceRoller::DiceResult.new(four_results, six_results, eight_results, ten_results, twelve_results, twenty_results, percentile_results)
+  end
+
+  # overrides the inspect method to provide some useful output
+  def inspect()
+    puts "four-sided dice: #{@num_four}"
+    puts "six-sided dice: #{@num_six}"
+    puts "eight-sided dice: #{@num_eight}"
+    puts "ten-sided dice: #{@num_ten}"
+    puts "twelve-sided dice: #{@num_twelve}"
+    puts "twenty-sided dice: #{@num_twenty}"
+    puts "percentile dice: #{@num_percentile}"
+  end
+end

data/lib/dice_roller/dice_result.rb

@@ -0,0 +1,106 @@
+# represents a result set from rolled dice
+# it takes a series of arrays as input -- these arrays
+# should contain the results of dice rolls
+class DiceRoller::DiceResult
+  attr_reader :four_result, :six_result, :eight_result, :ten_result, :twelve_result, :twenty_result, :percentile_result
+
+  def initialize(four = [], six = [], eight = [], ten = [], twelve = [], twenty = [], percentile = [])
+    @four_result = four
+    @six_result = six
+    @eight_result = eight
+    @ten_result = ten
+    @twelve_result = twelve
+    @twenty_result = twenty
+    @percentile_result = percentile
+    @rerolled = false
+  end
+
+  # returns the sum total of all values in the results
+  def total
+    sum = 0
+
+    @four_result.each do |result|
+      sum += result
+    end
+    @six_result.each do |result|
+      sum += result
+    end
+    @eight_result.each do |result|
+      sum += result
+    end
+    @ten_result.each do |result|
+      sum += result
+    end
+    @twelve_result.each do |result|
+      sum += result
+    end
+    @twenty_result.each do |result|
+      sum += result
+    end
+    @percentile_result.each do |result|
+      sum += result
+    end
+
+    sum
+  end
+
+  # returns a hash with the number of successes (as determined by the paremeters)
+  # and the results of all the dice rolled
+  #
+  # min: minimum value for a success
+  # reroll: minimum value to roll an additional d10
+  # subtract: if true, causes values of 1 to subtract from the success total
+  def successes(min = 8, reroll = 10, subtract = false)
+    count = 0
+    rote = false
+
+    # if this result set has already been rerolled, simply count the successes
+    # in the result and return the total (rather than rerolling /again/)
+    if @rerolled
+      @ten_result.each do |value|
+        count += 1 if value >= min
+      end
+
+      return count
+    end
+
+    if reroll == 0
+      reroll = 10
+      rote = true
+    end
+
+    # this bonus dice is used for any rerolls that accrue
+    bonus_dice = ::DiceRoller::Dice.new(sides = 10)
+
+    # reroll failed dice once and add the results to the array
+    if rote
+      rote_rerolls = []
+
+      @ten_result.each do |result|
+        rote_rerolls << bonus_dice.roll if result < min
+      end
+
+      @ten_result += rote_rerolls
+    end
+
+    # loop through the rolled results and count successes. values greater than
+    # the reroll value are rolled again.
+    @ten_result.each do |result|
+      count += 1 if result >= min
+      count -= 1 if subtract and result == 1
+
+      # each pass through this loop is a rerolled dice
+      while result >= reroll
+        result = bonus_dice.roll
+
+        # add the result for historical accuracy
+        @ten_result << result
+
+        count += 1 if result >= min
+      end
+    end
+
+    @rerolled = true
+    count
+  end
+end

data/lib/dice_roller.rb

@@ -0,0 +1,55 @@
+# rolls dice and formats the results
+class DiceRoller
+  def initialize(four = 0, six = 0, eight = 0, ten = 0, twelve = 0, twenty = 0, percentile = 0, type = :sum, reroll = 10, minimum = 8, subtract = false)
+    results = DicePool.new(four, six, eight, ten, twelve, twenty, percentile).roll_pool
+
+    case type
+    when :sum
+      # output each dice's value and the sum total
+      results.four_result.each do |value|
+        puts "four-sided dice: #{value}"
+      end
+      
+      results.six_result.each do |value|
+        puts "six-sided dice: #{value}"
+      end
+      
+      results.eight_result.each do |value|
+        puts "eight-sided dice: #{value}"
+      end
+      
+      results.ten_result.each do |value|
+        puts "ten-sided dice: #{value}"
+      end
+      
+      results.twelve_result.each do |value|
+        puts "twelve-sided dice: #{value}"
+      end
+      
+      results.twenty_result.each do |value|
+        puts "twenty-sided dice: #{value}"
+      end
+      
+      results.percentile_result.each do |value|
+        puts "percentile dice: #{value}"
+      end
+      
+      puts "sum total: #{results.total}"
+    when :successes
+      # output the ten-sided dice's values and the
+      # number of successes
+      suxx = results.successes(minimum, reroll, subtract)
+
+      results.ten_result.each do |value|
+        puts "ten-sided dice: #{value}"
+      end
+
+      puts "successes: #{suxx}"
+    end
+  end
+end
+
+require 'dice_roller/dice'
+require 'dice_roller/dice_pool'
+require 'dice_roller/dice_result'
+require 'dice_roller/cli'

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: dice_roller
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alex Chvatal
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-27 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: "    dice_roller is a pure ruby application that rolls dice for role playing games.\n    it is primarily built to handle d20 or Storytelling style rolls.\n"
+email: 
+- m.chvatal@gmail.com
+executables: 
+- dice_roller
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/dice_roller/cli.rb
+- lib/dice_roller/dice.rb
+- lib/dice_roller/dice_pool.rb
+- lib/dice_roller/dice_result.rb
+- lib/dice_roller.rb
+- bin/dice_roller
+has_rdoc: true
+homepage: https://github.com/yithian/dice_roller
+licenses: 
+- GPL
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: a dice roller for games
+test_files: []
+