```I don't want to spoil all the fun, in case anyone is still attempting
this quiz, but here's my solution to four of the seven variations:

#!/usr/local/bin/ruby -w

# blackhole_chess
#
#  Created by James Edward Gray II on 2005-06-20.

require "chess"

# An enhanced chess board for playing Blackhole Chess.
class BlackholeChess < Chess::Board
#
# A general purpose test to see if a _test_ square is between
_start_ and
# _finish_ squares, on a rank, file or diagonal.
#
def self.between?( start, finish, test )
test_rank,   test_file   = test[1, 1].to_i,   test[0]
start_rank,  start_file  = start[1, 1].to_i,  start[0]
finish_rank, finish_file = finish[1, 1].to_i, finish[0]

( test_rank == start_rank and test_rank == finish_rank and
test_file >= [start_file, finish_file].min and
test_file <= [start_file, finish_file].max ) or
( test_file == start_file and test_file == finish_file and
test_rank >= [start_rank, finish_rank].min and
test_rank <= [start_rank, finish_rank].max ) or
( (start_file - finish_file).abs == (start_rank -
finish_rank).abs and
(start_file - test_file).abs == (start_rank -
test_rank).abs and
(test_file - finish_file).abs == (test_rank -
finish_rank).abs and
test_file >= [start_file, finish_file].min and
test_file <= [start_file, finish_file].max and
test_rank >= [start_rank, finish_rank].min and
test_rank <= [start_rank, finish_rank].max )
end

# End the game if a King goes missing.
def in_checkmate?( who = @turn )
if find { |(s, pc)| pc and pc.color == who and pc.is_a?
Chess::King }
super
else
true
end
end

# Eliminate any piece moving through the blackholes.
def move( from_square, to_square, promote_to = nil )
if self.class.between?(from_square, to_square, "d5") or
self.class.between?(from_square, to_square, "f5")
@squares[from_square] = nil
next_turn
else
super
end

self
end

# Board display with two added blackholes.
def to_s(  )
super.sub( /^(5\s+\|(?:[^|]+\|){3})[^|]+\|([^|]+\|)[^|]+\|/,
"\\1 * |\\2 * |" )
end
end

board = BlackholeChess.new

# insert my chess inteface code (see Summary) here, with a minor
# a king that falls into a blackhole

__END__

#!/usr/local/bin/ruby -w

# fairy_chess
#
#  Created by James Edward Gray II on 2005-06-20.

require "chess"

#
# The container for the behavior of a chess fairy.  Fairies are
simply treated
# as both a Queen and a Knight.
#
class Fairy < Chess::Queen
#
# Returns all the capturing moves for a Fairy on the provided
_board_
# at the provided _square_ of the provided _color_.
#
def self.captures( board, square, color )
captures =  Chess::Queen.captures(board, square, color)
captures += Chess::Knight.captures(board, square, color)
captures.sort
end

#
# Returns all the non-capturing moves for a Fairy on the provided
# _board_ at the provided _square_ of the provided _color_.
#
def self.moves( board, square, color )
moves =  Chess::Queen.moves(board, square, color)
moves += Chess::Knight.moves(board, square, color)
moves.sort
end
end

# Make the Chess::King aware of the Fairy.
class FairyAwareKing < Chess::King
# Enhance in_check? to spot special Fairy moves.
def self.in_check?( bd, sq, col )
return true if Chess::Knight.captures(bd, sq, col).any? do |
name|
bd[name].is_a?(Fairy)
end

Chess::King.in_check?( bd, sq, col )
end

# Make this piece show up as a normal King.
def to_s(  )
if @color == :white then "K" else "k" end
end
end

# An enhanced chess board for playing Fairy Chess.
class FairyChess < Chess::Board
# Setup a normal board, then replace the queens with fairies.
def setup(  )
super

@squares["d1"] = Fairy.new(self, "d1", :white)
@squares["d8"] = Fairy.new(self, "d8", :black)
@squares["e1"] = FairyAwareKing.new(self, "e1", :white)
@squares["e8"] = FairyAwareKing.new(self, "e8", :black)
end
end

board = FairyChess.new

# insert my chess inteface code (see Summary) here

__END__

#!/usr/local/bin/ruby -w

# fibonacci_chess
#
#  Created by James Edward Gray II on 2005-06-20.

require "chess"

# An enhanced chess board for playing Fibonacci Chess.
class FibonacciBoard < Chess::Board
# Setup chess board and initialize move count sequence.
def initialize(  )
super

@fib1  = nil
@fib2  = nil
@count = 1
end

# Advance turn, as players complete moves in the Fibonacci
sequence.
def next_turn(  )
if @fib1.nil?
@fib1 = 1
elsif @fib2.nil?
@fib2 = 2
next_turn if in_check?(@turn == :white ? :black : :white)
elsif @count.zero? or in_check?(@turn
== :white ? :black : :white)
@fib1, @fib2 = @fib2, @fib1 + @fib2
@count = @fib2 - 1
else
@count -= 1
return
end

super
end

# Return a String description of the moves remaining.
def moves_remaining(  )
if @fib1.nil? or @fib2.nil? or @count.zero?
"last move"
else
"#{@count + 1} moves"
end
end
end

board = FibonacciBoard.new

# insert my chess inteface code (see Summary) here

__END__

#!/usr/local/bin/ruby -w

# gun_chess
#
#  Created by James Edward Gray II on 2005-06-20.

require "chess"

# An enhanced chess board for playing Gun Chess.
class GunChess < Chess::Board
# Returns a numerical count of all the pieces on the board.
def count_pieces(  )
find_all { |(square, piece)| piece }.size
end

# Make standard chess moves, save that capturing pieces do not
move.
def move( from_square, to_square, promote_to = nil )
old_count = count_pieces

super    # normal chess move

if count_pieces < old_count         # if it was a capture...
move(to_square, from_square)    # move the piece back
next_turn                       # fix the extra turn change
end

self
end
end

board = GunChess.new

# insert my chess inteface code (see Summary) here, with a minor
# promote pawns on moves only, never captures

__END__