gambit 0.1.0

data/lib/gambit/server/player.rb

@@ -0,0 +1,40 @@
+#!/usr/local/bin/ruby -w
+
+# player.rb
+#
+#  Created by Gregory Brown on 2005-06-04.
+#  Copyright 2005 smtose.org. All rights reserved.
+
+require "webrick"
+require "gambit/viewable"
+
+module Gambit
+	class Server < WEBrick::HTTPServer		
+		class Player
+			def initialize( name, password )
+				@name      = name
+				@password  = password
+				@mailbox   = Array.new
+				@notes     = Array.new
+				
+				@game_date = Hash.new
+			end
+			
+			attr_reader :name
+			attr_reader :mailbox, :notes
+			
+			def []( key )
+				@game_date[key]
+			end
+
+			def []=( key, value )
+				@game_date[key] = value
+			end
+			
+			def login?( password )
+				@password == password
+			end
+					
+		end
+	end
+end

data/lib/gambit/tools.rb

@@ -0,0 +1,13 @@
+#!/usr/local/bin/ruby -w
+
+# tools.rb
+#
+#  Created by James Edward Gray II on 2005-05-30.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "gambit/tools/board"
+require "gambit/tools/cards"
+require "gambit/tools/currency"
+require "gambit/tools/dice"
+require "gambit/tools/movehistory"
+require "gambit/tools/scorecard"

data/lib/gambit/tools/board.rb

@@ -0,0 +1,275 @@
+#!/usr/local/bin/ruby -w
+
+# board.rb
+#
+#  Created by Gregory Brown on May 29, 2004.
+#  Copyright 2005 smtose.org.  All rights reserved.
+
+require "gambit/viewable"
+
+module Gambit
+	module Tools
+		# A tool for managing a two-dimensional game board.
+		class Board
+			include Gambit::Viewable
+			register_view(:gambit_html, <<-END_HTML_VIEW.gsub(/^\t+/, ""))
+			<table class="board">
+			% each_with_location(true) do |sq, loc|
+			%	x, y = parse_location(loc)
+			% 	if x.zero?
+					<tr id="row<%= loc[/\\d+/] %>">
+			%	end
+				<%= "\\t" %><td id="<%= loc %>"><%= sq || "%nbsp;" %></td>
+			%	if x == @board.first.size - 1
+			%		if y == @board.size - 1
+						<%= "</tr>" %>
+			%		else
+						</tr>
+			%		end
+			%	end
+			% end
+			</table>
+			END_HTML_VIEW
+			register_view(:gambit_text, <<-END_TEXT_VIEW.gsub(/^\t+/, ""))
+			% widths = Array.new
+			% each_with_location do |sq, loc|
+			%	i = parse_location(loc).first
+			%	w = sq.to_s.length
+			%	widths[i] = w if widths[i].nil? or w > widths[i]
+			% end
+			% each_with_location(true) do |sq, loc|
+			%	x, y = parse_location(loc)
+				<%= "%\#{widths[x]}s" % sq %>
+			%	if x == @board.first.size - 1
+					<%= "\\n" %>
+			%   else
+					<%= '  ' %>
+			%   end
+			% end
+			END_TEXT_VIEW
+			
+			# 
+			# Creates a new Board of _x_dim_ by _y_dim_ with an optional _fill_
+			# object at each location.  (The _fill_ is dup()ed as it is placed.)
+			# 
+			def initialize( x_dim,  y_dim, fill = nil )
+				@board = Array.new(x_dim) { Array.new(y_dim) };
+				@include_diagonals = true;
+				unless(fill.nil?)
+					each_location do |loc|
+						self[loc] = fill.dup
+					end
+				end
+			end
+
+			# When set (default), diagonals are considered neighboring squares.
+			attr_accessor :include_diagonals
+
+			# Returns a row count.
+			def rows(  )
+				@board[0].length
+			end
+
+			# Returns a column count.
+			def cols(  )
+				@board.length
+			end
+
+			# 
+			# Returns the x and y indices of a given location, as indices or
+			# chess notation.
+			# 
+			# :call-seq:
+			#   parse_location(chess_notation_str)    -> x, y
+			#   parse_location(x, y)                  -> x, y
+			# 
+			def parse_location( *location )
+				if location.length == 1
+					letters = location.first[/[a-z]+/].split("").
+					                   map { |l| l[0] - ?a }.reverse
+					total = 0
+					letters.each_with_index do |letter, index|
+						total += letter + index * 26
+					end
+					x = total
+					y = location.first[1..-1].to_i - 1
+				else
+					x = location[0]
+					y = location[1]
+				end
+				return x, y
+			end
+
+			# 
+			# Returns the contents of a square.  Arguments can be anything
+			# parse_location() understands.
+			# 
+			def []( *coordinate )
+				x,y = parse_location(*coordinate)
+				return @board[x][y]
+			end
+
+			# 
+			# Sets the contents of a square.  Arguments can be anything
+			# parse_location() understands.
+			# 
+			def []=( *values )
+				item = values.pop 
+				x,y = parse_location(*values)
+				@board[x][y] = item
+			end
+
+			# 
+			# Returns an Array of neighboring locations, in chess notation.
+			# Arguments can be anything parse_location() understands.
+			# 
+			def neighboring_locations( *coordinate )
+				x,y = parse_location(*coordinate);
+				neighbor_locations = []
+				[-1,0,1].each do |xi|
+					[-1,0,1].each do |yi|
+						next if (xi == 0 and yi == 0)
+						next if !@include_diagonals and 
+						        ((xi + yi).abs != 1)
+						if valid?(x + xi, y + yi)
+							neighbor_locations << to_chess(x + xi,y + yi)
+						end
+					end
+				end
+				return neighbor_locations
+			end
+
+			# 
+			# Returns an Array of neighboring square contents, in chess
+			# notation. Arguments can be anything parse_location() understands.
+			# 
+			def neighbors( *coordinate )
+				neighbors = []
+				nl = neighboring_locations(*coordinate)
+				nl.each do |loc|
+					unless self[loc].nil?
+						neighbors << self[loc]
+					end
+				end
+				return neighbors;
+			end
+
+			# Converts _x_ and _y_ to a String of chess notation.
+			def to_chess( x, y )
+				(x + ?a).chr + (y+1).to_s
+			end
+		
+			# 
+			# Ensures that _coordinate_ is within the bounds of this Board.
+			# Arguments can be anything parse_location() understands.
+			# 
+			def valid?( *coordinate )
+				x,y = parse_location(*coordinate);
+				(x >= 0 && x < cols() && y >= 0 && y < rows()) ? true : false
+			end	
+
+			# 
+			# Moves the contents of the first square, to the second square.
+			# Arguments can be anything parse_location() understands.
+			# 
+			def move( *coordinates )
+				if coordinates.length == 2
+					self[coordinates[1]] = self[coordinates[0]].clone
+					self[coordinates[0]] = nil
+				else
+					self[coordinates[2],coordinates[3]].clone = 
+					        self[coordinates[0],coordinates[1]]
+					self[coordinates[0],coordinates[1]] = nil
+				end
+			end
+
+			# 
+			# Iterate over the columns of this Board.  Pass +true+ to _reverse_
+			# to swap the iteration order.
+			# 
+			def each_col( reverse = false, &block )
+				if reverse
+					@board.reverse.each(&block)
+				else
+					@board.each(&block)
+				end
+			end
+
+			# 
+			# Iterate over the rows of this Board.  Pass +true+ to _reverse_ to
+			# swap the iteration order.
+			# 
+			def each_row( reverse = true )
+				if reverse
+					((0 ... @board[0].length).to_a.reverse).each do |index|
+						yield @board.collect{ |column| column[index] }
+					end
+				else
+					(0 ... @board[0].length).each do |index|
+						yield @board.collect{ |column| column[index] }
+					end
+				end
+			end
+
+			include Enumerable
+
+			# 
+			# Iterate over the squares of this Board.  Pass +true+ to _reverse_
+			# to swap the iteration order.
+			# 
+			def each( reverse = false, &block )
+				if reverse
+					((0 ... @board[0].length).to_a.reverse).each do |index|
+						@board.collect do |column|
+							column[index]
+						end.each(&block)
+					end
+				else
+					@board[0].each_index do |index|
+						@board.collect{ |column| column[index] }.each(&block)
+					end
+				end
+			end
+
+			# 
+			# Iterate over the locations of this Board.  Pass +true+ to
+			# _reverse_ to swap the iteration order.
+			# 
+			def each_location( reverse = false )
+				if reverse
+					(@board[0].length - 1).downto(0) do |row|
+						0.upto(@board.length-1) do |column|
+							yield to_chess(column,row)
+						end
+					end
+				else
+					0.upto(@board[0].length-1) do |row|
+						0.upto(@board.length-1) do |column|
+							yield to_chess(column,row)
+						end
+					end
+				end
+			end
+
+			# 
+			# Iterate over the squares and locations of this Board.  Pass +true+
+			# to _reverse_ to swap the iteration order.
+			# 
+			def each_with_location( reverse = false )
+				if reverse
+					(@board[0].length - 1).downto(0) do |row|
+						0.upto(@board.length-1) do |column|
+							yield(@board[column][row], to_chess(column,row))
+						end
+					end
+				else
+					0.upto(@board[0].length-1) do |row|
+						0.upto(@board.length-1) do |column|
+							yield(@board[column][row], to_chess(column,row))
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/gambit/tools/cards.rb

@@ -0,0 +1,11 @@
+#!/usr/local/bin/ruby -w
+
+# cards.rb
+#
+#  Created by James Edward Gray II on 2005-05-30.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "gambit/tools/cards/card"
+require "gambit/tools/cards/deck"
+require "gambit/tools/cards/hand"
+require "gambit/tools/cards/pile"

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

@@ -0,0 +1,158 @@
+#!/usr/local/bin/ruby -w
+
+# card.rb
+#
+#  Created by James Edward Gray II on 2005-05-30.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "gambit/viewable"
+
+# The namespace for all three layers of the Gambit framework.
+module Gambit
+	# 
+	# The namespace for all the game creation tools (model layer) the Gambit 
+	# framework.
+	# 
+	module Tools
+		# The namespace for all card game tools.
+		module Cards
+			# 
+			# The base class for all Card objects using the Gambit tools 
+			# framework.
+			# 
+			class Card
+				include Gambit::Viewable
+
+				# 
+				# Subclasses must provide a creation iterator that will yield
+				# each Card in a Deck.
+				# 
+				def self.each(  )
+					raise NotImplementedError,
+					      "Subclasses must override self.each()."
+				end
+
+				include Comparable
+				
+				# Sublclasses must provide a comparator method.
+				def <=>( other )
+					raise NotImplementedError, "Subclasses must override <=>()."
+				end
+			end
+			
+			class StandardCard < Card
+				register_view(:gambit_html, <<-END_HTML_VIEW.gsub(/\t{4}/, ""))
+				<dl class="card">
+					<dt>Value:</dt>
+					<dd><%= @value %></dd>
+					
+					<dt>Suit:</dt>
+					<dd><%= @suit %></dd>
+				</dl>
+				END_HTML_VIEW
+				register_view(:gambit_text, "<%= name %>")
+				
+				@@suit_order = [:clubs, :diamonds, :hearts, :spades]
+				# 
+				# Set a suit order.  Default is:
+				# 
+				#   [:clubs, :diamonds, :hearts, :spades]
+				# 
+				def self.suit_order=( suits ) @@suit_order = suits end
+				# Fetch the current suit order.
+				def self.suit_order(  )       @@suit_order         end
+
+				@@value_order = [ :ace, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+				                  :jack, :queen, :king ]
+				# 
+				# Set a card value order.  Default is:
+				# 
+				#   [ :ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, :jack, :queen, :king ]
+				# 
+				def self.value_order=( values ) @@value_order = values end
+				# Fetch the current card value order.
+				def self.value_order(  )        @@value_order          end
+				
+				@@use_jokers = false
+				# When set (not the default), jokers will be used.
+				def self.use_jokers=( use ) @@use_jokers = use end
+				# Determine if jokers are being used.
+				def self.use_jokers(  )     @@use_jokers       end
+
+				@@jokers_are_high = true
+				# 
+				# When set (default), the jokers are considered high cards in
+				# sorting.
+				# 
+				def self.jokers_are_high=( high ) @@jokers_are_high = high end
+				# Determine if jokers are high.
+				def self.jokers_are_high(  )      @@jokers_are_high        end
+
+				# Yields one of each possible card, in turn for Deck creation.
+				def self.each(  )
+					@@suit_order.each do |suit|
+						@@value_order.each do |value|
+							yield new(value, suit)
+						end
+					end
+					
+					if @@use_jokers
+						yield new(:joker, :red)
+						yield new(:joker, :black)
+					end
+				end
+				
+				# Creates a new StandardCard of _value_ and _suit_.
+				def initialize( value, suit )
+					@value, @suit = value, suit
+				end
+				
+				# The value or name of this card.
+				attr_reader :value
+				# The suit of this card.
+				attr_reader :suit
+				
+				# Support for ranking (and sorting) the cards.
+				def <=>( other )
+					if self == other
+						0
+					elsif @value == :joker or other.value == :joker
+						if @value == :joker and other.value == :joker
+							if @suit == :red then -1 else 1 end
+						elsif @value == :joker
+							if @@jokers_are_high then 1 else -1 end
+						else
+							if @@jokers_are_high then -1 else 1 end
+						end
+					else
+						suit_rank       = self.class.suit_order.index(@suit)
+						other_suit_rank =
+							self.class.suit_order.index(other.suit)
+					
+						if suit_rank != other_suit_rank
+							suit_rank <=> other_suit_rank
+						else
+							self.class.value_order.index(@value) <=>
+								self.class.value_order.index(other.value)
+						end
+					end
+				end
+				
+				# Compares this card with _other_ for equality.
+				def ==( other )
+					@value == other.value and @suit == other.suit
+				end
+				
+				# Returns the String name of this card (human readable).
+				def name(  )
+					if @value == :joker
+						"The #{@suit.to_s.capitalize} #{@value.to_s.capitalize}"
+					else
+						"The #{@value.to_s.capitalize} " +
+						"of #{@suit.to_s.capitalize}"
+					end
+				end
+			end
+		end
+	end
+end