games_dice 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Dependencies are in games_dice.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Neil Slater
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# GamesDice
+
+A library for simulating dice, intended for constructing a variety of dice systems as used in
+role-playing and board games.
+
+## Special Note on Versions Prior to 1.0.0
+
+The author is using this code as an exercise in gem "best practice". As such, the gem
+will have a deliberately limited set of functionality prior to version 1.0.0, and there should be
+many small release increments before then.
+
+The functionality should expand to cover dice systems seen in many role-playing systems, as it
+progresses through 0.x.y versions (in fact much of this code is already written and working, so if
+you have a burning need to simulate dice rolls for a specific game, feel free to get in touch).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'games_dice'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install games_dice
+
+## Usage
+
+    require 'games_dice'
+
+    # Simple 6-sided die, more to follow
+    d = GamesDice::Die.new( 6 )
+    d.roll         # => 4
+    d.result       # => 4
+    d.explain_roll # => "4"
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/games_dice.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'games_dice/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "games_dice"
+  gem.version       = GamesDice::VERSION
+  gem.authors       = ["Neil Slater"]
+  gem.email         = ["slobo777@gmail.com"]
+  gem.description   = %q{A simulated-dice library, with flexible rules that allow dice systems from
+                        many board and roleplay games to be built, run and reported.}
+  gem.summary       = %q{Simulates and explains dice rolls from a variety of game systems.}
+  gem.homepage      = ""
+
+  gem.add_development_dependency "rspec"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/games_dice.rb

@@ -0,0 +1,6 @@
+require "games_dice/version"
+require "games_dice/die"
+
+module GamesDice
+  # TODO: Factory methods for various dice schemes
+end

data/lib/games_dice/die.rb

@@ -0,0 +1,92 @@
+module GamesDice
+  # basic die that rolls 1..N, typically with equal weighting for each value
+  #  d = Die.new(6)
+  #  d.roll # => Integer in range 1..6
+  #  d.result # => same Integer value as returned by d.roll
+  class Die
+    # sides is e.g. 6 for traditional cubic die, or 20 for icosahedron.
+    # It can take non-traditional values, such as 7, but must be at least 1.
+    # prng is an object that has a rand(x) method. If provided, it will be called as
+    # prng.rand(sides), and is expected to return an integer in range 0...sides
+    def initialize( sides, prng=nil )
+      @sides = Integer(sides)
+      raise ArgumentError, "sides value #{sides} is too low, it must be 1 or greater" if @sides < 1
+      raise ArgumentError, "prng does not support the rand() method" if prng && ! prng.respond_to?(:rand)
+      @prng = prng
+      @result = nil
+    end
+
+    # number of sides as set by #new
+    attr_reader :sides
+
+    # integer result of last call to #roll, nil if no call made yet
+    attr_reader :result
+
+    # minimum possible value
+    def min
+      1
+    end
+
+    # maximum possible value
+    def max
+      @sides
+    end
+
+    # returns a hash of value (Integer) => probability (Float) pairs
+    def probabilities
+      return @probabilities if @probabilities
+      density = 1.0/@sides
+      @probabilities = (1..@sides).inject({}) { |h,x| h[x] = density; h }
+    end
+
+    # returns mean expected value as a Float
+    def expected_result
+      0.5 * (1 + @sides)
+    end
+
+    # returns probability than a roll will produce a number greater than target integer
+    def probability_gt target
+      probability_ge( Integer(target) + 1 )
+    end
+
+    # returns probability than a roll will produce a number greater than or equal to target integer
+    def probability_ge target
+      target = Integer(target)
+      return 1.0 if target <= 1
+      return 0.0 if target > @sides
+      return 1.0 * (1.0 + @sides - target )/@sides
+    end
+
+    # returns probability than a roll will produce a number less than or equal to target integer
+    def probability_le target
+      target = Integer(target)
+      return 1.0 if target >= @sides
+      return 0.0 if target < 1
+      return 1.0 * target/@sides
+    end
+
+    # returns probability than a roll will produce a number less than target integer
+    def probability_lt target
+      probability_le( Integer(target) - 1 )
+    end
+
+    # generates Integer between #min and #max, using rand()
+    def roll
+      if @prng
+        @result = @prng.rand(@sides) + 1
+      else
+        @result = rand(@sides) + 1
+      end
+    end
+
+    # always nil, available for compatibility with ComplexDie
+    def rerolls
+      nil
+    end
+
+    # always nil, available for compatibility with ComplexDie
+    def maps
+      nil
+    end
+  end # class Die
+end # module GamesDice

data/lib/games_dice/version.rb

@@ -0,0 +1,3 @@
+module GamesDice
+  VERSION = "0.0.1"
+end

data/spec/die_spec.rb

@@ -0,0 +1,95 @@
+require 'games_dice/die'
+
+# Test helper class, a stub of a PRNG
+class TestPRNG
+  def initialize
+    # Numbers that I randomly thought up!
+    @numbers = [0.123,0.234,0.345,0.999,0.876,0.765,0.543,0.111,0.333,0.777]
+  end
+  def rand(n)
+    Integer( n * @numbers.pop )
+  end
+end
+
+describe GamesDice::Die do
+
+  before do
+    # Set state of default PRNG
+    srand(4567)
+  end
+
+  describe "#new" do
+    it "should return an object that represents e.g. a six-sided die" do
+      die = GamesDice::Die.new(6)
+      die.min.should == 1
+      die.max.should == 6
+      die.sides.should == 6
+      die.probabilities.should == { 1 => 1.0/6, 2 => 1.0/6, 3 => 1.0/6, 4 => 1.0/6, 5 => 1.0/6, 6 => 1.0/6 }
+      die.expected_result.should == 3.5
+    end
+
+    it "should accept any object with a rand(Integer) method as the second param" do
+      prng = TestPRNG.new()
+      die = GamesDice::Die.new(20,prng)
+      [16,7,3,11,16,18,20,7].each do |expected|
+        die.roll.should == expected
+        die.result.should == expected
+      end
+    end
+  end
+
+  describe "#roll and #result" do
+    it "should return results based on Ruby's internal rand() by default" do
+    die = GamesDice::Die.new(10)
+      [5,4,10,4,7,8,1,9].each do |expected|
+        die.roll.should == expected
+        die.result.should == expected
+      end
+    end
+  end
+
+  describe "#min and #max" do
+    it "should calculate correct min, max" do
+      die = GamesDice::Die.new(20)
+      die.min.should == 1
+      die.max.should == 20
+    end
+  end
+
+  describe "#expected_result" do
+    it "should calculate correct weighted mean" do
+      die = GamesDice::Die.new(20)
+      die.expected_result.should be_within(1e-10).of 10.5
+    end
+  end
+
+  describe "#probabilities" do
+    it "should calculate probabilities accurately" do
+      die = GamesDice::Die.new(6)
+      die.probabilities[1].should be_within(1e-10).of 1/6.0
+      die.probabilities[2].should be_within(1e-10).of 1/6.0
+      die.probabilities[3].should be_within(1e-10).of 1/6.0
+      die.probabilities[4].should be_within(1e-10).of 1/6.0
+      die.probabilities[5].should be_within(1e-10).of 1/6.0
+      die.probabilities[6].should be_within(1e-10).of 1/6.0
+      die.probabilities.values.inject(:+).should be_within(1e-9).of 1.0
+
+      die.probability_gt(6).should == 0.0
+      die.probability_gt(-20).should == 1.0
+      die.probability_gt(4).should be_within(1e-10).of 2/6.0
+
+      die.probability_ge(20).should == 0.0
+      die.probability_ge(1).should == 1.0
+      die.probability_ge(4).should be_within(1e-10).of 0.5
+
+      die.probability_le(6).should == 1.0
+      die.probability_le(-3).should == 0.0
+      die.probability_le(5).should be_within(1e-10).of 5/6.0
+
+      die.probability_lt(7).should == 1.0
+      die.probability_lt(1).should == 0.0
+      die.probability_lt(3).should be_within(1e-10).of 2/6.0
+    end
+  end
+
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: games_dice
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Neil Slater
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "A simulated-dice library, with flexible rules that allow dice systems
+  from\n                        many board and roleplay games to be built, run and
+  reported."
+email:
+- slobo777@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- games_dice.gemspec
+- lib/games_dice.rb
+- lib/games_dice/die.rb
+- lib/games_dice/version.rb
+- spec/die_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Simulates and explains dice rolls from a variety of game systems.
+test_files:
+- spec/die_spec.rb
+has_rdoc: