bangkok 0.1.0

data/lib/bangkok/info.rb

@@ -0,0 +1,6 @@
+VERSION_MAJOR = 0
+VERSION_MINOR = 1
+VERSION_TWEAK = 0
+
+Version = "#{VERSION_MAJOR}.#{VERSION_MINOR}.#{VERSION_TWEAK}"
+Copyright = 'Copyright (c) 2005 by Jim Menard <jimm@io.com>'

data/lib/bangkok/move.rb

@@ -0,0 +1,106 @@
+require 'bangkok/square'
+
+
+# A Move is a single piece's move in a chess match. There are two Move objects
+# created for each chess match move: one for white and one for black.
+class Move
+  attr_reader :color, :piece, :square, :from_rank_or_file, :modifier
+
+  # Parse the chess piece move +text+ and set piece, square, and modifier.
+  def initialize(color, text)
+    @color = color              # :white or :black
+    @orig_text = text
+
+    # Note: I don't have to worry about "e.p." en passant notation; the data
+    # files do not use that.
+    case text
+    when 'O-O-O', 'O-O', '0-0-0', '0-0'
+      @modifier = text.gsub(/0/, 'O') # zeroes to capital o's
+      @piece = 'K'
+      @square = Square::OFF_BOARD # Not really, of course; square is never used
+    when /^([KQRBNa-h1-8])x([a-h][1-8])(.*)$/
+      piece_or_from_rank_or_file, file_and_rank, @modifier = $1, $2, $3
+      @square = Square.new(file_and_rank)
+      case piece_or_from_rank_or_file
+      when /[a-h1-8]/           # first char is file or rank; it's a pawn
+        @piece = 'P'
+        @from_rank_or_file = Square.new(piece_or_from_rank_or_file)
+      else                      # first char is piece name
+        @piece = piece_or_from_rank_or_file
+      end
+      @modifier ||= ''
+      @modifier << 'x'
+    when /^([KQRBN]?)([a-h1-8]?)([a-h][1-8])(.*)$/
+      @piece, from_rank_or_file, file_and_rank, @modifier = $1, $2, $3, $4
+      @square = Square.new(file_and_rank)
+      unless from_rank_or_file.empty?
+        @from_rank_or_file = Square.new(from_rank_or_file) 
+      end
+    else
+      raise "I can't understand the move \"#{@orig_text}\""
+    end
+
+    @piece = 'P' if @piece.empty?
+    @piece = @piece.intern
+  end
+
+  def to_s
+    return @orig_text
+  end
+
+  # Returns true if @modifier is not null and includes +str+.
+  def has_modifier?(str)
+    return false unless @modifier
+    return @modifier.include?(str)
+  end
+
+  # Returns true if this is a capture
+  def capture?
+    has_modifier?('x')
+  end
+
+  # Returns true if this is a castle (either side)
+  def castle?
+    has_modifier?('O-O')	# Also true if O-O-O
+  end
+
+  # Returns true if this is a queenside castle
+  def queenside_castle?
+    has_modifier?('O-O-O')
+  end
+
+  # Returns true if this is a kingside castle
+  def kingside_castle?
+    has_modifier?('O-O') && !queenside_castle?
+  end
+
+  # Returns true if this move results in a pawn promotion
+  def pawn_promotion?
+    has_modifier?('Q')
+  end
+
+  # Returns true if this move results in a check
+  def check?
+    has_modifier?('+')
+  end
+
+  # Returns true if this move results in a checkmate
+  def checkmate?
+    has_modifier?('#')
+  end
+
+  # Returns true if this move was a good one
+  def good_move?
+    has_modifier?('!')
+  end
+
+  # Returns true if this move was a bad one
+  def bad_move?
+    has_modifier?('?') && !blunder?
+  end
+
+  # Returns true if this move was a blunder
+  def blunder?
+    has_modifier?('??')
+  end
+end

data/lib/bangkok/piece.rb

@@ -0,0 +1,243 @@
+require 'bangkok/square'
+
+class Piece
+  attr_reader :color, :piece, :square
+
+  # Factory method that creates a piece of the proper subclass
+  def Piece.create(board, listener, color, piece_sym, square)
+    return case piece_sym
+        when :K
+          King.new(board, listener, color, square)
+        when :Q
+          Queen.new(board, listener, color, square)
+        when :B
+          Bishop.new(board, listener, color, square)
+        when :N
+          Knight.new(board, listener, color, square)
+        when :R
+          Rook.new(board, listener, color, square)
+        when :P
+          Pawn.new(board, listener, color, square)
+        end
+  end
+
+  def initialize(board, listener, color, piece, square)
+    @board, @listener, @color, @piece, @square =
+      board, listener, color, piece, square
+  end
+
+  def move_to(square)
+    puts "#{self} moving to #{square}" if $verbose
+    @listener.move(self, @square, square)
+    @square = square
+  end
+
+  def move_off_board
+    return move_to(Square::OFF_BOARD)
+  end
+
+  # Make sure this piece can perform +move+. This implementation checks the
+  # basics (the color and type of this piece and the emptiness or color of the
+  # piece at the destination square); subclasses add further checks.
+  def could_perform_move(move)
+    p = @board.at(move.square)
+    return @color == move.color && piece == move.piece &&
+      (p.nil? || p.color != @color)
+  end
+
+  # Checks diagonals and straight horizontal/vertical lines. Won't work
+  # correctly for anything else.
+  def clear_to?(square)
+    curr_file = @square.file
+    end_file = square.file
+    file_delta = @square.file < square.file ? 1 :
+                               (@square.file == square.file ? 0 : -1)
+    curr_file += file_delta unless curr_file == end_file # Skip current loc
+
+    curr_rank = @square.rank
+    end_rank = square.rank
+    rank_delta = @square.rank < square.rank ? 1 :
+                               (@square.rank == square.rank ? 0 : -1)
+    curr_rank += rank_delta unless curr_rank == end_rank # Skip current loc
+
+    if file_delta == 0 && rank_delta == 0
+      raise "error: trying to move to same space #{file}#{rank}"
+    end
+
+    while curr_file != end_file || curr_rank != end_rank
+      return false unless @board.empty_at?(Square.new(curr_file, curr_rank))
+      curr_file += file_delta
+      curr_rank += rank_delta
+    end
+
+    return true
+  end
+
+  def to_s
+    str = "#{@color.to_s.capitalize} #@piece "
+    str << "at " if @square.on_board?
+    str << @square.to_s
+    str
+  end
+end
+
+class King < Piece
+  def initialize(board, listener, color, square)
+    super(board, listener, color, :K, square)
+  end
+
+  # There is no King#could_move_to method because it would only be called if
+  # there were more than one King of the same color on the board, which can
+  # not happen.
+end
+
+class Queen < Piece
+  def initialize(board, listener, color, square)
+    super(board, listener, color, :Q, square)
+  end
+
+  # There can be more than one queen on the board, thus this method must be
+  # implemented.
+  def could_perform_move(move)
+    return false unless super
+
+    # Check for horizontal or vertical
+    square = move.square
+    if @square.file == square.file || @square.rank == square.rank
+      return clear_to?(square)
+    end
+
+    # Check for diagonal
+    return false unless square.color == @square.color
+    d_file = (@square.file - square.file).abs
+    d_rank = (@square.rank - square.rank).abs
+    return false unless d_file == d_rank # diagonal
+    return clear_to?(square)
+  end
+end
+
+class Bishop < Piece
+  def initialize(board, listener, color, square)
+    super(board, listener, color, :B, square)
+  end
+
+  def could_perform_move(move)
+    return false unless super
+
+    # Quick square color check
+    square = move.square
+    return false unless square.color == @square.color
+
+    d_file = (@square.file - square.file).abs
+    d_rank = (@square.rank - square.rank).abs
+    return false unless d_file == d_rank # diagonal
+    return clear_to?(square)
+  end
+end
+
+class Knight < Piece
+  def initialize(board, listener, color, square)
+    super(board, listener, color, :N, square)
+  end
+
+  def could_perform_move(move)
+    return false unless super
+
+    square = move.square
+    d_file = (@square.file - square.file).abs
+    d_rank = (@square.rank - square.rank).abs
+    return (d_file == 2 && d_rank == 1) || (d_file == 1 && d_rank == 2)
+  end
+end
+
+class Rook < Piece
+  def initialize(board, listener, color, square)
+    super(board, listener, color, :R, square)
+  end
+
+  def could_perform_move(move)
+    return false unless super
+
+    square = move.square
+    return false if square.file != @square.file && square.rank != @square.rank
+    return clear_to?(square)
+  end
+end
+
+class Pawn < Piece
+  attr_reader :moved
+
+  def initialize(board, listener, color, square)
+    super(board, listener, color, :P, square)
+    @moved = false
+  end
+
+  def move_to(square)
+    @moved = true
+    return super
+  end
+
+  def could_perform_move(move)
+    return false unless super
+
+    square = move.square
+    if @color == :white
+      if square.file == @square.file && square.rank == @square.rank + 1
+        # single step forwards
+        return @board.empty_at?(square)
+      elsif square.file + 1 == @square.file && square.rank == @square.rank + 1
+        # take a piece queenside
+        return !@board.empty_at?(square)
+      elsif square.file == @square.file + 1 && square.rank == @square.rank + 1
+        # take a piece kingside
+        return !@board.empty_at?(square)
+      elsif !@moved && square.file == @square.file &&
+                       square.rank == @square.rank + 2
+        # first move: 2 squares forward
+        return @board.empty_at?(Square.new(@square.file, @square.rank + 1)) &&
+          @board.empty_at?(square)
+
+# TODO Implement en passant checking. The following code was wrong. 
+
+#       elsif !@moved && square.file + 1 == @square.file &&
+#                        square.rank == @square.rank + 2
+#         # e.p. queenside
+#         return !@board.empty_at?(square)
+#       elsif !@moved && square.file == @square.file + 1 &&
+#                        square.rank == @square.rank + 2
+#         # e.p. kingside
+#         return !@board.empty_at?(square)
+
+      end
+    else
+      # black
+      if square.file == @square.file && square.rank == @square.rank - 1
+        # single step forwards
+        return @board.empty_at?(square)
+      elsif square.file + 1 == @square.file && square.rank == @square.rank - 1
+        # take a piece queenside
+        return !@board.empty_at?(square)
+      elsif square.file == @square.file + 1 && square.rank == @square.rank - 1
+        # take a piece kingside
+        return !@board.empty_at?(square)
+      elsif !@moved && square.file == @square.file &&
+                       square.rank == @square.rank - 2
+        # first move: 2 spaces forward
+        return @board.empty_at?(Square.new(@square.file, @square.rank - 1)) &&
+          @board.empty_at?(square)
+
+# TODO Implement en passant checking. The following code was wrong. 
+
+#       elsif !@moved && square.file + 1 == @square.file &&
+#                        square.rank == @square.rank - 2
+#         # en passant queenside
+#         return !@board.empty_at?(square)
+#       elsif !@moved && square.file == @square.file + 1 &&
+#                        square.rank == @square.rank - 2
+#         # en passant kingside
+#         return !@board.empty_at?(square)
+
+      end
+    end
+  end
+end

data/lib/bangkok/square.rb

@@ -0,0 +1,47 @@
+# Represents a location on the board. Immutable.
+class Square
+  attr_reader :file, :rank      # Always 0-7
+  attr_reader :color            # :white or :black
+
+  def initialize(*args)
+    @file = @rank = @color = nil
+    case args[0]
+    when Square                 # copy values from another Square
+      @file = args[0].file
+      @rank = args[0].rank
+      @color = args[0].color
+    when Numeric                # (file number, rank number)
+      @file = args[0].to_i      # If floating point, make integer
+      @rank = args[1].to_i
+      @color = (((@file & 1) == (@rank & 1)) ? :black : :white) if on_board?
+    when /[a-h][1-8]/           # a3, d8
+      @file = args[0][0] - ?a
+      @rank = args[0][1,1].to_i - 1
+      @color = ((@file & 1) == (@rank & 1)) ? :black : :white
+    when /[a-h]/                # Either (file letter, rank) or a file 'a'
+      @file = args[0][0] - ?a
+      @rank = (args[1].to_i - 1) if args[1]
+    when /[1-8]/                # 1, 5
+      @rank = args[0].to_i - 1
+    when nil
+      # both file and rank are nil
+    else
+      raise "don't understand Square ctor args (#{args.join(',')})"
+    end
+  end
+
+  def ==(square)
+    @file == square.file && @rank == square.rank
+  end
+
+  def on_board?
+    return @file && @rank
+  end
+
+  def to_s
+    return "<off-board>" if @file.nil? || @rank.nil?
+    return "#{@file ? (?a + file).chr : ''}#{@rank + 1}"
+  end
+
+  OFF_BOARD = Square.new
+end

data/test/mock_game_listener.rb

@@ -0,0 +1,22 @@
+class MockGameListener
+  def start_game
+  end
+
+  def end_game
+  end
+
+  def move(piece, from, to)
+  end
+
+  def capture(attacker, loser)
+  end
+
+  def check
+  end
+
+  def checkmate
+  end
+
+  def pawn_to_queen(pawn)
+  end
+end

data/test/test_piece.rb

@@ -0,0 +1,106 @@
+require 'test/unit'
+$LOAD_PATH[0, 0] = File.dirname(__FILE__)
+$LOAD_PATH[0, 0] = File.join(File.dirname(__FILE__), '..', 'lib')
+require 'bangkok/piece'
+require 'bangkok/square'
+require 'bangkok/move'
+require 'bangkok/board'
+require 'mock_game_listener'
+
+class PieceTest < Test::Unit::TestCase
+
+  def setup
+    @listener = MockGameListener.new
+    @board = Board.new(@listener)
+    @w_pawn = @board.at(Square.new('a2'))
+    @b_pawn = @board.at(Square.new('e7'))
+  end
+
+  def test_create
+    assert_instance_of(King, Piece.create(@board, @listener, :white, :K,
+                                          Square::OFF_BOARD))
+    assert_instance_of(Queen, Piece.create(@board, @listener, :white, :Q,
+                                          Square::OFF_BOARD))
+    assert_instance_of(Bishop, Piece.create(@board, @listener, :white, :B,
+                                          Square::OFF_BOARD))
+    assert_instance_of(Knight, Piece.create(@board, @listener, :white, :N,
+                                          Square::OFF_BOARD))
+    assert_instance_of(Rook, Piece.create(@board, @listener, :white, :R,
+                                          Square::OFF_BOARD))
+    assert_instance_of(Pawn, Piece.create(@board, @listener, :white, :P,
+                                          Square::OFF_BOARD))
+    assert_nil(Piece.create(@board, @listener, :white, nil, Square::OFF_BOARD))
+  end
+
+  def test_moved
+    assert(!@w_pawn.moved)
+    @w_pawn.move_to(Square.new('a4'))
+    assert(@w_pawn.moved)
+  end
+
+  def test_move_to
+    assert_equal(Square.new('a2'), @w_pawn.square)
+
+    dest = Square.new('b3')
+    @w_pawn.move_to(dest)
+    assert_equal(dest, @w_pawn.square)
+
+    dest = Square::OFF_BOARD
+    @w_pawn.move_off_board
+    assert_equal(dest, @w_pawn.square)
+  end
+
+  def test_pawn_could_move_to
+    assert(@w_pawn.could_perform_move(Move.new(:white, 'a3')))
+    assert(@w_pawn.could_perform_move(Move.new(:white, 'a4')))
+
+    diag = Move.new(:white, 'b3')
+    assert(!@w_pawn.could_perform_move(diag)) # no piece there
+
+    # put a black piece there so we can capture it
+    @board.at(Square.new('d8')).move_to(Square.new('b3'))
+    assert(@w_pawn.could_perform_move(diag)) # now we can capture it
+
+    assert(@b_pawn.could_perform_move(Move.new(:black, 'e6')))
+    assert(@b_pawn.could_perform_move(Move.new(:black, 'e5')))
+
+    diag = Move.new(:black, 'd6')
+    assert(!@b_pawn.could_perform_move(diag)) # no piece there
+
+    # put a white piece there so we can capture it
+    @board.at(Square.new('d1')).move_to(Square.new('d6'))
+    assert(@b_pawn.could_perform_move(diag)) # now we can capture it
+  end
+
+  def test_pawn_en_passant
+    # Warning: en passant is not handled yet by the code
+  end
+
+  def test_rook_could_move_to
+    rook = @board.at(Square.new('a8')) # black rook
+    assert(!rook.could_perform_move(Move.new(:black, 'Ra7')))
+    @board.at(Square.new('a7')).move_off_board # remove pawn in front
+    (3..7).each { | rank |
+      assert(rook.could_perform_move(Move.new(:black, 'Ra' + rank.to_s)))
+    }
+
+    assert_not_nil(@board.at(Square.new('a2')))
+    assert(rook.could_perform_move(Move.new(:black, 'Ra2'))) # can capture
+
+    assert_not_nil(@board.at(Square.new('a1')))
+    assert(!rook.could_perform_move(Move.new(:black, 'Ra1'))) # can't get there
+  end
+
+  def test_knight_could_move_to
+  end
+
+  def test_bishop_could_move_to
+  end
+
+  def test_queen_could_move_to
+  end
+
+  def test_king_could_move_to
+  end
+
+end