gambit 0.1.0

data/lib/gambit/tools/cards/deck.rb

@@ -0,0 +1,99 @@
+#!/usr/local/bin/ruby -w
+
+# deck.rb
+#
+#  Created by James Edward Gray II on 2005-05-30.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "gambit/viewable"
+
+module Gambit
+	module Tools
+		module Cards
+			# A Deck manager for any class inheriting from Card.
+			class Deck
+				include Gambit::Viewable
+				register_view(:gambit_html, <<-END_HTML_VIEW.gsub(/\t{4}/, ""))
+				<ol class="deck">
+				% each do |card|
+					<li><%= card.view(:gambit_text) %></li>
+				% end
+				</ol>
+				END_HTML_VIEW
+				register_view(:gambit_text, <<-END_TEXT_VIEW.gsub(/\t+/, ""))
+				% each do |card|
+					<%= card.view(:gambit_text) + "\\n" %>
+				% end
+				END_TEXT_VIEW
+				
+				# 
+				# Create a new Deck filled with _card_type_ (StandardCard by 
+				# default).
+				# 
+				def initialize( card_type = StandardCard )
+					@deck = Array.new
+					card_type.each { |card| @deck << card }
+				end
+				
+				# Returns the Deck size.
+				def count(  )
+					@deck.size
+				end
+				
+				# Cuts the deck at the provided _count_ or a random default.
+				def cut!( count = rand(@deck.size / 2) + @deck.size / 4 )
+					@deck = @deck.values_at(count..-1, 0...count)
+				end
+				
+				# 
+				# Deals cards to _hands_ in round robin fashion.  If a Fixnum is
+				# included in the argument list, that many cards will be dealt
+				# to each hand.  Otherwise, the entire deck is dealt.
+				# 
+				# You may use Hand objects in _hands_ or anything that supports
+				# the << operator.
+				# 
+				def deal( *hands )
+					if count = hands.find { |hand| hand.is_a? Fixnum }
+						hands.delete(count)
+					else
+						count = @deck.size
+					end
+					count.times do 
+						hands.each do |hand|
+							hand << @deck.shift
+						end
+					end
+				end
+				
+				# Removes and returns a card from the top of the deck.
+				def draw(  )
+					@deck.shift
+				end
+				
+				include Enumerable
+
+				# Iterate through the cards.
+				def each( &block )
+					@deck.each(&block)
+				end
+				
+				# Randomize the deck.
+				def shuffle!(  )
+					@deck = @deck.sort_by { rand }
+				end
+				
+				# Sort the deck by card value.
+				def sort!( &block )
+					@deck.sort!(&block)
+				end
+				
+				# Replace _card_ on the bottom of the deck.
+				def replace( card )
+					@deck << card
+				end
+				alias_method :<<, :replace
+			end
+		end
+	end
+end

data/lib/gambit/tools/cards/hand.rb

@@ -0,0 +1,86 @@
+#!/usr/local/bin/ruby -w
+
+# hand.rb
+#
+#  Created by James Edward Gray II on 2005-05-30.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "gambit/viewable"
+
+module Gambit
+	module Tools
+		module Cards
+			# An object for managing a Hand of cards.
+			class Hand
+				include Gambit::Viewable
+				register_view(:gambit_html, <<-END_HTML_VIEW.gsub(/^\t{4}/, ""))
+				<ol class="hand">
+				% each do |card|
+					<li><%= card.view(:gambit_text) %></li>
+				% end
+				</ol>
+				END_HTML_VIEW
+				register_view(:gambit_text, <<-END_TEXT_VIEW.gsub(/^\t+/, ""))
+				% if @hand.size.zero?
+					an empty pile
+				% elsif @hand.size == 1
+					<%= @hand.first.view(:gambit_text) %>
+				% else
+				%	first_cards = @hand[0..-2].map { |c| c.view(:gambit_text) }
+				%   last_card   = @hand[-1].view(:gambit_text)
+					<%= first_cards.join(', ') + " and " + last_card %>
+				% end
+				END_TEXT_VIEW
+
+				# Create an empty Hand of cards.
+				def initialize(  )
+					@hand   = Array.new
+				end
+
+				# Fetch a card by _index_.
+				def []( index )
+					@hand[index]
+				end
+				
+				# 
+				# Add a card to this Hand.
+				# 
+				# Returns +self+ for method chaining.
+				# 
+				def <<( card )
+					@hand << card
+					
+					self
+				end
+
+				# Returns the Hand size.
+				def count(  )
+					@hand.size
+				end
+				
+				include Enumerable
+				
+				# Iterate through the cards.
+				def each( &block )
+					@hand.each(&block)
+				end
+				
+				# Removes and returns the card at the given _index_.
+				def discard( index )
+					@hand.delete_at(index)
+				end
+
+				# 
+				# Sort the Hand by card value.
+				# 
+				# Returns +self+ for method chaining.
+				# 
+				def sort!( &block )
+					@hand.sort!(&block)
+					
+					self
+				end
+			end
+		end
+	end
+end

data/lib/gambit/tools/cards/pile.rb

@@ -0,0 +1,107 @@
+#!/usr/local/bin/ruby -w
+
+# Pile.rb
+#
+#  Created by James Edward Gray II on 2005-05-31.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "gambit/viewable"
+
+module Gambit
+	module Tools
+		module Cards
+			# A tool for managing Piles of cards.
+			class Pile
+				include Gambit::Viewable
+				register_view(:gambit_html, <<-END_HTML_VIEW.gsub(/^\t+/, ""))
+				<ol class="pile">
+				% @pile.each_with_index do |card, index|
+				%	if @face_up[index]
+						<%= "\\t" %><li><%= card.view(:gambit_text) %></li>
+				%	else
+						<%= "\\t" %><li>A Face-down Card</li>
+				%	end
+				% end
+				</ol>
+				END_HTML_VIEW
+				register_view(:gambit_text, <<-END_TEXT_VIEW.gsub(/^\t+/, ""))
+				% cards = to_a
+				% if cards.size.zero?
+					an empty pile
+				% elsif cards.size == 1
+					<%= cards.first.view(:gambit_text) %>
+				% else
+				%	first_cards = cards[0..-2].map { |c| c.view(:gambit_text) }
+				%   last_card   = cards[-1].view(:gambit_text)
+					<%= first_cards.join(', ') + " and " + last_card %>
+				% end
+				END_TEXT_VIEW
+
+				# Creates an empty Pile of cards.
+				def initialize(  )
+					@pile            = Array.new
+
+					@add_to_top      = true
+					@remove_from_top = true
+					
+					@face_up         = lambda { |index| true }
+				end
+				
+				# 
+				# When +true+ (default), add() will place cards on the top of
+				# the pile.  Otherwise, they go to the bottom.
+				# 
+				attr_accessor :add_to_top
+				# 
+				# When +true+ (default), remove() will pull cards from the top
+				# of the pile.  Otherwise, they come from the bottom.
+				# 
+				attr_accessor :remove_from_top
+				# 
+				# This method contains a Proc object that is passed card indices
+				# when rendering the default views.  The Proc is excepted to 
+				# return +true+ or +false+ indicating if the card at that index
+				# is face up or face down.
+				# 
+				attr_accessor :face_up
+
+				# Fetch a card by _index_.
+				def []( index )
+					@pile[index]
+				end
+
+				# Add _card_ to this Pile.
+				def add( card )
+					if @add_to_top
+						@pile.unshift(card)
+					else
+						@pile << card
+					end
+					
+					self
+				end
+				alias_method :<<, :add
+				
+				include Enumerable
+				
+				# Iterate through the cards.
+				def each(  )
+					@pile.each_index do |index|
+						next unless @face_up[index]
+						
+						yield @pile[index]
+					end
+				end
+
+				# Remove and return a card from this Pile.
+				def remove(  )
+					if @remove_from_top
+						@pile.shift
+					else
+						@pile.pop
+					end
+				end
+			end
+		end
+	end
+end

data/lib/gambit/tools/currency.rb

@@ -0,0 +1,148 @@
+#!/usr/local/bin/ruby -w
+
+# currency.rb
+#
+#  Created by Gregory Brown on 2005-05-30
+#  Copyright 2005 smtose.org.  All rights reserved
+
+require "gambit/viewable"
+
+module Gambit
+	module Tools
+		# 
+		# A general money tool for managing various denominations and the 
+		# conversions between them.
+		# 
+		class Currency
+			include Gambit::Viewable
+			register_view(:gambit_html, <<-END_HTML_VIEW.gsub(/^\t{3}/, ""))
+			<dl class="currency">
+			% resources = @holdings.keys
+			% resources = resources.sort_by { |res| res.to_s }
+			% resources.each do |resource|
+				<dt><%= resource.to_s.capitalize %></dt>
+				<dd><%= @holdings[resource] %></dd>
+			%	if resource != resources.last
+				
+			%	end
+			% end
+			</dl>
+			END_HTML_VIEW
+			register_view(:gambit_text, <<-END_TEXT_VIEW.gsub(/^\t+/, ""))
+			% resources = @holdings.keys
+			% resources = resources.sort_by { |res| res.to_s }
+			% res_width = resources.max { |a, b| a.to_s.length <=>
+			%                                    b.to_s.length }.to_s.length
+			% amt_width = @holdings.values.max { |a, b| a.to_s.length <=>
+			%                                           b.to_s.length }.
+			%                              to_s.length
+			% resources.each do |resource|
+				<%= "%\#{res_width}s" % resource.to_s.capitalize %>:  <%=
+				    "%\#{amt_width}d" % @holdings[resource] %>
+			% end
+			END_TEXT_VIEW
+
+			@@values = Hash.new(0)	
+
+			# 
+			# Used to set a standard _ratio_ for a _resource_ Currency objects
+			# can use.
+			# 
+			def self.[]=( resource, ratio )
+				@@values[resource] = ratio.to_f	
+			end
+
+			# 
+			# Fetch a standard ratio for a _resource_ Currency objects can use.
+			# 
+			def self.[]( resource )
+				return @@values[resource]
+			end
+
+			# Calculates a relative_value _from_resource_ _to_resource_.
+			def self.relative_value( from_resource, to_resource )
+				if @@values.key?(from_resource) && @@values.key?(to_resource)
+					@@values[from_resource] / @@values[to_resource]
+				else
+					raise ArgumentError, "Can't find conversion ratio!"
+				end
+			end
+
+			# 
+			# Creates a new Currency object.  Optionally, you may provide a Hash
+			# of _initial_holdings_.
+			# 
+			def initialize( initial_holdings = nil )
+				if initial_holdings.is_a? Hash
+					@holdings = initial_holdings
+				else
+					@holdings = Hash.new(0)
+				end
+			end
+
+			# The holdings Hash.
+			attr_reader :holdings
+
+			# Delegates to the holdings Hash.
+			def []( resource )
+				return @holdings[resource]
+			end
+
+			# 
+			# Remove _amount_ of _resource_ from these holdings, optionally
+			# _as_resource_.
+			# 
+			def withdraw( amount, resource, as_resource = nil )
+				if (@holdings[resource] - amount >= 0 && as_resource.nil?)
+					@holdings[resource] -= amount
+					return amount
+				elsif (@holdings[resource] - amount >= 0)
+					@holdings[resource] -= amount
+					return amount *
+					       self.class.relative_value(resource, as_resource)
+				else
+					raise ArgumentError, "Insufficiant Funds"
+				end	
+			end
+		
+			# Add _amount_ of _resource_ to these holdings.
+			def deposit( amount, resource )
+				if @@values.key?(resource)
+					@holdings[resource] += amount
+					return amount
+				end
+			end
+	
+			# Combine holding between this Currency object and _other_currency_.
+			def +( other_currency )
+				new_holdings = Hash.new(0)
+				@holdings.each do |key,value|
+					new_holdings[key] += value
+				end
+				other_currency.holdings.each do |key,value|
+					new_holdings[key] += value
+				end
+				return Currency.new(new_holdings)
+			end
+
+			# Remove holdings in _other_currency_ from this Currency object.
+			def -( other_currency )
+				new_holdings = Hash.new(0)
+				other_currency.holdings.each do |key,value|
+					new_holdings[key] = @holdings[key] - value
+				end
+				if new_holdings.values.min < 0
+					raise ArgumentError, "Detected negative value"
+				end
+				return Currency.new(new_holdings)
+			end
+			
+			include Enumerable
+
+			# Delegates to the holdings Hash.
+			def each(&block)
+				@holdings.each(&block)
+			end
+		end
+	end
+end

data/lib/gambit/tools/dice.rb

@@ -0,0 +1,219 @@
+#!/usr/local/bin/ruby -w
+
+# dice.rb
+#
+#  Created by James Edward Gray II on 2005-05-29.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "gambit/viewable"
+
+module Gambit
+	module Tools
+		# An object for managing a roll of dice.
+		class Dice
+			include Gambit::Viewable
+			register_view(:gambit_html, <<-END_HTML_VIEW.gsub(/^\t{3}/, ""))
+			<ul class="dice">
+			% each do |die|
+				<li><%= die %></li>
+			% end
+			</ul>
+			END_HTML_VIEW
+			register_view(:gambit_text, <<-END_TEXT_VIEW.gsub(/^\t+/, ""))
+			% if @dice == 1
+				<%= "a \#{@roll.first}" %>
+			% else
+				<%= "\#{@roll[0..-2].join(', ')} and \#{@roll[-1]}" %>
+			% end
+			END_TEXT_VIEW
+			
+			# 
+			# Creates a new Dice object, rolling the indicated _count_ of the
+			# indicated _sided_ dice.  The sides on a die need not be realistic,
+			# so this object can also be used to manage a coin toss (a two-sided
+			# die).
+			#
+			# :call-seq:
+			#   Dice.new(count, sides)    -> count_d_sides_roll
+			#   Dice.new(sides)           -> one_d_sides_roll
+			#   Dice.new()                -> one_d_six_roll
+			# 
+			def initialize( *args )
+				@dice, @sides = if args.size == 2
+					args
+				elsif args.size == 1
+					[1, args.first]
+				else
+					[1, 6]
+				end
+				
+				@roll = Array.new(@dice) { rand(@sides) + 1 }
+			end
+			
+			# Fetch the die at the provided _index_.
+			def []( index )
+				@roll[index]
+			end
+			
+			# 
+			# Returns a count of all dice in the roll matching the provided
+			# _pips_.
+			# 
+			def count( pips )
+				@roll.inject(0) do |total, die|
+					if die == pips then total + 1 else total end
+				end
+			end
+			
+			include Enumerable
+			
+			# Iterate over each die in the roll.
+			def each( &block )
+				@roll.each(&block)
+			end
+			
+			# 
+			# Count the number of "failure" dice in this roll.  A die is
+			# a failure if it is less than or equal to the provided _maximum_.
+			# 
+			def fail( maximum )
+				@roll.inject(0) do |total, die|
+					if die <= maximum then total + 1 else total end
+				end
+			end
+
+			# 
+			# A call to matches?() allows _pattern_ matching for dice rolls.  A
+			# _pattern_ may contain single-letter Strings and/or Integers.  
+			# 
+			# Strings are used to locate recurring die patterns.  For example, 
+			# one could check for a full house with 
+			# <tt>dice.matches?(*w{x x x y y})</tt>.
+			# 
+			# Integers can be used to locate sequences of dice.  For example,
+			# one could check for a small straight with
+			# <tt>dice.matches?(*(1..4).to_a)</tt>.
+			# 
+			def matches?( *pattern )
+				digits, letters = pattern.partition { |e| e.is_a?(Integer) }
+				matches_digits?(digits) and matches_letters?(letters)
+			end
+
+			# 
+			# A call to this method will reroll the indicated dice.  Dice can be
+			# selected by block or _indices_.
+			# 
+			# :call-seq:
+			#   reroll(*indices)          -> dice
+			#   reroll() { |die| ... }    -> dice
+			# 
+			def reroll( *indices )
+				if block_given?
+					@roll.each_with_index do |die, i|
+						@roll[i] = rand(6) + 1 if yield(die)
+					end
+				elsif indices.empty?
+					@roll = Array.new(@dice) { rand(@sides) + 1 }
+				else
+					indices.each { |i| @roll[i] = rand(6) + 1 }
+				end
+				
+				self
+			end
+			
+			# 
+			# Count the number of "success" dice in this roll.  A die is
+			# a success if it is greater than or equal to the provided 
+			# _minimum_.
+			# 
+			def success( minimum )
+				@roll.inject(0) do |total, die|
+					if die >= minimum then total + 1 else total end
+				end
+			end
+			
+			# 
+			# Returns a total sum of all dice in the roll matching the provided
+			# _pips_.  If _pips_ is +nil+ (the default), all dice are totaled.
+			# 
+			def sum( pips = nil )
+				if pips
+					@roll.inject(0) do |total, die|
+						if die == pips then total + die else total end
+					end
+				else
+					@roll.inject(0) { |total, die| total + die }
+				end
+			end
+			
+			# Add the sum() of this roll to an Integer.
+			def +( other ) sum + other end
+			# Subtract the sum() of this roll from an Integer.
+			def -( other ) sum - other end
+			# Multiply the sum() of this roll to an Integer.
+			def *( other ) sum * other end
+			# Divide the sum() of this roll by an Integer.
+			def /( other ) sum / other end
+			
+			# 
+			# Support for using Dice objects in ordinary Ruby math.  Rolls are
+			# added to an Integer or Float by sum().
+			# 
+			def coerce( other )
+				if other.is_a? Integer
+					[other, self.sum]
+				else
+					[Float(other), Float(self.sum)]
+				end
+			end
+
+			private
+			
+			# The "number pattern" half of matches?().
+			def matches_digits?( digits )
+				return true if digits.size < 2
+
+				digits.sort!
+				test = @roll.uniq.sort
+				loop do
+					(0..(@roll.length - digits.length)).each do |index|
+						return true if test[index, digits.length] == digits
+					end
+
+					digits.collect! { |d| d + 1 }
+					break if digits.last > 6	
+				end
+
+				false
+			end
+
+			# The "letter pattern" half of matches?().
+			def matches_letters?( letters )
+				return true if letters.size < 2
+
+				counts = Hash.new(0)
+				letters.each { |l| counts[l] += 1 }
+				counts = counts.values.sort.reverse
+
+				pips = @roll.uniq
+				counts.each do |c|
+					return false unless match = pips.find { |p| count(p) >= c }
+					pips.delete(match)
+				end
+
+				true
+			end
+		end
+	end
+end
+
+class Integer
+	# 
+	# A shortcut for rolling dice in a program.  For example:
+	# 
+	#   str = 3.d(6) + 2
+	# 
+	def d( sides )
+		Gambit::Tools::Dice.new(self, sides)
+	end
+end