def test_black_pawns_can_capture_diagonally():
# Arrange
board = Board.empty()
pawn = Pawn(Player.BLACK)
pawn_square = Square.at(3, 4)
board.set_piece(pawn_square, pawn)
friendly = Pawn(Player.BLACK)
friendly_square = Square.at(2, 5)
board.set_piece(friendly_square, friendly)
# Act
moves = pawn.get_available_moves(board)
# Assert
assert Square.at(2, 3) not in moves
assert Square.at(2, 5) not in moves
def test_white_rook_can_capture():
# Arrange
board = Board.empty()
rook = Rook(Player.WHITE)
square = Square.at(4, 4)
board.set_piece(square, rook)
obstructing_square = Square.at(5, 4)
obstruction = Pawn(Player.BLACK)
board.set_piece(obstructing_square, obstruction)
# Act
moves = rook.get_available_moves(board)
# Assert
assert Square.at(5, 4) in moves
assert Square.at(6, 4) not in moves
def test_bishop_is_blocked_by_friendly_pieces():
# Arrange
board = Board.empty()
bishop = Bishop(Player.WHITE)
square = Square.at(3, 5)
board.set_piece(square, bishop)
friendly = Pawn(Player.WHITE)
friendly_square = Square.at(5, 3)
board.set_piece(friendly_square, friendly)
# Act
moves = bishop.get_available_moves(board)
# Assert
assert Square.at(6, 2) not in moves
assert Square.at(7, 7) not in moves
def test_black_pawn_cannot_move_if_piece_in_front():
# Arrange
board = Board.empty()
pawn = Pawn(Player.BLACK)
pawn_square = Square.at(4, 4)
board.set_piece(pawn_square, pawn)
obstructing_square = Square.at(3, 4)
obstruction = Pawn(Player.WHITE)
board.set_piece(obstructing_square, obstruction)
# Act
moves = pawn.get_available_moves(board)
# Assert
assert len(moves) == 0
def test_white_pawns_cannot_move_diagonally_except_to_capture():
# Arrange
board = Board.empty()
pawn = Pawn(Player.WHITE)
pawn_square = Square.at(3, 4)
board.set_piece(pawn_square, pawn)
friendly = Pawn(Player.WHITE)
friendly_square = Square.at(4, 5)
board.set_piece(friendly_square, friendly)
# Act
moves = pawn.get_available_moves(board)
# Assert
assert Square.at(4, 3) not in moves
assert Square.at(4, 5) not in moves
def test_white_pawn_cannot_move_two_squares_if_piece_two_in_front():
# Arrange
board = Board.empty()
pawn = Pawn(Player.WHITE)
pawn_square = Square.at(4, 4)
board.set_piece(pawn_square, pawn)
obstructing_square = Square.at(6, 4)
obstruction = Pawn(Player.BLACK)
board.set_piece(obstructing_square, obstruction)
# Act
moves = pawn.get_available_moves(board)
# Assert
assert obstructing_square not in moves
def test_white_king_checked_by_black_knight():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
king_square = Square.at(2, 3)
board.set_piece(king_square, king)
enemy = Knight(Player.BLACK)
enemy_square = Square.at(1, 1)
board.set_piece(enemy_square, enemy)
# Act
# check if current square is in check?
check = king.is_in_check(board)
# Assert
assert check is True
def test_white_rook_can_take_piece_if_black_piece_in_front():
# Arrange
board = Board.empty()
rook = Rook(Player.WHITE)
rook_square = Square.at(0, 0)
board.set_piece(rook_square, rook)
obstructing_square = Square.at(1, 0)
obstruction = Pawn(Player.BLACK)
board.set_piece(obstructing_square, obstruction)
# Act
moves = rook.get_available_moves(board)
# Assert
assert Square.at(1, 0) in moves
assert Square.at(2, 0) not in moves
def test_black_knights_can_move_in_l_shape():
# Arrange
board = Board.empty()
knight = Knight(Player.BLACK)
square = Square.at(3, 3)
board.set_piece(square, knight)
# Act
moves = knight.get_available_moves(board)
# Assert
assert Square.at(4, 5) in moves
assert Square.at(4, 1) in moves
assert Square.at(5, 4) in moves
assert Square.at(5, 2) in moves
assert Square.at(2, 5) in moves
assert Square.at(2, 1) in moves
assert Square.at(1, 4) in moves
assert Square.at(1, 2) in moves
def test_black_king_can_castle():
# Arrange
board = Board.empty()
king = King(Player.BLACK)
square = Square.at(7, 4)
board.set_piece(square, king)
rook1 = Rook(Player.BLACK)
board.set_piece(Square.at(7, 0), rook1)
rook2 = Rook(Player.BLACK)
board.set_piece(Square.at(7, 7), rook2)
# Act
moves = king.get_available_moves(board)
# Assert
assert Square.at(7, 2) in moves
assert Square.at(7, 6) in moves
def play_game():
psg.ChangeLookAndFeel('GreenTan')
board = Board.at_starting_position()
board_layout = render_board(board)
window = psg.Window('Chessington',
default_button_element_size=(12, 1),
auto_size_buttons=False).Layout(board_layout)
from_square = None
to_squares = []
def handle_click(row, col):
nonlocal window, board, from_square, to_squares
clicked_piece = board.get_piece(Square.at(row, col))
# If making an allowed move, then make it
if from_square is not None and any(s.row == row and s.col == col
for s in to_squares):
board.get_piece(from_square).move_to(board, Square.at(row, col))
from_square, to_squares = None, []
# If clicking on a piece whose turn it is, get its allowed moves
elif clicked_piece is not None and clicked_piece.player == board.current_player:
from_square = Square.at(row, col)
to_squares = clicked_piece.get_available_moves(board)
# Otherwise reset everything to default
else:
from_square, to_squares = None, []
while True:
# Check for a square being clicked on and react appropriately
button, _ = window.Read()
if button is not None:
handle_click(*button)
# Update the UI
highlight_squares(window, from_square, to_squares)
update_pieces(window, board)
def test_black_pawn_can_be_captured_by_en_pessant():
# Arrange
board = Board.empty()
pawn1 = Pawn(Player.BLACK) # MAKE BLACK PAWN
starting_square1 = Square.at(6, 4)
board.set_piece(starting_square1, pawn1)
pawn2 = Pawn(Player.WHITE) # MAKE WHITE PAWN
starting_square2 = Square.at(4, 3)
board.set_piece(starting_square2, pawn2)
intermediate_square = Square.at(4, 4) # move black pawn
pawn1.move_to(board, intermediate_square)
# Act
moves = pawn2.get_available_moves(board)
# Assert
assert Square.at(5, 4) in moves
def test_rooks_cannot_move_off_the_board():
# Arrange
board = Board.empty()
rook = Rook(Player.WHITE)
rook_square = Square.at(0, 0)
board.set_piece(rook_square, rook)
friendly_1 = Pawn(Player.WHITE)
friendly_1_square = Square.at(1, 0)
board.set_piece(friendly_1_square, friendly_1)
friendly_2 = Pawn(Player.WHITE)
friendly_2_square = Square.at(0, 1)
board.set_piece(friendly_2_square, friendly_2)
# Act
moves = rook.get_available_moves(board)
# Assert
assert len(moves) == 0
def test_knights_cannot_move_off_board():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
knight_square = Square.at(0, 0)
board.set_piece(knight_square, knight)
friendly_1 = Pawn(Player.WHITE)
friendly_1_square = Square.at(2, 1)
board.set_piece(friendly_1_square, friendly_1)
friendly_2 = Pawn(Player.WHITE)
friendly_2_square = Square.at(1, 2)
board.set_piece(friendly_2_square, friendly_2)
# Act
moves = knight.get_available_moves(board)
# Assert
assert len(moves) == 0
def test_white_knights_can_move_to_all_possible_squares():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
square = Square.at(1, 4)
board.set_piece(square, knight)
# Act
moves = knight.get_available_moves(board)
# Assert
assert set(moves) == set([
Square.at(0, 6),
Square.at(0, 2),
Square.at(2, 6),
Square.at(2, 2),
Square.at(3, 3),
Square.at(3, 5)
])
def test_white_kings_can_move_to_unoccupied_neighbouring_squares_inside_board(
):
# Arrange
board = Board.empty()
king = King(Player.WHITE)
square = Square.at(7, 0)
board.set_piece(square, king)
enemy1 = Pawn(Player.BLACK)
enemy1_square = Square.at(6, 0)
board.set_piece(enemy1_square, enemy1)
enemy2 = Pawn(Player.WHITE)
enemy2_square = Square.at(6, 1)
board.set_piece(enemy2_square, enemy2)
# Act
moves = king.get_available_moves(board)
# Assert
assert set(moves) == set([Square.at(6, 0), Square.at(7, 1)])
def test_rook_cannot_move_if_piece_in_front():
# Arrange
board = Board.empty()
rook = Rook(Player.WHITE)
rook_square = Square.at(4, 4)
board.set_piece(rook_square, rook)
enemy = Pawn(Player.BLACK)
enemy_square = Square.at(5, 4)
board.set_piece(enemy_square, enemy)
# Act
moves = rook.get_available_moves(board)
# Assert
print(moves)
assert Square.at(5, 4) in moves
assert Square.at(6, 4) not in moves
assert Square.at(7, 4) not in moves
assert Square.at(2, 4) in moves
def testKnightMovementShape():
board = Board.empty()
knight = Knight(Player.WHITE)
square = Square.at(3, 5)
board.set_piece(square, knight)
moves = knight.get_available_moves(board)
expected_moves = [
Square.at(4, 7),
Square.at(4, 3),
Square.at(5, 6),
Square.at(5, 4),
Square.at(2, 7),
Square.at(2, 3),
Square.at(1, 6),
Square.at(1, 4)
]
assert len(moves) == len(expected_moves)
assert set(moves) == set(expected_moves)
def test_white_king_can_move_up_one_square():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
square = Square.at(4, 4)
board.set_piece(square, king)
# Act
moves = king.get_available_moves(board)
# Assert
assert Square.at(3, 3) in moves
assert Square.at(3, 4) in moves
assert Square.at(3, 5) in moves
assert Square.at(4, 3) in moves
assert Square.at(4, 5) in moves
assert Square.at(5, 3) in moves
assert Square.at(5, 4) in moves
assert Square.at(5, 5) in moves
def test_king_cannot_move_off_the_left_of_board():
# Arrange
board = Board.empty()
king = King(Player.BLACK)
square = Square.at(4,0)
board.set_piece(square, king)
# Act
moves = king.get_available_moves(board)
# Assert
assert Square.at(3, 1) in moves
assert Square.at(4, 1) in moves
assert Square.at(5, 1) in moves
assert Square.at(3, 0) in moves
assert Square.at(5, 0) in moves
assert Square.at(3, -1) not in moves
assert Square.at(4, -1) not in moves
assert Square.at(5, -1) not in moves
def test_king_cannot_move_off_the_right_of_board():
# Arrange
board = Board.empty()
king = King(Player.BLACK)
square = Square.at(4,7)
board.set_piece(square, king)
# Act
moves = king.get_available_moves(board)
# Assert
assert Square.at(3, 6) in moves
assert Square.at(4, 6) in moves
assert Square.at(5, 6) in moves
assert Square.at(3, 7) in moves
assert Square.at(5, 7) in moves
assert Square.at(3, 8) not in moves
assert Square.at(4, 8) not in moves
assert Square.at(5, 8) not in moves
def test_king_cannot_move_off_the_bottom_of_board():
# Arrange
board = Board.empty()
king = King(Player.BLACK)
square = Square.at(0,4)
board.set_piece(square, king)
# Act
moves = king.get_available_moves(board)
# Assert
assert Square.at(1, 3) in moves
assert Square.at(1, 4) in moves
assert Square.at(1, 5) in moves
assert Square.at(0, 3) in moves
assert Square.at(0, 5) in moves
assert Square.at(-1, 3) not in moves
assert Square.at(-1, 4) not in moves
assert Square.at(-1, 5) not in moves
def test_pawn_can_en_passant():
# Arrange
board = Board.empty()
pawn1 = Pawn(Player.WHITE)
pawn1_square = Square.at(1, 4)
board.set_piece(pawn1_square, pawn1)
pawn1_to_square = Square.at(3, 4)
pawn2 = Pawn(Player.BLACK)
pawn2_square = Square.at(3, 5)
board.set_piece(pawn2_square, pawn2)
# Act
board.move_piece(pawn1_square, pawn1_to_square)
moves = pawn2.get_available_moves(board)
# Assert
assert Square.at(2, 4) in moves
assert Square.at(2, 5) in moves
assert Square.at(2, 6) not in moves
def test_queen_cannot_move_if_piece_in_front():
# Arrange
board = Board.empty()
queen = Queen(Player.WHITE)
queen_square = Square.at(4, 4)
board.set_piece(queen_square, queen)
enemy = Pawn(Player.BLACK)
enemy_square = Square.at(5, 5)
board.set_piece(enemy_square, enemy)
# Act
moves = queen.get_available_moves(board)
# Assert
print(moves)
assert Square.at(5, 5) in moves
assert Square.at(6, 6) not in moves
assert Square.at(7, 7) not in moves
assert Square.at(2, 2) in moves
def test_bishop_cannot_move_if_piece_in_front():
# Arrange
board = Board.empty()
bishop = Bishop(Player.WHITE)
bishop_square = Square.at(4, 4)
board.set_piece(bishop_square, bishop)
enemy = Pawn(Player.BLACK)
enemy_square = Square.at(5, 5)
board.set_piece(enemy_square, enemy)
# Act
moves = bishop.get_available_moves(board)
# Assert
print(moves)
assert Square.at(5, 5) in moves
assert Square.at(6, 6) not in moves
assert Square.at(7, 7) not in moves
assert Square.at(2, 2) in moves
def test_kings_can_capture():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
king_square = Square.at(4, 4)
board.set_piece(king_square, king)
enemy_1 = Pawn(Player.BLACK)
enemy_1_square = Square.at(4, 3)
board.set_piece(enemy_1_square, enemy_1)
enemy_2 = Pawn(Player.BLACK)
enemy_2_square = Square.at(3, 4)
board.set_piece(enemy_2_square, enemy_2)
# Act
moves = king.get_available_moves(board)
# Assert
assert Square.at(4, 3) in moves
assert Square.at(3, 4) in moves
def test_black_pawns_can_capture_diagonally():
# Arrange
board = Board.empty()
pawn = Pawn(Player.BLACK)
pawn_square = Square.at(3, 4)
board.set_piece(pawn_square, pawn)
enemy1 = Pawn(Player.WHITE)
enemy1_square = Square.at(2, 5)
board.set_piece(enemy1_square, enemy1)
enemy2 = Pawn(Player.WHITE)
enemy2_square = Square.at(2, 3)
board.set_piece(enemy2_square, enemy2)
# Act
moves = pawn.get_available_moves(board)
# Assert
assert enemy1_square in moves
assert enemy2_square in moves
def test_king_can_castle():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
king_square = Square.at(0, 4)
board.set_piece(king_square, king)
friend1 = Rook(Player.WHITE)
friend_square1 = Square.at(0, 7)
board.set_piece(friend_square1, friend1)
friend2 = Rook(Player.WHITE)
friend_square2 = Square.at(0, 0)
board.set_piece(friend_square2, friend2)
# Act
moves = king.get_available_moves(board)
# Assert
assert Square.at(0, 2) in moves
assert Square.at(0, 6) in moves
def test_white_kings_can_move_to_all_neighbouring_squares():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
square = Square.at(1, 4)
board.set_piece(square, king)
# Act
moves = king.get_available_moves(board)
# Assert
assert set(moves) == set([
Square.at(1, 5),
Square.at(1, 3),
Square.at(2, 5),
Square.at(2, 3),
Square.at(2, 4),
Square.at(0, 5),
Square.at(0, 3),
Square.at(0, 4)
])
def test_black_bishop_cannot_move_if_friendly_piece_in_the_way():
# Arrange
board = Board.empty()
bishop = Bishop(Player.BLACK)
bishop_square = Square.at(2, 2)
board.set_piece(bishop_square, bishop)
obstructing_square1 = Square.at(1, 1)
obstructing_square2 = Square.at(3, 3)
obstructing_square3 = Square.at(1, 3)
obstructing_square4 = Square.at(3, 1)
obstruction = Pawn(Player.BLACK)
board.set_piece(obstructing_square1, obstruction)
board.set_piece(obstructing_square2, obstruction)
board.set_piece(obstructing_square3, obstruction)
board.set_piece(obstructing_square4, obstruction)
# Act
moves = bishop.get_available_moves(board)
# Assert
assert len(moves) == 0
