ruby-chess 0.0.0

data/lib/rook.rb

@@ -0,0 +1,56 @@
+module Rook
+
+  extend self
+  include Moves
+
+  def illegal(board,x,y)
+    possible_moves = []
+
+    7.times do |coord|
+      possible_moves += Board.board_safe(
+        horizontal(coord) + vertical(coord) 
+      )
+    end
+
+    if not(possible_moves.any? {|move| move == [x,y]})
+      raise Game::IllegalMove, "#{x},#{y} is not a possible move" 
+    elsif board.at(x,y).friend_of?(self)
+      raise Game::IllegalMove, "#{x},#{y} is occupied by a friend"
+    elsif jumped?(board,x,y) 
+      raise Game::IllegalMove, "Rooks cannot jump" 
+    else
+      :legal_move
+    end
+  end
+end
+
+class WhiteRook < WhitePiece
+
+  include Rook
+
+  attr_reader :start
+  def initialize(x,y)
+    super
+    @start = true
+  end
+
+  def to_s
+    "WR"
+  end
+end
+
+class BlackRook < BlackPiece
+
+  include Rook
+
+  attr_reader :start
+  def initialize(x,y)
+    super
+    @start = true
+  end
+
+  def to_s
+    "BR"
+  end
+end
+

data/lib/space.rb

@@ -0,0 +1,52 @@
+class EmptySpace
+
+  attr_reader :color
+  def initialize(x,y)
+    @x, @y = x, y
+    @color = :none
+  end
+
+  def place_on(board)
+    board.board[@y][@x] = self
+  end
+
+  def remove_from(board)
+    board.board[@y][@x] = EmptySpace.new(@x, @y)
+  end
+
+  def empty?
+    color == :none 
+  end
+
+  def enemy_of?(piece)
+    false
+  end
+
+  def friend_of?(piece)
+    false
+  end
+
+  def to_coord
+    [@x, @y]
+  end
+
+  def to_s
+    (@x + @y) % 2 == 0 ? "__" : "##"
+  end
+end
+
+class NullSpace < EmptySpace
+
+  attr_reader :direction 
+  def initialize
+  end
+
+  def to_coord
+    [nil, nil]
+  end
+
+  def place_on(board)
+  end
+end
+
+

data/rakefile

@@ -0,0 +1,7 @@
+require 'rake'
+
+task :run_all_tests do
+	Dir.glob('test/*.rb').each {|file| load file}
+end
+
+task default: [:run_all_tests]

data/test/bishop_test.rb

@@ -0,0 +1,63 @@
+require_relative '../lib/chess'
+
+require 'minitest/autorun'
+
+class BishopTest < Minitest::Test
+
+  def test_bishop_moves
+    board = Board.new(:empty)
+    bishop = WhiteBishop.new(4,4)
+    board.place(bishop)
+    board.move(bishop,5,5)
+    assert_equal bishop, board.at(5,5)
+  end
+
+  def test_bishop_moves_more_than_one_space 
+    board = Board.new(:empty)
+    bishop = WhiteBishop.new(4,4)
+    board.place(bishop)
+    assert_silent do 
+      board.move(bishop,3,3)
+      board.move(bishop,4,4)
+      board.move(bishop,5,5)
+      board.move(bishop,4,4)
+      board.move(bishop,7,7)
+      board.move(bishop,4,4)
+      board.move(bishop,1,1)
+      board.move(bishop,4,4)
+      board.move(bishop,5,3)
+      board.move(bishop,4,4)
+
+      board.move(bishop,3,5)
+      board.move(bishop,4,4)
+      board.move(bishop,0,0)
+      board.move(bishop,4,4)
+      board.move(bishop,1,7)
+    end
+  end
+
+  def test_bishop_cannot_move_vertically
+    board = Board.new(:empty)
+    bishop = WhiteBishop.new(4,4)
+    board.place(bishop)
+    assert_raises(Game::IllegalMove) do
+      board.move(bishop,4,0)
+    end
+  end
+
+  def test_bishop_cannot_jump
+    board = Board.new()
+    bishop = board.at(2,0) 
+    assert_raises(Game::IllegalMove) do
+      board.move(bishop,5,3)
+    end
+  end
+
+  def test_bishop_blocked_by_friend 
+    board = Board.new()
+    bishop = board.at(2,0) 
+    assert_raises(Game::IllegalMove) do
+      board.move(bishop,3,1)
+    end
+  end
+end

data/test/castle_test.rb

@@ -0,0 +1,81 @@
+require_relative '../lib/chess'
+
+require 'minitest/autorun'
+
+class CastleTest < Minitest::Test
+
+  def test_rook_moves_when_king_castles_right
+    board = Board.new(:empty)
+    king = BlackKing.new(4,7)
+    rook = BlackRook.new(7,7)
+    board.place(king)
+    board.place(rook)
+    board.move(king,6,7)
+    assert_equal rook, board.at(5,7) 
+  end
+
+  def test_rook_moves_when_king_castles_left
+    board = Board.new(:empty)
+    king = BlackKing.new(4,7)
+    rook = BlackRook.new(0,7)
+    board.place(king)
+    board.place(rook)
+    board.move(king,2,7)
+    assert_equal rook, board.at(3,7)
+  end
+
+  def test_black_king_can_move_to_castle_right
+    board = Board.new(:empty)
+    king = BlackKing.new(4,7)
+    rook = BlackRook.new(7,7)
+    board.place(king)
+    board.place(rook)
+    assert_silent do
+      board.move(king,6,7)
+    end
+  end
+
+  def test_black_king_can_move_to_castle_left
+    board = Board.new(:empty)
+    king = BlackKing.new(4,7)
+    rook = BlackRook.new(0,7)
+    board.place(king)
+    board.place(rook)
+    assert_silent do
+      board.move(king,2,7)
+    end
+  end
+
+  def test_white_king_can_move_to_castle_right
+    board = Board.new(:empty)
+    king = WhiteKing.new(3,0)
+    rook = WhiteRook.new(7,0)
+    board.place(king)
+    board.place(rook)
+    assert_silent do
+      board.move(king,5,0)
+    end
+  end
+
+  def test_white_king_can_move_to_castle_left
+    board = Board.new(:empty)
+    king = WhiteKing.new(3,0)
+    rook = WhiteRook.new(0,0)
+    board.place(king)
+    board.place(rook)
+    assert_silent do
+      board.move(king,1,0)
+    end
+  end
+
+  def test_king_cannot_jump_to_castle
+    board = Board.new(:empty)
+    king = WhiteKing.new(3,0)
+    queen = WhiteQueen.new(4,0)
+    board.place(king)
+    board.place(queen)
+    assert_raises(Game::IllegalMove) do
+      board.move(king,5,0)
+    end
+  end
+end

data/test/game_test.rb

@@ -0,0 +1,68 @@
+require_relative '../lib/chess'
+
+require 'minitest/autorun'
+require 'stringio'
+
+class GameTest < Minitest::Test
+
+  def game 
+    game = Game.new
+    white_pawn = game.at(1,1)
+    game.play([1,1],[1,3])
+    game
+  end
+
+  def white_in_check
+    game = Game.new
+    game.play([3,1],[3,3])
+    game.play([4,6],[4,5])
+    game.play([1,1],[1,3])
+    game.play([5,7],[1,3])
+    game
+  end
+
+  def test_can_play_white
+    assert_kind_of WhitePawn, game.at(1,3)
+  end
+
+  def test_can_play_black
+    this_game = game
+    this_game.play([6,6],[6,5])
+    assert_kind_of BlackPawn, this_game.at(6,5)
+  end
+
+  def test_game_can_undo_moves
+    game = white_in_check
+    2.times {game.undo}
+    assert_kind_of EmptySpace, game.at(1,3)
+  end
+
+  def test_cannot_play_while_in_check
+    game = white_in_check
+    assert_raises(Game::IllegalMove) do
+      game.play([0,1],[0,2])
+    end
+  end 
+
+  def test_cannot_move_into_check
+    game = white_in_check
+    game.play([2,1],[2,2])
+    game.play([6,6],[6,5])
+    assert_raises(Game::IllegalMove) do
+      game.play([2,2],[2,3])
+    end
+  end
+
+  def test_player_can_resign
+    out, temp = StringIO.new, $stdout
+    $stdout = out
+
+    game = white_in_check
+    game.resign
+
+    $stdout = temp
+    out.rewind
+
+    assert_match /White resigns, Black wins!/, out.read
+  end
+end

data/test/king_test.rb

@@ -0,0 +1,61 @@
+require_relative '../lib/chess'
+
+require 'minitest/autorun'
+
+class KingTest < Minitest::Test
+
+  def test_king_moves
+    board = Board.new(:empty)
+    king = WhiteKing.new(4,4)
+    board.place(king)
+    board.move(king,4,5)
+    assert_equal king, board.at(4,5)
+  end
+
+  def test_king_can_move_in_any_direction
+    board = Board.new(:empty)
+    king = WhiteKing.new(4,4)
+    board.place(king)
+    assert_silent do 
+      board.move(king,3,3)
+      board.move(king,4,4)
+      board.move(king,4,3)
+      board.move(king,4,4)
+      board.move(king,5,3)
+      board.move(king,4,4)
+
+      board.move(king,3,4)
+      board.move(king,4,4)
+      board.move(king,5,3)
+      board.move(king,4,4)
+
+      board.move(king,3,5)
+      board.move(king,4,4)
+      board.move(king,4,5)
+      board.move(king,4,4)
+      board.move(king,5,5)
+    end
+  end
+
+  def test_king_cannot_move_into_check
+    board = Board.new(:empty)
+    king = WhiteKing.new(3,0)
+    queen = BlackQueen.new(5,6)
+    board.place(king)
+    board.place(queen)
+    assert_raises(Game::IllegalMove) do
+      board.move(king,5,0)
+    end
+  end
+  
+  def test_king_cannot_move_through_check
+    board = Board.new(:empty)
+    king = WhiteKing.new(3,0)
+    queen = BlackQueen.new(4,6)
+    board.place(king)
+    board.place(queen)
+    assert_raises(Game::IllegalMove) do
+      board.move(king,5,0)
+    end
+  end
+end

data/test/knight_test.rb

@@ -0,0 +1,45 @@
+require_relative '../lib/chess'
+
+require 'minitest/autorun'
+
+class KnightTest < Minitest::Test
+
+  def test_knight_moves
+    board = Board.new(:empty)
+    knight = WhiteKnight.new(4,4)
+    board.place(knight)
+    board.move(knight,6,5)
+    assert_equal knight, board.at(6,5)
+  end
+
+  def test_knight_only_moves_in_l_shape
+    board = Board.new(:empty)
+    knight = WhiteKnight.new(4,4)
+    board.place(knight)
+    assert_raises(Game::IllegalMove) do
+      board.move(knight,6,6)
+    end
+  end
+
+  def test_knight_is_blocked_by_friend
+    board = Board.new(:empty)
+    knight = WhiteKnight.new(4,4)
+    pawn = WhitePawn.new(6,6)
+    board.place(knight)
+    board.place(pawn)
+    assert_raises(Game::IllegalMove) do
+      board.move(knight,6,6)
+    end  
+  end
+
+  def test_knight_can_capture_enemy 
+    board = Board.new(:empty)
+    knight = WhiteKnight.new(4,4)
+    pawn = BlackPawn.new(6,5)
+    board.place(knight)
+    board.place(pawn)
+    assert_silent do
+      board.move(knight,6,5)
+    end
+  end
+end

data/test/pawn_test.rb

@@ -0,0 +1,119 @@
+require_relative '../lib/chess'
+
+require 'minitest/autorun'
+
+class PawnTest < Minitest::Test
+  
+  def test_pawn_can_move_forward_one
+    board = Board.new(:empty)
+    pawn = WhitePawn.new(0,1)
+    board.place(pawn)
+    board.move(pawn,0,2)
+    assert_equal pawn, board.at(0,2)
+  end
+
+  def test_pawn_can_move_forward_two_if_at_starting_position
+    board = Board.new(:empty)
+    pawn = WhitePawn.new(0,1)
+    board.place(pawn)
+    board.move(pawn,0,3)
+    assert_equal pawn, board.at(0,3)
+  end
+
+  def test_pawn_cannot_move_forward_two_if_not_at_starting_position
+    board = Board.new(:empty)
+    pawn = WhitePawn.new(0,1)
+    board.place(pawn)
+    board.move(pawn,0,2)
+    assert_raises(Game::IllegalMove) do
+      board.move(pawn, 0,4)
+    end
+  end
+
+  def test_pawn_cannot_attack_forward
+    board = Board.new(:empty)
+    pawn = WhitePawn.new(0,1)
+    black_pawn = BlackPawn.new(0,3)
+    board.place(pawn)
+    board.place(black_pawn)
+    board.move(black_pawn,0,2)
+    assert_raises(Game::IllegalMove) do
+      board.move(pawn,0,2)
+    end
+  end
+
+  def test_pawn_can_attack_diagonally
+    board = Board.new(:empty)
+    pawn = WhitePawn.new(0,1)
+    black_pawn = BlackPawn.new(1,2)
+    board.place(pawn)
+    board.place(black_pawn)
+    board.move(pawn,1,2)
+    assert_equal pawn, board.at(1,2)
+  end
+
+  def test_pawn_cannot_move_where_a_piece_of_the_same_color_is
+    board = Board.new(:empty)
+    pawn = WhitePawn.new(0,1)
+    pawn2 = WhitePawn.new(0,2)
+    board.place(pawn)
+    board.place(pawn2)
+    assert_raises(Game::IllegalMove) do
+      board.move(pawn,0,2)
+    end
+  end
+
+  def test_pawn_cannot_jump 
+    board = Board.new(:empty)
+    pawn = WhitePawn.new(0,1)
+    black_pawn = BlackPawn.new(0,2)
+    board.place(pawn)
+    board.place(black_pawn)
+    assert_raises(Game::IllegalMove) do
+      board.move(pawn,0,3)
+    end
+  end
+
+  def test_pawn_can_capture_en_passent
+    board = Board.new(:empty)
+    pawn = WhitePawn.new(0,1)
+    pawn2 = BlackPawn.new(1,3)
+    board.place(pawn)
+    board.place(pawn2)
+    board.move(pawn,0,3)
+    board.move(pawn2,0,2)
+    assert_equal pawn2, board.at(0,2)
+  end
+
+  def test_white_pawn_can_capture_en_passent 
+    board = Board.new
+    white_pawn = board.at(3,1)
+    black_pawn = board.at(4,6)
+    board.move(white_pawn,3,3)
+    board.move(white_pawn,3,4)
+    board.move(black_pawn,4,4)
+    board.move(white_pawn,4,5)
+    assert_equal white_pawn, board.at(4,5)
+  end
+
+  def test_pawn_replaced_with_queen_when_it_reaches_the_back_row
+    board = Board.new(:empty)
+    pawn = WhitePawn.new(0,1)
+    2.upto(7) {|y| board.move(pawn,0,y)}
+    assert_kind_of WhiteQueen, board.at(0,7)
+  end
+
+  def test_does_not_raise_illegal_move_twice_if_second_move_is_legal
+    board = Board.new
+    pawn = board.at(3,1)
+    board.move(pawn,3,3)
+    begin 
+      board.move(pawn,3,5)
+    rescue Game::IllegalMove
+      :this_is_expected
+    end
+    assert_silent do 
+      board.move(pawn,3,4)
+    end
+  end
+end

data/test/queen_test.rb

@@ -0,0 +1,103 @@
+require_relative '../lib/chess'
+
+require 'minitest/autorun'
+
+class QueenTest < Minitest::Test
+
+  def test_queen_moves
+    board = Board.new(:empty)
+    queen = WhiteQueen.new(4,4)
+    board.place(queen)
+    board.move(queen,4,5)
+    assert_equal queen, board.at(4,5)
+  end
+
+  def test_queen_can_move_in_any_direction
+    board = Board.new(:empty)
+    queen = WhiteQueen.new(4,4)
+    board.place(queen)
+    assert_silent do 
+      board.move(queen,3,3)
+      board.move(queen,4,4)
+      board.move(queen,4,3)
+      board.move(queen,4,4)
+      board.move(queen,5,3)
+      board.move(queen,4,4)
+
+      board.move(queen,3,4)
+      board.move(queen,4,4)
+      board.move(queen,5,3)
+      board.move(queen,4,4)
+
+      board.move(queen,3,5)
+      board.move(queen,4,4)
+      board.move(queen,4,5)
+      board.move(queen,4,4)
+      board.move(queen,5,5)
+    end
+  end
+
+  def test_queen_can_move_in_any_direction_for_any_number_of_spaces 
+    board = Board.new(:empty)
+    queen = WhiteQueen.new(4,4)
+    board.place(queen)
+    assert_silent do 
+      board.move(queen,0,0)
+      board.move(queen,4,4)
+
+      board.move(queen,4,2)
+      board.move(queen,4,4)
+
+      board.move(queen,7,1)
+      board.move(queen,4,4)
+
+      board.move(queen,5,5)
+      board.move(queen,4,4)
+
+      board.move(queen,4,7)
+      board.move(queen,4,4)
+
+      board.move(queen,1,7)
+      board.move(queen,4,4)
+      
+      board.move(queen,2,4)
+      board.move(queen,4,4)
+
+      board.move(queen,6,4)
+    end
+  end
+
+  def test_queen_cannot_move_in_an_l
+    board = Board.new(:empty)
+    queen = WhiteQueen.new(4,4)
+    board.place(queen)
+    assert_raises(Game::IllegalMove) do
+      board.move(queen,6,5)
+    end
+  end
+
+  def test_queen_cannot_jump
+    board = Board.new(:empty)
+    queen = WhiteQueen.new(4,4)
+    pawn = BlackPawn.new(1,1)
+    board.place(queen)
+    board.place(pawn)
+    assert_raises(Game::IllegalMove) do 
+      board.move(queen,0,0)
+    end
+  end
+
+  def test_queen_can_capture_an_enemy_piece
+    board = Board.new
+    queen = BlackQueen.new(4,4)
+    # White Pawn at (1,1)
+    assert_silent {board.move(queen, 1,1)}
+  end
+
+  def test_queen_cannot_move_to_space_occupied_by_a_friend
+    board = Board.new
+    queen = BlackQueen.new(4,4)
+    # Black Pawn at (6,6)
+    assert_raises(Game::IllegalMove) {board.move(queen, 6,6)}
+  end
+end

data/test/rook_test.rb

@@ -0,0 +1,41 @@
+require_relative '../lib/chess'
+
+require 'minitest/autorun'
+
+class RookTest < Minitest::Test
+
+  def test_rook_moves
+    board = Board.new(:empty)
+    rook = WhiteRook.new(4,4)
+    board.place(rook)
+    board.move(rook,4,5)
+    assert_equal rook, board.at(4,5)
+  end
+
+  def test_rook_can_move_in_any_direction
+    board = Board.new(:empty)
+    rook = WhiteRook.new(4,4)
+    board.place(rook)
+    assert_silent do 
+      board.move(rook,4,6)
+      board.move(rook,4,4)
+      board.move(rook,6,4)
+      board.move(rook,4,4)
+
+      board.move(rook,7,4)
+      board.move(rook,4,4)
+      board.move(rook,1,4)
+      board.move(rook,4,4)
+      board.move(rook,4,0)
+    end
+  end
+
+  def test_rook_cannot_move_diagonally
+    board = Board.new(:empty)
+    rook = BlackRook.new(7,7)
+    board.place(rook)
+    assert_raises(Game::IllegalMove) do
+      board.move(rook,4,4)
+    end
+  end
+end