games_dice 0.5.0 → 0.6.0

data/spec/complex_die_spec.rb

@@ -1,314 +0,0 @@
-# frozen_string_literal: true
-
-require 'helpers'
-
-describe GamesDice::ComplexDie do
-  before do
-    # Set state of default PRNG
-    srand(4567)
-  end
-
-  it 'represent a basic die as an object' do
-    die = described_class.new(6)
-    expect(die.min).to be 1
-    expect(die.max).to be 6
-    expect(die.sides).to be 6
-  end
-
-  it "return results based on Ruby's internal rand() by default" do
-    die = described_class.new(10)
-    [5, 4, 10, 4, 7, 8, 1, 9].each do |expected|
-      expect(die.roll.value).to eql expected
-      expect(die.result.value).to eql expected
-    end
-  end
-
-  it 'use any object with a rand(Integer) method' do
-    prng = TestPRNG.new
-    die = described_class.new(20, prng: prng)
-    [16, 7, 3, 11, 16, 18, 20, 7].each do |expected|
-      expect(die.roll.value).to eql expected
-      expect(die.result.value).to eql expected
-    end
-  end
-
-  it 'optionally accept a rerolls param' do
-    described_class.new(10, rerolls: [])
-    described_class.new(10, rerolls: [GamesDice::RerollRule.new(6, :<=, :reroll_add)])
-    described_class.new(10,
-                        rerolls: [GamesDice::RerollRule.new(6, :<=, :reroll_add),
-                                  GamesDice::RerollRule.new(1, :>=, :reroll_subtract)])
-    described_class.new(10, rerolls: [[6, :<=, :reroll_add]])
-    described_class.new(10, rerolls: [[6, :<=, :reroll_add], [1, :>=, :reroll_subtract]])
-
-    expect do
-      described_class.new(10, rerolls: 7)
-    end.to raise_error(TypeError)
-
-    expect do
-      described_class.new(10, rerolls: ['hello'])
-    end.to raise_error(TypeError)
-
-    expect do
-      described_class.new(10, rerolls: [GamesDice::RerollRule.new(6, :<=, :reroll_add), :reroll_add])
-    end.to raise_error(TypeError)
-
-    expect do
-      described_class.new(10, rerolls: [7])
-    end.to raise_error(TypeError)
-
-    expect do
-      described_class.new(10, rerolls: [['hello']])
-    end.to raise_error(ArgumentError)
-
-    expect do
-      described_class.new(10, rerolls: [[6, :<=, :reroll_add], :reroll_add])
-    end.to raise_error(TypeError)
-  end
-
-  it 'optionally accept a maps param' do
-    described_class.new(10, maps: [])
-    described_class.new(10, maps: [GamesDice::MapRule.new(7, :<=, 1)])
-    described_class.new(10, maps: [GamesDice::MapRule.new(7, :<=, 1), GamesDice::MapRule.new(1, :>, -1)])
-    described_class.new(10, maps: [[7, :<=, 1]])
-    described_class.new(10, maps: [[7, :<=, 1], [1, :>, -1]])
-
-    expect do
-      described_class.new(10, maps: 7)
-    end.to raise_error(TypeError)
-
-    expect do
-      described_class.new(10, maps: [7])
-    end.to raise_error(TypeError)
-
-    expect do
-      described_class.new(10, maps: [[7]])
-    end.to raise_error(ArgumentError)
-
-    expect do
-      described_class.new(10, maps: ['hello'])
-    end.to raise_error(TypeError)
-
-    expect do
-      described_class.new(10,
-                          maps: [GamesDice::MapRule.new(7, :<=, 1),
-                                 GamesDice::RerollRule.new(6, :<=, :reroll_add)])
-    end.to raise_error(TypeError)
-  end
-
-  describe 'with rerolls' do
-    it 'calculate correct minimum and maximum results' do
-      die = described_class.new(10, rerolls: [GamesDice::RerollRule.new(10, :<=, :reroll_add, 3)])
-      expect(die.min).to be 1
-      expect(die.max).to be 40
-
-      die = described_class.new(10, rerolls: [[1, :>=, :reroll_subtract]])
-      expect(die.min).to be(-9)
-      expect(die.max).to be 10
-
-      die = described_class.new(10, rerolls: [GamesDice::RerollRule.new(10, :<=, :reroll_add)])
-      expect(die.min).to be 1
-      expect(die.max).to be 10_010
-    end
-
-    it 'simulate a d10 that rerolls and adds on a result of 10' do
-      die = described_class.new(10, rerolls: [[10, :<=, :reroll_add]])
-      [5, 4, 14, 7, 8, 1, 9].each do |expected|
-        expect(die.roll.value).to eql expected
-        expect(die.result.value).to eql expected
-      end
-    end
-
-    it 'explain how it got results outside range 1 to 10 on a d10' do
-      die = described_class.new(10, rerolls: [[10, :<=, :reroll_add], [1, :>=, :reroll_subtract]])
-      ['5', '4', '[10+4] 14', '7', '8', '[1-9] -8'].each do |expected|
-        die.roll
-        expect(die.explain_result).to eql expected
-      end
-    end
-
-    it 'calculate an expected result' do
-      die = described_class.new(10, rerolls: [[10, :<=, :reroll_add], [1, :>=, :reroll_subtract]])
-      expect(die.probabilities.expected).to be_within(1e-10).of 5.5
-
-      die = described_class.new(10, rerolls: [GamesDice::RerollRule.new(1, :<=, :reroll_use_best, 1)])
-      expect(die.probabilities.expected).to be_within(1e-10).of 7.15
-
-      die = described_class.new(10, rerolls: [GamesDice::RerollRule.new(1, :<=, :reroll_use_worst, 2)])
-      expect(die.probabilities.expected).to be_within(1e-10).of 3.025
-
-      die = described_class.new(6, rerolls: [GamesDice::RerollRule.new(6, :<=, :reroll_add)])
-      expect(die.probabilities.expected).to be_within(1e-10).of 4.2
-
-      die = described_class.new(8, rerolls: [GamesDice::RerollRule.new(1, :>=, :reroll_use_best)])
-      expect(die.probabilities.expected).to be_within(1e-10).of 5.0
-
-      die = described_class.new(4, rerolls: [GamesDice::RerollRule.new(1, :>=, :reroll_replace, 1)])
-      expect(die.probabilities.expected).to be_within(1e-10).of 2.875
-    end
-
-    it 'calculate probabilities of each possible result' do
-      die = described_class.new(6, rerolls: [GamesDice::RerollRule.new(7, :>, :reroll_add, 1)])
-      probs = die.probabilities.to_h
-      expect(probs[11]).to be_within(1e-10).of 2 / 36.0
-      expect(probs[8]).to be_within(1e-10).of 5 / 36.0
-      expect(probs.values.sum).to be_within(1e-9).of 1.0
-
-      die = described_class.new(10, rerolls: [GamesDice::RerollRule.new(10, :<=, :reroll_add)])
-      probs = die.probabilities.to_h
-      expect(probs[8]).to be_within(1e-10).of 0.1
-      expect(probs[10]).to be_nil
-      expect(probs[13]).to be_within(1e-10).of 0.01
-      expect(probs[27]).to be_within(1e-10).of 0.001
-      expect(probs.values.sum).to be_within(1e-9).of 1.0
-
-      die = described_class.new(6, rerolls: [GamesDice::RerollRule.new(1, :>=, :reroll_replace, 1)])
-      probs = die.probabilities.to_h
-      expect(probs[1]).to be_within(1e-10).of 1 / 36.0
-      expect(probs[2]).to be_within(1e-10).of 7 / 36.0
-      expect(probs.values.sum).to be_within(1e-9).of 1.0
-    end
-
-    it 'calculate aggregate probabilities' do
-      die = described_class.new(6, rerolls: [GamesDice::RerollRule.new(7, :>, :reroll_add, 1)])
-      probs = die.probabilities
-      expect(probs.p_gt(7)).to be_within(1e-10).of 15 / 36.0
-      expect(probs.p_gt(-10)).to be 1.0
-      expect(probs.p_gt(12)).to be 0.0
-
-      expect(probs.p_ge(7)).to be_within(1e-10).of 21 / 36.0
-      expect(probs.p_ge(2)).to be 1.0
-      expect(probs.p_ge(15)).to be 0.0
-
-      expect(probs.p_lt(7)).to be_within(1e-10).of 15 / 36.0
-      expect(probs.p_lt(-10)).to be 0.0
-      expect(probs.p_lt(13)).to be 1.0
-
-      expect(probs.p_le(7)).to be_within(1e-10).of 21 / 36.0
-      expect(probs.p_le(1)).to be 0.0
-      expect(probs.p_le(12)).to be 1.0
-    end
-  end
-
-  describe 'with maps' do
-    it 'calculate correct minimum and maximum results' do
-      die = described_class.new(10, maps: [GamesDice::MapRule.new(7, :<=, 1, 'S')])
-      expect(die.min).to be 0
-      expect(die.max).to be 1
-    end
-
-    it 'simulate a d10 that scores 1 for success on a value of 7 or more' do
-      die = described_class.new(10, maps: [[7, :<=, 1, 'S']])
-      [0, 0, 1, 0, 1, 1, 0, 1].each do |expected|
-        expect(die.roll.value).to eql expected
-        expect(die.result.value).to eql expected
-      end
-    end
-
-    it 'label the mappings applied with the provided names' do
-      die = described_class.new(10, maps: [[7, :<=, 1, 'S'], [1, :>=, -1, 'F']])
-      ['5', '4', '10 S', '4', '7 S', '8 S', '1 F', '9 S'].each do |expected|
-        die.roll
-        expect(die.explain_result).to eql expected
-      end
-    end
-
-    it 'calculate an expected result' do
-      die = described_class.new(10,
-                                maps: [GamesDice::MapRule.new(7, :<=, 1, 'S'),
-                                       GamesDice::MapRule.new(1, :>=, -1, 'F')])
-      expect(die.probabilities.expected).to be_within(1e-10).of 0.3
-    end
-
-    it 'calculate probabilities of each possible result' do
-      die = described_class.new(10,
-                                maps: [GamesDice::MapRule.new(7, :<=, 1, 'S'),
-                                       GamesDice::MapRule.new(1, :>=, -1, 'F')])
-      probs_hash = die.probabilities.to_h
-      expect(probs_hash[1]).to be_within(1e-10).of 0.4
-      expect(probs_hash[0]).to be_within(1e-10).of 0.5
-      expect(probs_hash[-1]).to be_within(1e-10).of 0.1
-      expect(probs_hash.values.sum).to be_within(1e-9).of 1.0
-    end
-
-    it 'calculate aggregate probabilities' do
-      die = described_class.new(10,
-                                maps: [GamesDice::MapRule.new(7, :<=, 1, 'S'),
-                                       GamesDice::MapRule.new(1, :>=, -1, 'F')])
-      probs = die.probabilities
-      expect(probs.p_gt(-2)).to be 1.0
-      expect(probs.p_gt(-1)).to be_within(1e-10).of 0.9
-      expect(probs.p_gt(1)).to be 0.0
-
-      expect(probs.p_ge(1)).to be_within(1e-10).of 0.4
-      expect(probs.p_ge(-1)).to be 1.0
-      expect(probs.p_ge(2)).to be 0.0
-
-      expect(probs.p_lt(1)).to be_within(1e-10).of 0.6
-      expect(probs.p_lt(-1)).to be 0.0
-      expect(probs.p_lt(2)).to be 1.0
-
-      expect(probs.p_le(-1)).to be_within(1e-10).of 0.1
-      expect(probs.p_le(-2)).to be 0.0
-      expect(probs.p_le(1)).to be 1.0
-    end
-  end
-
-  describe 'with rerolls and maps together' do
-    before do
-      @die = described_class.new(6,
-                                 rerolls: [[6, :<=, :reroll_add]],
-                                 maps: [GamesDice::MapRule.new(9, :<=, 1, 'Success')])
-    end
-
-    it 'calculate correct minimum and maximum results' do
-      expect(@die.min).to be 0
-      expect(@die.max).to be 1
-    end
-
-    it 'calculate an expected result' do
-      expect(@die.probabilities.expected).to be_within(1e-10).of 4 / 36.0
-    end
-
-    it 'calculate probabilities of each possible result' do
-      probs_hash = @die.probabilities.to_h
-      expect(probs_hash[1]).to be_within(1e-10).of 4 / 36.0
-      expect(probs_hash[0]).to be_within(1e-10).of 32 / 36.0
-      expect(probs_hash.values.sum).to be_within(1e-9).of 1.0
-    end
-
-    it 'calculate aggregate probabilities' do
-      probs = @die.probabilities
-
-      expect(probs.p_gt(0)).to be_within(1e-10).of 4 / 36.0
-      expect(probs.p_gt(-2)).to be 1.0
-      expect(probs.p_gt(1)).to be 0.0
-
-      expect(probs.p_ge(1)).to be_within(1e-10).of 4 / 36.0
-      expect(probs.p_ge(-1)).to be 1.0
-      expect(probs.p_ge(2)).to be 0.0
-
-      expect(probs.p_lt(1)).to be_within(1e-10).of 32 / 36.0
-      expect(probs.p_lt(0)).to be 0.0
-      expect(probs.p_lt(2)).to be 1.0
-
-      expect(probs.p_le(0)).to be_within(1e-10).of 32 / 36.0
-      expect(probs.p_le(-1)).to be 0.0
-      expect(probs.p_le(1)).to be 1.0
-    end
-
-    it 'apply mapping to final re-rolled result' do
-      [0, 1, 0, 0].each do |expected|
-        expect(@die.roll.value).to eql expected
-        expect(@die.result.value).to eql expected
-      end
-    end
-
-    it 'explain how it got each result' do
-      ['5', '[6+4] 10 Success', '[6+2] 8', '5'].each do |expected|
-        @die.roll
-        expect(@die.explain_result).to eql expected
-      end
-    end
-  end
-end

data/spec/dice_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'helpers'
-
-describe GamesDice::Dice do
-  describe 'dice scheme' do
-    before do
-      srand(67_809)
-    end
-
-    describe '1d10+2' do
-      let(:dice) { described_class.new([{ sides: 10, ndice: 1 }], 2) }
-
-      it 'simulate rolling a ten-sided die, and adding two to each result' do
-        [5, 4, 10, 10, 7, 5, 9].each do |expected_total|
-          expect(dice.roll).to eql expected_total
-          expect(dice.result).to eql expected_total
-        end
-      end
-    end
-
-    describe '2d6+6' do
-      let(:dice) { described_class.new([{ sides: 6, ndice: 2 }], 6) }
-
-      it 'simulate rolling two six-sided dice and adding six to the result' do
-        [15, 12, 17, 15, 13, 13, 16].each do |expected_total|
-          expect(dice.roll).to eql expected_total
-          expect(dice.result).to eql expected_total
-        end
-      end
-    end
-  end
-end

data/spec/die_result_spec.rb

@@ -1,254 +0,0 @@
-# frozen_string_literal: true
-
-require 'helpers'
-
-describe GamesDice::DieResult do
-  describe '.new' do
-    it "work without parameters to represent 'no results yet'" do
-      die_result = described_class.new
-      expect(die_result.value).to be_nil
-      expect(die_result.rolls).to eql []
-      expect(die_result.roll_reasons).to eql []
-    end
-
-    it 'work with a single Integer param to represent an initial result' do
-      die_result = described_class.new(8)
-      expect(die_result.value).to be 8
-      expect(die_result.rolls).to eql [8]
-      expect(die_result.roll_reasons).to eql [:basic]
-    end
-
-    it 'not accept a param that cannot be coerced to Integer' do
-      expect { described_class.new([]) }.to raise_error(TypeError)
-      expect { described_class.new('N') }.to raise_error(ArgumentError)
-    end
-
-    it 'not accept unknown reasons for making a roll' do
-      expect { described_class.new(8, 'wooo') }.to raise_error(ArgumentError)
-      expect { described_class.new(8, :frabulous) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#add_roll' do
-    context "when starting from 'no results yet'" do
-      let(:die_result) { described_class.new }
-
-      it 'create an initial result' do
-        die_result.add_roll(5)
-        expect(die_result.value).to be 5
-        expect(die_result.rolls).to eql [5]
-        expect(die_result.roll_reasons).to eql [:basic]
-      end
-
-      it 'accept non-basic reasons for the first roll' do
-        die_result.add_roll(4, :reroll_subtract)
-        expect(die_result.value).to be(-4)
-        expect(die_result.rolls).to eql [4]
-        expect(die_result.roll_reasons).to eql [:reroll_subtract]
-      end
-
-      it 'not accept a first param that cannot be coerced to Integer' do
-        expect { die_result.add_roll([]) }.to raise_error(TypeError)
-        expect { die_result.add_roll('N') }.to raise_error(ArgumentError)
-      end
-
-      it 'not accept an unsupported second param' do
-        expect { die_result.add_roll(5, []) }.to raise_error(ArgumentError)
-        expect { die_result.add_roll(15, :bam) }.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'when starting with an initial result' do
-      let(:die_result) { described_class.new(7) }
-
-      it 'not accept a first param that cannot be coerced to Integer' do
-        expect { die_result.add_roll([]) }.to raise_error(TypeError)
-        expect { die_result.add_roll('N') }.to raise_error(ArgumentError)
-      end
-
-      it 'not accept an unsupported second param' do
-        expect { die_result.add_roll(5, []) }.to raise_error(ArgumentError)
-        expect { die_result.add_roll(15, :bam) }.to raise_error(ArgumentError)
-      end
-
-      context 'when adding another basic roll' do
-        it 'replace an initial result, as if the die were re-rolled' do
-          die_result.add_roll(5)
-          expect(die_result.value).to be 5
-          expect(die_result.rolls).to eql [7, 5]
-          expect(die_result.roll_reasons).to eql %i[basic basic]
-        end
-      end
-
-      context 'with exploding dice' do
-        it 'add to value when exploding up' do
-          die_result.add_roll(6, :reroll_add)
-          expect(die_result.value).to be 13
-          expect(die_result.rolls).to eql [7, 6]
-          expect(die_result.roll_reasons).to eql %i[basic reroll_add]
-        end
-
-        it 'subtract from value when exploding down' do
-          die_result.add_roll(4, :reroll_subtract)
-          expect(die_result.value).to be 3
-          expect(die_result.rolls).to eql [7, 4]
-          expect(die_result.roll_reasons).to eql %i[basic reroll_subtract]
-        end
-      end
-
-      context 'with re-roll dice' do
-        it 'optionally replace roll unconditionally' do
-          die_result.add_roll(2, :reroll_replace)
-          expect(die_result.value).to be 2
-          expect(die_result.rolls).to eql [7, 2]
-          expect(die_result.roll_reasons).to eql %i[basic reroll_replace]
-
-          die_result.add_roll(5, :reroll_replace)
-          expect(die_result.value).to be 5
-          expect(die_result.rolls).to eql [7, 2, 5]
-          expect(die_result.roll_reasons).to eql %i[basic reroll_replace reroll_replace]
-        end
-
-        it 'optionally use best roll' do
-          die_result.add_roll(2, :reroll_use_best)
-          expect(die_result.value).to be 7
-          expect(die_result.rolls).to eql [7, 2]
-          expect(die_result.roll_reasons).to eql %i[basic reroll_use_best]
-
-          die_result.add_roll(9, :reroll_use_best)
-          expect(die_result.value).to be 9
-          expect(die_result.rolls).to eql [7, 2, 9]
-          expect(die_result.roll_reasons).to eql %i[basic reroll_use_best reroll_use_best]
-        end
-
-        it 'optionally use worst roll' do
-          die_result.add_roll(4, :reroll_use_worst)
-          expect(die_result.value).to be 4
-          expect(die_result.rolls).to eql [7, 4]
-          expect(die_result.roll_reasons).to eql %i[basic reroll_use_worst]
-
-          die_result.add_roll(5, :reroll_use_worst)
-          expect(die_result.value).to be 4
-          expect(die_result.rolls).to eql [7, 4, 5]
-          expect(die_result.roll_reasons).to eql %i[basic reroll_use_worst reroll_use_worst]
-        end
-      end
-
-      context 'with combinations of reroll reasons' do
-        it 'correctly handle valid reasons for extra rolls in combination' do
-          die_result.add_roll(10, :reroll_add)
-          die_result.add_roll(3, :reroll_subtract)
-          expect(die_result.value).to be 14
-          expect(die_result.rolls).to eql [7, 10, 3]
-          expect(die_result.roll_reasons).to eql %i[basic reroll_add reroll_subtract]
-
-          die_result.add_roll(12, :reroll_replace)
-          expect(die_result.value).to be 12
-          expect(die_result.rolls).to eql [7, 10, 3, 12]
-          expect(die_result.roll_reasons).to eql %i[basic reroll_add reroll_subtract reroll_replace]
-
-          die_result.add_roll(9, :reroll_use_best)
-          expect(die_result.value).to be 12
-          expect(die_result.rolls).to eql [7, 10, 3, 12, 9]
-          expect(die_result.roll_reasons).to eql %i[basic reroll_add reroll_subtract reroll_replace
-                                                    reroll_use_best]
-
-          die_result.add_roll(15, :reroll_add)
-          expect(die_result.value).to be 27
-          expect(die_result.rolls).to eql [7, 10, 3, 12, 9, 15]
-          expect(die_result.roll_reasons).to eql %i[basic reroll_add reroll_subtract reroll_replace
-                                                    reroll_use_best reroll_add]
-        end
-      end
-    end
-  end
-
-  describe '#explain_value' do
-    let(:die_result) { described_class.new }
-
-    it "be empty string for 'no results yet'" do
-      expect(die_result.explain_value).to eql ''
-    end
-
-    it 'be a simple stringified number when there is one die roll' do
-      die_result.add_roll(3)
-      expect(die_result.explain_value).to eql '3'
-    end
-
-    it 'describe all single rolls made and how they combine' do
-      die_result.add_roll(6)
-      expect(die_result.explain_value).to eql '6'
-
-      die_result.add_roll(5, :reroll_add)
-      expect(die_result.explain_value).to eql '[6+5] 11'
-
-      die_result.add_roll(2, :reroll_replace)
-      expect(die_result.explain_value).to eql '[6+5|2] 2'
-
-      die_result.add_roll(7, :reroll_subtract)
-      expect(die_result.explain_value).to eql '[6+5|2-7] -5'
-
-      die_result.add_roll(4, :reroll_use_worst)
-      expect(die_result.explain_value).to eql '[6+5|2-7\\4] -5'
-
-      die_result.add_roll(3, :reroll_use_best)
-      expect(die_result.explain_value).to eql '[6+5|2-7\\4/3] 3'
-    end
-  end
-
-  it 'combine via +,- and * intuitively based on #value' do
-    die_result = described_class.new(7)
-    expect(die_result + 3).to be 10
-    expect(4 + die_result).to be 11
-    expect(die_result - 2).to be 5
-    expect(9 - die_result).to be 2
-
-    expect(die_result + 7.7).to be 14.7
-    expect(4.1 + die_result).to be 11.1
-
-    expect(die_result * 2).to be 14
-    expect(1 * die_result).to be 7
-
-    other_die_result = described_class.new(6)
-    other_die_result.add_roll(6, :reroll_add)
-    expect(die_result + other_die_result).to be 19
-    expect(other_die_result - die_result).to be 5
-  end
-
-  it 'support comparison with >,<,>=,<= as if it were an integer, based on #value' do
-    die_result = described_class.new(7)
-
-    expect(die_result > 3).to be true
-    expect(die_result < 14).to be true
-    expect(die_result >= 7).to be true
-    expect(die_result <= 9.5).to be true
-    expect(die_result < 3).to be false
-    expect(die_result > 14).to be false
-    expect(die_result <= 8).to be true
-    expect(die_result >= 14).to be false
-
-    other_die_result = described_class.new(6)
-    other_die_result.add_roll(6, :reroll_add)
-    expect(die_result > other_die_result).to be false
-    expect(other_die_result > die_result).to be true
-    expect(die_result >= other_die_result).to be false
-    expect(other_die_result >= die_result).to be true
-    expect(die_result < other_die_result).to be true
-    expect(other_die_result < die_result).to be false
-    expect(die_result <= other_die_result).to be true
-    expect(other_die_result <= die_result).to be false
-  end
-
-  it 'sort, based on #value' do
-    die_results = [
-      described_class.new(7), described_class.new(5), described_class.new(8), described_class.new(3)
-    ]
-
-    die_results.sort!
-
-    expect(die_results[0].value).to be 3
-    expect(die_results[1].value).to be 5
-    expect(die_results[2].value).to be 7
-    expect(die_results[3].value).to be 8
-  end
-end

data/spec/fixtures/probs_fair_die_6.dat

@@ -1,2 +0,0 @@
-u:GamesDice::Probabilities
�{if0.16666666666666666if0.16666666666666666if0.16666666666666666i	f0.16666666666666666i
-f0.16666666666666666if0.16666666666666666