gambit 0.1.0

data/test/tc_board.rb

@@ -0,0 +1,167 @@
+#!/usr/local/bin/ruby -w
+
+#  tc_board.rb
+#
+#  Created by Gregory Brown on 2005-05-29.
+#  Copyright 2005 smtose.org.  All rights reserved.
+
+require "test/unit"
+require "gambit/tools/board"
+
+class TestBoard < Test::Unit::TestCase
+	def test_bounds
+		board = Gambit::Tools::Board.new(10,15)
+		assert_equal(10,board.cols)
+		assert_equal(15,board.rows)
+	end
+
+	def test_parse_location
+		board = Gambit::Tools::Board.new(5,10)
+		assert_equal([1,3],board.parse_location("b4"))
+		assert_equal([1,3],board.parse_location(1,3))
+	end
+
+	def test_to_chess
+		board = Gambit::Tools::Board.new(3,3)
+		assert_equal("b4",board.to_chess(1,3))
+	end
+
+	def test_get
+		board = Gambit::Tools::Board.new(5,10)
+		board["a4"] = "Object1"
+		board[2,4] = "Object2"
+		assert_equal("Object1",board["a4"])
+		assert_equal("Object2",board[2,4])
+	end
+
+	def test_fill
+		board = Gambit::Tools::Board.new(2,2,[])
+		board["a1"] << "something"
+		assert(board["b2"].empty?)
+		assert(board["b1"].empty?)
+		assert(board["a2"].empty?)
+	end
+
+	def test_valid
+		board = Gambit::Tools::Board.new(5,10)
+		assert(!board.valid?(-1,3))
+		assert(!board.valid?(3,-1))
+		assert(!board.valid?(-1,-1))
+		assert(!board.valid?(5,2))
+		assert(!board.valid?(2,10))
+		assert(!board.valid?("f6"))
+		assert(!board.valid?("b11"))
+	end
+
+	def test_neighboring_locations
+		board = Gambit::Tools::Board.new(3,3)
+		actual_neighbors = ["b1","a2", "b2"].sort
+		assert_equal(actual_neighbors,
+		             board.neighboring_locations("a1"))
+
+		board.include_diagonals = false
+		assert_equal(actual_neighbors - ["b2"],
+			     board.neighboring_locations("a1"))
+	end
+
+	def test_neighbors
+		board = Gambit::Tools::Board.new(3,3)
+		board["b1"] = "Sample1"
+		board["b2"] = "Sample2"
+		board["a2"] = "Sample3"
+		assert_equal(["Sample1","Sample2","Sample3"].sort,
+		             board.neighbors("a1").sort)
+		board.include_diagonals = false
+		assert_equal(["Sample1","Sample3"].sort,
+			     board.neighbors("a1").sort)
+	end
+
+	def test_move
+		board = Gambit::Tools::Board.new(7,3)
+		board["b1"] = "Cat"
+		board.move("b1","c3")
+		assert_equal("Cat",board["c3"])
+		assert_equal(nil,board["b1"])
+	end
+
+	def test_each_location
+		board = Gambit::Tools::Board.new(3,3)
+		expected = %w[a1 b1 c1 a2 b2 c2 a3 b3 c3]
+		board.each_location do |loc|
+			assert_equal(expected.shift, loc)
+		end
+		expected = %w[a3 b3 c3 a2 b2 c2 a1 b1 c1]
+		board.each_location(true) do |loc|
+			assert_equal(expected.shift, loc)
+		end
+	end
+
+	def test_each
+		board = Gambit::Tools::Board.new(2,2)
+		board["a1"] = "Cat"
+		board["b1"] = "Bat"
+		board["a2"] = "Fat"
+		board["b2"] = "Mat"
+		expected = %w[Cat Bat Fat Mat]
+		board.each do |item|
+			assert_equal(expected.shift, item)
+		end
+		expected = %w[Fat Mat Cat Bat]
+		board.each(true) do |item|
+			assert_equal(expected.shift, item)
+		end
+	end
+
+	def test_each_with_location
+		board = Gambit::Tools::Board.new(2,2)
+		board["a1"] = "Cat"
+		board["b1"] = "Bat"
+		board["a2"] = "Fat"
+		board["b2"] = "Mat"
+		expected_items = %w[Cat Bat Fat Mat]
+		expected_loc = %w[a1 b1 a2 b2]
+		board.each_with_location do |item,loc|
+			assert_equal(expected_items.shift,item)
+			assert_equal(expected_loc.shift,loc)
+		end
+		
+		expected_items = %w[Fat Mat Cat Bat]
+		expected_loc   = %w[a2 b2 a1 b1]
+		board.each_with_location(true) do |item,loc|
+			assert_equal(expected_items.shift,item)
+			assert_equal(expected_loc.shift,loc)
+		end
+	end
+
+	def test_each_row
+		board = Gambit::Tools::Board.new(2,2)
+		board["a1"] = "Tree"
+		board["b1"] = "Fee"	
+		board["a2"] = "Bee"
+		board["b2"] = "Lee"
+		expected = [ %w[Bee Lee],%w[Tree Fee] ]
+		board.each_row do |row|
+			assert_equal(expected.shift, row)
+		end
+		expected = [ %w[Tree Fee],%w[Bee Lee] ]
+		board.each_row(false) do |row|
+			assert_equal(expected.shift, row)
+		end
+	end
+
+	def test_each_col
+		board = Gambit::Tools::Board.new(2,2)
+		board["a1"] = "James"
+		board["b1"] = "A"
+		board["a2"] = "Is"
+		board["b2"] = "Bastard"
+		expected = [ %w[James Is], %w[A Bastard] ]
+		board.each_col do |col|
+			assert_equal(expected.shift, col)
+		end
+		expected = [ %w[A Bastard], %w[James Is] ]
+		board.each_col(true) do |col|
+			assert_equal(expected.shift, col)
+		end
+	end
+end

data/test/tc_cards.rb

@@ -0,0 +1,182 @@
+#!/usr/local/bin/ruby -w
+
+# tc_cards.rb
+#
+#  Created by James Edward Gray II on 2005-05-30.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "test/unit"
+
+require "gambit/tools/cards"
+
+class TestCards < Test::Unit::TestCase
+	class MyCard < Gambit::Tools::Cards::Card
+		def initialize( value )
+			@value = value
+		end
+		
+		attr_reader :value
+		
+		def <=>( other )
+			@value <=> other.value
+		end
+	end
+	
+	def test_card
+		assert_not_nil(card1 = Gambit::Tools::Cards::Card.new)
+		assert_not_nil(card2 = Gambit::Tools::Cards::Card.new)
+		assert_raise(NotImplementedError) { card1 <=> card2 }
+		assert_raise(NotImplementedError) { card1 < card2 }
+		
+		assert_not_nil(card1 = MyCard.new(1))
+		assert_not_nil(card2 = MyCard.new(10))
+		assert_equal(-1, card1 <=> card2)
+		assert_equal(true, card1 < card2)
+
+		assert_equal( Gambit::Tools::Cards::StandardCard.new(:joker, :red),
+		              Gambit::Tools::Cards::StandardCard.new(:joker, :red) )
+	end
+	
+	def test_standard_card
+		deck = Array.new
+		Gambit::Tools::Cards::StandardCard.use_jokers = false
+		Gambit::Tools::Cards::StandardCard.value_order =
+			[:ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, :jack, :queen, :king]
+		Gambit::Tools::Cards::StandardCard.each { |card| deck << card }
+		names = Array.new
+		%w{Clubs Diamonds Hearts Spades}.each do |suit|
+			%w{Ace 2 3 4 5 6 7 8 9 10 Jack Queen King}.each do |value|
+				names << "The #{value} of #{suit}"
+			end
+		end
+		deck.each { |card| assert_equal(names.shift, card.name) }
+
+		%w{Clubs Diamonds Hearts Spades}.each do |suit|
+			%w{Ace 2 3 4 5 6 7 8 9 10 Jack Queen King}.each do |value|
+				names << "The #{value} of #{suit}"
+			end
+		end
+		deck = deck.sort_by { rand }
+		deck.sort!
+		deck.each { |card| assert_equal(names.shift, card.name) }
+	end
+
+	def test_jokers
+		deck = Array.new
+		Gambit::Tools::Cards::StandardCard.use_jokers = true
+		Gambit::Tools::Cards::StandardCard.each { |card| deck << card }
+		names = Array.new
+		%w{Clubs Diamonds Hearts Spades}.each do |suit|
+			%w{Ace 2 3 4 5 6 7 8 9 10 Jack Queen King}.each do |value|
+				names << "The #{value} of #{suit}"
+			end
+		end
+		names << "The Red Joker" << "The Black Joker"
+		deck.each { |card| assert_equal(names.shift, card.name) }
+
+		Gambit::Tools::Cards::StandardCard.jokers_are_high = false
+		Gambit::Tools::Cards::StandardCard.value_order =
+			[2, 3, 4, 5, 6, 7, 8, 9, 10, :jack, :queen, :king, :ace]
+		names << "The Red Joker" << "The Black Joker"
+		%w{Clubs Diamonds Hearts Spades}.each do |suit|
+			%w{2 3 4 5 6 7 8 9 10 Jack Queen King Ace}.each do |value|
+				names << "The #{value} of #{suit}"
+			end
+		end
+		deck = deck.sort_by { rand }
+		deck.sort!
+		deck.each { |card| assert_equal(names.shift, card.name) }
+	end
+	
+	def test_deck
+		Gambit::Tools::Cards::StandardCard.use_jokers = false
+		Gambit::Tools::Cards::StandardCard.value_order =
+			[:ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, :jack, :queen, :king]
+		deck = Gambit::Tools::Cards::Deck.new
+		assert_equal(52, deck.count)
+		names = Array.new
+		%w{Clubs Diamonds Hearts Spades}.each do |suit|
+			%w{Ace 2 3 4 5 6 7 8 9 10 Jack Queen King}.each do |value|
+				names << "The #{value} of #{suit}"
+			end
+		end
+		deck.each { |card| assert_equal(names.shift, card.name) }
+		
+		ordered  = deck.map { |card| card.name }
+		shuffled = deck.shuffle!.map { |card| card.name }
+		assert_not_equal( ordered, shuffled,
+		                  "Testing Shuffle:  " + 
+		                  "Could fail under insane statistical odds!" )
+		
+		sorted = deck.sort!.map { |card| card.name }
+		ordered.each { |name| assert_equal(sorted.shift, name) }
+		
+		cut = deck.cut!(10).map { |card| card.name }
+		assert_equal(52, deck.count)
+		assert_not_equal(ordered, cut)
+		10.times { ordered << ordered.shift }
+		deck.each { |card| assert_equal(ordered.shift, card.name) }
+		
+		card = deck.draw
+		assert_equal("The Jack of Clubs", card.name)
+		assert_equal(51, deck.count)
+		deck.replace(card)
+		assert_equal(52, deck.count)
+		card = deck.draw
+		assert_equal("The Queen of Clubs", card.name)
+		assert_equal(51, deck.count)
+		deck << card
+		assert_equal(52, deck.count)
+		
+		deck.sort!
+		hand1 = Array.new
+		hand2 = Array.new
+		hand3 = Array.new
+		deck.deal(hand1, hand2, 2)
+		assert_equal( ["The Ace of Clubs", "The 3 of Clubs"],
+		              hand1.map { |card| card.name } )
+        assert_equal( ["The 2 of Clubs", "The 4 of Clubs"],
+                      hand2.map { |card| card.name } )
+        assert_equal(48, deck.count)
+		deck.deal(hand3)
+		assert_equal(0, deck.count)
+		deck.deal(hand3)
+		assert_equal(48, hand3.size)
+	end
+	
+	def test_hand
+		assert_not_nil(hand = Gambit::Tools::Cards::Hand.new)
+		assert_same( hand,
+			hand << Gambit::Tools::Cards::StandardCard.new(:ace, :spades) )
+		assert_same( hand,
+			hand << Gambit::Tools::Cards::StandardCard.new(:joker, :red) )
+		assert_same( hand,
+			hand << Gambit::Tools::Cards::StandardCard.new(3, :clubs) )
+		assert_equal("The Ace of Spades", hand[0].name)
+		assert_same(hand, hand.sort!)
+		assert_equal("The 3 of Clubs", hand[0].name)
+		
+		assert_equal("The Red Joker", hand.discard(-1).name)
+		assert_equal(2, hand.count)
+		
+		names = ["The 3 of Clubs", "The Ace of Spades"]
+		hand.each { |card| assert_equal(names.shift, card.name) }
+	end
+	
+	def test_pile
+		assert_not_nil(pile = Gambit::Tools::Cards::Pile.new)
+		assert_same( pile,
+			pile << Gambit::Tools::Cards::StandardCard.new(:ace, :spades) )
+		assert_same( pile,
+			pile << Gambit::Tools::Cards::StandardCard.new(:joker, :red) )
+		assert_same( pile,
+			pile << Gambit::Tools::Cards::StandardCard.new(3, :clubs) )
+		
+		assert_equal("The 3 of Clubs", pile[0].name)
+		assert_equal("The Ace of Spades", pile[-1].name)
+		assert_equal("The 3 of Clubs", pile.remove.name)
+		
+		assert_equal( "The Red Joker",
+		              pile.find { |card| card.value == :joker }.name )
+	end
+end

data/test/tc_currency.rb

@@ -0,0 +1,99 @@
+#!/usr/local/bin/ruby -w
+
+#tc_currency.rb
+#
+#  Created by Gregory Brown on 2005-05-30
+#  Copyright 2005 smtose.org.  All rights reserved
+
+require "test/unit"
+require "gambit/tools/currency"
+
+class TestCurrency < Test::Unit::TestCase
+	include Gambit::Tools
+
+	def test_amount_of
+		holdings = Hash.new()
+		holdings[:gold] = 50
+		holdings[:silver] = 50
+		holdings[:copper] = 25
+
+		currency_hold = Currency.new(holdings)
+
+		assert_equal(50, currency_hold[:gold])
+		assert_equal(50, currency_hold[:silver])
+		assert_equal(25, currency_hold[:copper])
+	end
+
+	def test_withdraw
+		holdings = Hash.new(0)
+		holdings[:gold] = 50
+		holdings[:silver] = 75
+		holdings[:copper] = 25
+		
+		currency_hold = Currency.new(holdings)
+		
+		Currency[:gold]   = 1.00
+		Currency[:silver] = 0.50
+		Currency[:copper] = 0.25
+
+		assert_equal(25, currency_hold.withdraw(25,:gold))
+		assert_equal(25, currency_hold[:gold])
+		assert_equal(50, currency_hold.withdraw(25,:gold,:silver))
+		assert_equal(0, currency_hold[:gold])
+		assert_equal(100, currency_hold.withdraw(50,:silver,:copper))
+	end
+
+	def test_deposit
+		currency_hold = Currency.new()
+
+		Currency[:dollars] = 1
+
+		assert_equal(100,currency_hold.deposit(100,:dollars))
+		assert_equal(100,currency_hold[:dollars])
+	end
+
+	def test_relative_value
+		Currency[:dollars] = 1
+		Currency[:nickels] = 0.05
+		assert_equal(20,Currency.relative_value(:dollars,:nickels))
+	end
+
+	def test_add
+		Currency[:gold] = 1
+		Currency[:silver] = 0.5
+		Currency[:copper] = 2
+		
+		currency_hold = Currency.new({:gold => 100, :silver => 50})
+		currency_hold2 = Currency.new({:gold => 25, :copper => 30})
+		currency_hold += currency_hold2
+		assert_equal( [125, 50, 30],  [ currency_hold[:gold], 
+			                            currency_hold[:silver],
+			                            currency_hold[:copper] ] )
+	end
+
+	def test_subtract
+		Currency[:gold] = 1
+		Currency[:silver] = 0.5
+		Currency[:copper] = 2
+		
+		currency_hold = Currency.new({:gold => 100, :silver => 50})
+		currency_hold2 = Currency.new({:gold => 50, :silver => 10})
+		currency_hold -= currency_hold2
+		assert_equal( [50,40], [ currency_hold[:gold], 
+			                     currency_hold[:silver] ] )
+	end
+
+	def test_each
+		Currency[:gold] = 1
+		Currency[:silver] = 2
+		Currency[:copper] = 5
+
+		data = { :gold => 500, :silver => 200, :copper => 50 }
+		
+		currency_hold = Currency.new(data)
+
+		currency_hold.each do |resource, amount|
+			assert_equal(data[resource],amount)
+		end
+	end
+end

data/test/tc_dice.rb

@@ -0,0 +1,83 @@
+#!/usr/local/bin/ruby -w
+
+#  tc_dice.rb
+#
+#  Created by James Edward Gray II on 2005-02-12.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "test/unit"
+require "gambit/tools/dice"
+
+class TestDice < Test::Unit::TestCase
+	def test_rolls
+		assert_not_nil(roll = Gambit::Tools::Dice.new(6))
+		assert((1..6).to_a.include?(roll.sum))
+
+		assert_not_nil(roll = Gambit::Tools::Dice.new(3, 6))
+		assert(roll.sum >= 3)
+		assert(roll.sum <= 18)
+		roll.each do |die|
+			assert(die >= 1)
+			assert(die <= 6)
+		end
+
+		assert_not_nil(roll = Gambit::Tools::Dice.new(2, 100))
+		assert((2..200).to_a.include?(roll.sum))
+		assert_not_nil(roll = Gambit::Tools::Dice.new(5, 4))
+		assert((5..20).to_a.include?(roll.sum))
+	end
+	
+	def test_reroll
+		assert_not_nil(yahtzee = Gambit::Tools::Dice.new(5, 6))
+
+		save = yahtzee[0]
+		others = [ ]
+		yahtzee.each_with_index { |die, i| others << i if die != save }
+		count = yahtzee.sum(save)
+		
+		assert_equal(save * (5 - others.size), count)
+		assert_equal((5 - others.size), yahtzee.count(save))
+		assert_same(yahtzee, yahtzee.reroll(*others))
+		assert(yahtzee.sum(save) >= count)
+		
+		count = yahtzee.sum(save)
+		
+		assert_same(yahtzee, yahtzee.reroll { |die| die != save })
+		assert(yahtzee.sum(save) >= count)
+	end
+	
+	def test_success
+		assert_not_nil(roll = Gambit::Tools::Dice.new(7, 10))
+
+		assert_equal( roll.sum(7) / 7 + roll.sum(8) / 8 +
+		              roll.sum(9) / 9 + roll.sum(10) / 10, roll.success(7) )
+		assert_equal(roll.sum(1), roll.fail(1))
+	end
+	
+	def test_matches
+		assert_not_nil(roll = Gambit::Tools::Dice.new)
+
+		roll.instance_eval { @roll = [2, 2, 5, 5, 5] }
+		assert(roll.matches?(*%w{x x x y y}))
+
+		roll.instance_eval { @roll = [2, 5, 3, 2, 4] }
+		assert(roll.matches?(1, 2, 3, 4))
+	end
+	
+	def test_top_level
+		assert_not_nil(roll = 3.d(6))
+		assert_instance_of(Gambit::Tools::Dice, roll)
+		assert(roll.sum >= 3)
+		assert(roll.sum <= 18)
+		
+		assert_not_nil(total = 3.d(6) + 5)
+		assert_instance_of(Fixnum, total)
+		assert(total >= 8)
+		assert(total <= 23)
+
+		assert_not_nil(total = 5 + 3.d(6))
+		assert_instance_of(Fixnum, total)
+		assert(total >= 8)
+		assert(total <= 23)
+	end
+end