gambit 0.1.0

data/lib/gambit/tools/movehistory.rb

@@ -0,0 +1,164 @@
+#!/usr/local/bin/ruby -w
+
+# movehistory.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
+		# An objectified move history object.
+		class MoveHistory
+			include Gambit::Viewable
+			register_view(:gambit_html, <<-END_HTML_VIEW.gsub(/^\t{3}/, ""))
+			<table class="movehistory">
+			% turns      = @moves.keys.sort
+			<tr>
+				<th>&nbsp;</th>
+			% @players.each do |player|
+				<th id="<%= player %>"><%= player %></th>
+			% end
+			<%= "</tr>" %>
+			% even = true
+			% turns.each do |turn|
+			% even = (not even)
+			%		if even
+			<tr class="even">
+			%		else
+			<tr class="odd">
+			%		end
+				<td class="turn"><%= turn %></td>
+			% 	@players.each do |player|
+				<td id="<%= player %><%= turn %>"><%= @moves[turn][player] ||
+				"&nbsp;" %></td>
+			%	end
+			%		if turn == turns.last
+			</tr>
+			%		else
+			<%= "</tr>" %>
+			%		end
+			% end
+			</table>
+			END_HTML_VIEW
+			register_view(:gambit_text, <<-END_TEXT_VIEW.gsub(/^\t+/, ""))
+			% turns      = @moves.keys.sort
+			% len_cmp    = lambda { |a, b| a.length <=> b.length }
+			% turn_width = turns.map { |t| t.to_s }.max(&len_cmp).length
+			% move_width = [ @moves.map { |(turn, moves)| moves.values }.
+			%                flatten.max(&len_cmp).length,
+			%                @players.max(&len_cmp).length ].max
+			<%= ("%\#{turn_width}s  " + "%\#{move_width}s  " * @players.size) %
+			    ["", *@players] %>
+			% turns.each do |turn|
+			%	unless @moves[turn][@players.first].nil?
+			<%= ("%\#{turn_width}d: " + "%\#{move_width}s  " * @players.size) %
+			    [turn, *@players.map { |p| @moves[turn][p] }] %>
+			%	end
+			% end
+			END_TEXT_VIEW
+
+			# 
+			# Creates a new MoveHistory object, optionally initialized with some
+			# _players_.
+			# 
+			def initialize( *players )
+				@players     = Array.new
+				@turn        = 1
+				@next_player = 0
+				@moves       = Hash.new { |moves, turn| moves[turn] = Hash.new }
+
+				add_players(*players)
+			end
+
+			# The current turn number or name.
+			attr_accessor :turn
+			
+			# 
+			# Returns the moves for the provided _turn_ (optionally for the 
+			# given _player_.)
+			# 
+			def []( turn, player = nil )
+				if player.nil?
+					@moves[turn]
+				else
+					@moves[turn][player]
+				end
+			end
+
+			# 
+			# Add _move_ to the current player for the current turn.
+			# 
+			# Returns +self+ for method chaining.
+			# 
+			def <<( move )
+				@moves[@turn][@players[@next_player]] = move
+				
+				find_next_player
+				
+				self
+			end
+
+			# 
+			# Add a _player_ to this MoveHistory.
+			# 
+			# Returns +self+ for method chaining.
+			# 
+			def add_player( player )
+				@players << player
+
+				self
+			end
+
+			# 
+			# Add a group of _players_ to this MoveHistory.
+			# 
+			# Returns +self+ for method chaining.
+			# 
+			def add_players( *players )
+				players.each { |player| add_player(player) }
+
+				self
+			end
+			
+			# Iterate over each move, by turn and then by player.
+			def each(  )
+				@moves.each do |(turn, moves)|
+					@players.each { |player| yield moves[player] }
+				end
+			end
+
+			# 
+			# Add's an _event_ to the given _player_ for the current turn.  If 
+			# the player already has and event for that turn, an Array is used
+			# to hold all added events in order.
+			# 
+			# Returns +self+ for method chaining.
+			# 
+			def record( player, event )
+				if @moves[@turn][player].nil?
+					@moves[@turn][player] = event
+				elsif @moves[@turn][player].is_a? Array
+					@moves[@turn][player] << event
+				else
+					@moves[@turn][player] = [@moves[@turn][player]]
+					@moves[@turn][player] << event
+				end
+				
+				self
+			end
+			
+			private
+			
+			# Loops through players, circularly.
+			def find_next_player(  )
+				@next_player += 1
+				if @next_player >= @players.size
+					@next_player = 0
+					@turn += 1
+				end
+			end
+		end
+	end
+end

data/lib/gambit/tools/scorecard.rb

@@ -0,0 +1,333 @@
+#!/usr/local/bin/ruby -w
+
+# scorecard.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
+		# A tool for managing the score of just about any game.
+		class Scorecard
+			include Gambit::Viewable
+			register_view(:gambit_html, <<-END_HTML_VIEW.gsub(/^\t{3}/, ""))
+			<table class="scorecard">
+			<tr>
+				<th>&nbsp;</th>
+			% @players.each do |player|
+				<th id="<%= player %>"><%= player %></th>
+			% end
+			<%= "</tr>" %>
+			% even = true
+			% @order.each do |cat|
+			% even = (not even)
+			%		if even
+			<tr class="even">
+			%		else
+			<tr class="odd">
+			%		end
+				<td class="category"><%= cat %></td>
+			% 	@players.each do |player|
+			%		if @categories.assoc(cat)
+				<td id="<%= player %>--<%= cat %>"><%=
+			        @categories_score[player][cat] || "&nbsp;" %></td>
+			%		elsif subtotal = @totals.assoc(cat)
+				<td id="<%= player %>--<%= cat %>"><%=
+			        figure_total(player, subtotal[1], subtotal[2]) ||
+			    "&nbsp;" %></td>
+			%		end
+			%	end
+			%		if cat == @order.last
+			</tr>
+			%		else
+			<%= "</tr>" %>
+			%		end
+			% end
+			</table>
+			END_HTML_VIEW
+			register_view(:gambit_text, <<-END_TEXT_VIEW.gsub(/^\t+/, ""))
+			% max_len = @players.max { |a, b| a.length <=> b.length }.length
+			% cat_len = @order.max { |a, b| a.length <=> b.length }.length
+			<%= "%\#{cat_len}s" % "" %>  <%= "%\#{max_len}s  " * @players.size %
+			    @players %>
+			% last = nil
+			% @order.each do |cat|
+			%	if @categories.assoc(cat)
+			%		if @totals.assoc(last)
+			
+			%		end
+			<%= "%\#{cat_len}s" % cat %>: <%= "%\#{max_len}s  " * 
+			    @players.size % @players.map { |player|
+								@categories_score[player][cat] } %>
+			%	elsif subtotal = @totals.assoc(cat)
+			<%= "-" * cat_len %>  <%=
+			    (("-" * max_len) + "  ") * @players.size %>
+			<%= "%\#{cat_len}s" % cat %>: <%= "%\#{max_len}s  " * 
+			    @players.size % @players.map { |player|
+				figure_total(player, subtotal[1], subtotal[2]) } %>
+			%	end
+			%	last = cat
+			% end
+			END_TEXT_VIEW
+
+			# 
+			# Creates a new Scorecard object, optionally initialized with some
+			# _players_.
+			# 
+			def initialize( *players )
+				@score            = Hash.new(0)
+				@players          = Array.new
+				
+				@use_categories   = false
+				@categories       = Array.new
+				@totals           = Array.new
+				@order            = Array.new
+				@categories_score = Hash.new do |names, cat|
+					names[cat] = Hash.new(0)
+				end
+				@win_category     = nil
+				
+				add_players(*players)
+			end
+			
+			# 
+			# Add a new _player_ to this Scorecard.
+			# 
+			# Returns +self+ for method chaining.
+			# 
+			def add_player( player )
+				@players << player
+
+				self
+			end
+
+			# 
+			# Add a group of _players_ to this Scorecard.
+			# 
+			# Returns +self+ for method chaining.
+			# 
+			def add_players( *players )
+				players.each { |player| add_player(player) }
+
+				self
+			end
+
+			# 
+			# Returns the losing player, as determined by the provided winning
+			# _condition_.  If a _condition_ block is not given, scores will be
+			# compared numerically, with the highest score considered to be the
+			# best.
+			# 
+			def loser( &condition )
+				if @use_categories
+					scores = @categories_score.map do |(name, scores)|
+						if @categories.assoc(@win_category)
+							@score[@win_category]
+						elsif total = @totals.assoc(@win_category)
+							figure_total(name, total[1], total[2])
+						end
+					end
+					best_score = scores.min(&condition)
+					@categories_score.find do |(name, score)|
+						if @categories.assoc(@win_category)
+							@score[@win_category] == best_score
+						elsif total = @totals.assoc(@win_category)
+							figure_total(name, total[1], total[2]) == best_score
+						end
+					end.first
+				else
+					best_score = @score.values.min(&condition)
+					@score.find { |(player, score)| score == best_score }.first
+				end
+			end
+
+			# 
+			# Forces this Scorecard to score by category only.
+			# 
+			# Returns +self+ for method chaining.
+			# 
+			def require_categories(  )
+				@use_categories = true
+				
+				self
+			end
+			
+			# 
+			# Can be used to add _points_ to the score of the given _player_ or
+			# to fetch the score for a _player_, by omitting the _points_.  If 
+			# given, a score will be modified or fetched for the given 
+			# _category_.
+			# 
+			def score( player, points = 0, category = nil )
+				if @use_categories
+					cat = @categories.assoc(category) or
+						raise ArgumentError, "Invalid category."
+
+					total = @categories_score[player][category]
+					total += points
+
+					if cat.size == 2 and cat.last.is_a? Proc
+						unless cat.last[total]
+							raise ArgumentError, "Invalid score for " +
+							                     "#{cat.first} category."
+						end
+					elsif cat.size == 2 and cat.last.is_a? Array
+						unless cat.last.include?(total)
+							raise ArgumentError, "Invalid score for " +
+							                     "#{cat.first} category."
+						end
+					elsif cat.size == 3
+						unless cat[1] <= total and total <= cat[2]
+							raise ArgumentError, "Invalid score for " +
+							                     "#{cat.first} category."
+						end
+					end
+
+					@categories_score[player][category] = total
+
+					total(player, category)
+				else
+					@score[player] += points
+					@score[player] = yield(@score[player]) if block_given?
+
+					total(player)
+				end
+			end
+			
+			# 
+			# This method adds a "total" field to this Scorecard, by _name_.
+			# A total can  be calculated _from_ any other fields on the card,
+			# including other totals.
+			# 
+			# A _validation_ block can be given, if needed.  The block will be 
+			# called each time the total is display and passed the sum of all
+			# _from_ fields.  The return value of the block will be the total
+			# displayed.
+			# 
+			# Returns +self+ for method chaining.
+			# 
+			def set_total( name, *from, &validation )
+				@order << name
+				@totals << [name, from, validation]
+				
+				self
+			end
+
+			# 
+			# Sets the score catrgory used to determine a winner.
+			# 
+			# Returns +self+ for method chaining.
+			# 
+			def set_win( name )
+				@win_category = name
+				
+				self
+			end
+			
+			# 
+			# Sets a starting score for each field.  *WARNING*:  Should be 
+			# called before any calls to score(), for predictable results.
+			# 
+			def start_at=( minimum_score )
+				@score.default = minimum_score
+			end
+
+			# 
+			# Returns the total score for the given _player_ or for the given 
+			# _player_ in the optional _category_.
+			# 
+			def total( player, category = nil )
+				if category.nil?
+					@score[player]
+				else
+					if @categories.assoc(category)
+						@categories_score[player][category]
+					elsif total = @totals.assoc(category)
+						figure_total(player, total[1], total[2])
+					else
+						
+					end
+				end
+			end
+			
+			# 
+			# Adds a _category_ to this Scorecard.
+			# 
+			# Returns +self+ for method chaining.
+			# 
+			# :call-seq:
+			#   use_category(cat) { |score| ... }            -> self
+			#   use_category(cat, ary_of_accepted_values)    -> self
+			#   use_category(cat, low, high)                 -> self
+			# 
+			def use_category( category, *details, &validation )
+				@order << category
+				
+				if not validation.nil?
+					@categories << [category, validation]
+				elsif details.size == 1 and details[0].is_a? Array
+					@categories << [category, details[0]]
+				elsif details.size == 2 and details.all? { |n| n.is_a? Integer }
+					@categories << [category, *details]
+				else
+					raise ArgumentError, "Invalid category definition."
+				end
+				
+				self
+			end
+			
+			# 
+			# Returns the winning player, as determined by the provided winning
+			# _condition_.  If a _condition_ block is not given, scores will be
+			# compared numerically, with the highest score considered to be the
+			# best.
+			# 
+			def winner( &condition )
+				if @use_categories
+					scores = @categories_score.map do |(name, scores)|
+						if @categories.assoc(@win_category)
+							@score[@win_category]
+						elsif total = @totals.assoc(@win_category)
+							figure_total(name, total[1], total[2])
+						end
+					end
+					best_score = scores.max(&condition)
+					@categories_score.find do |(name, score)|
+						if @categories.assoc(@win_category)
+							@score[@win_category] == best_score
+						elsif total = @totals.assoc(@win_category)
+							figure_total(name, total[1], total[2]) == best_score
+						end
+					end.first
+				else
+					best_score = @score.values.max(&condition)
+					@score.find { |(player, score)| score == best_score }.first
+				end
+			end
+			
+			private
+			
+			# 
+			# Calculates a total field as described in set_total() and returns
+			# the score.
+			# 
+			def figure_total( player, from, validate )
+				total = 0
+
+				from.each do |cat_or_total|
+					if @categories.assoc(cat_or_total)
+						total += @categories_score[player][cat_or_total]
+					elsif subtotal = @totals.assoc(cat_or_total)
+						total += figure_total(player, subtotal[1], subtotal[2])
+					end
+				end
+				
+				total = validate[total] unless validate.nil?
+				
+				total
+			end
+		end
+	end
+end