def test_queen_can_take_opponent():
# Arrange
board = Board.empty()
queen = Queen(Player.WHITE)
square = Square.at(4, 4)
board.set_piece(square, queen)
board.set_piece(Square.at(6, 4), Queen(Player.BLACK))
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(6, 4) in moves
def test_queen_can_move_until_blocked_by_teammate():
# Arrange
board = Board.empty()
queen = Queen(Player.WHITE)
square = Square.at(4, 4)
board.set_piece(square, queen)
board.set_piece(Square.at(6, 4), Queen(Player.WHITE))
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(6, 4) not in moves
def test_black_queen_cannot_move_if_friendly_piece_in_the_way():
# Arrange
board = Board.empty()
queen = Queen(Player.BLACK)
queen_square = Square.at(2, 2)
board.set_piece(queen_square, queen)
obstructing_square1 = Square.at(1, 1)
obstructing_square2 = Square.at(3, 3)
obstructing_square3 = Square.at(1, 3)
obstructing_square4 = Square.at(3, 1)
obstructing_square5 = Square.at(2, 1)
obstructing_square6 = Square.at(2, 3)
obstructing_square7 = Square.at(1, 2)
obstructing_square8 = Square.at(3, 2)
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)
board.set_piece(obstructing_square5, obstruction)
board.set_piece(obstructing_square6, obstruction)
board.set_piece(obstructing_square7, obstruction)
board.set_piece(obstructing_square8, obstruction)
# Act
moves = queen.get_available_moves(board)
# Assert
assert len(moves) == 0
def handle_promotion(self, moving_piece, to_square):
if isinstance(moving_piece, Pawn):
if to_square.row == 0 or to_square.row == 7:
piece = input(
"Select piece to promote pawn to: 'Q', 'K', 'R' or 'B'.")
if piece == 'Q':
self.set_piece(to_square, Queen(self.current_player))
elif piece == 'K':
self.set_piece(to_square, Knight(self.current_player))
elif piece == 'R':
self.set_piece(to_square, Rook(self.current_player))
elif piece == 'B':
self.set_piece(to_square, Bishop(self.current_player))
else:
self.set_piece(to_square, Queen(self.current_player))
return
def test_king_cannot_move_to_check_by_queen():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
king_square = Square.at(2, 3)
board.set_piece(king_square, king)
enemy = Queen(Player.BLACK)
enemy_square = Square.at(1, 2)
board.set_piece(enemy_square, enemy)
# Act
moves = king.get_available_moves(board)
# check if current square is in check?
# checked_by = king.get_checked_by(board)
# Assert
assert Square.at(1, 2) in moves
assert Square.at(2, 2) not in moves
assert Square.at(3, 2) not in moves
assert Square.at(3, 3) in moves
assert Square.at(3, 4) not in moves
assert Square.at(2, 4) in moves
assert Square.at(1, 4) not in moves
assert Square.at(1, 3) not in moves
assert len(moves) == 3
def test_queen_can_move_diagonally():
# Arrange
board = Board.empty()
queen = Queen(Player.WHITE)
square = Square.at(4, 4)
board.set_piece(square, queen)
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(6, 6) in moves
def move_piece(self, from_square, to_square):
"""
Moves the piece from the given starting square to the given destination square. Also checks for pawn promotion.
"""
moving_piece = self.get_piece(from_square)
if moving_piece is not None and moving_piece.player == self.current_player:
if isinstance(moving_piece, Pawn) and (to_square.row == 0 or to_square.row == 7):
moving_piece = Queen(self.current_player) # Pawn promotion mechanic. Automatically promotes to Queen.
self.set_piece(to_square, moving_piece)
self.set_piece(from_square, None)
self.en_passant_deletion(moving_piece, to_square)
self.set_en_passant_state(to_square, from_square, moving_piece)
self.current_player = self.current_player.opponent()
def test_queen_cannot_move_off_board():
# Arrange
board = Board.empty()
queen = Queen(Player.BLACK)
queen_square = Square.at(4, 4)
board.set_piece(queen_square, queen)
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(0, 0) in moves
assert Square.at(7, 7) in moves
assert Square.at(8, 8) not in moves
assert Square.at(-1, -1) not in moves
def test_queens_can_move_right():
# Arrange
board = Board.empty()
queen = Queen(Player.WHITE)
queen_square = Square.at(3, 4)
board.set_piece(queen_square, queen)
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(3, 5) in moves
assert Square.at(3, 6) in moves
assert Square.at(3, 7) in moves
def test_black_queen_cannot_move_off_top_of_board():
# Arrange
board = Board.empty()
queen = Queen(Player.BLACK)
square = Square.at(1, 7)
board.set_piece(square, queen)
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(2, 8) not in moves
assert Square.at(0, 8) not in moves
assert Square.at(1, 8) not in moves
def test_black_queen_can_move_vertically_and_horizontally():
# Arrange
board = Board.empty()
queen = Queen(Player.BLACK)
queen_square = Square.at(1, 3)
board.set_piece(queen_square, queen)
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(1, 4) in moves
assert Square.at(4, 3) in moves
assert Square.at(0, 3) in moves
assert Square.at(1, 1) in moves
def test_black_queen_can_move_diagonally():
# Arrange
board = Board.empty()
queen = Queen(Player.BLACK)
queen_square = Square.at(3, 3)
board.set_piece(queen_square, queen)
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(4, 4) in moves
assert Square.at(2, 2) in moves
assert Square.at(4, 2) in moves
assert Square.at(2, 4) in moves
def test_queen_can_move_on_backslash():
# Arrange
board = Board.empty()
queen = Queen(Player.BLACK)
queen_square = Square.at(4, 4)
board.set_piece(queen_square, queen)
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(3, 5) in moves
assert Square.at(2, 6) in moves
assert Square.at(5, 3) in moves
assert Square.at(6, 2) in moves
def test_queen_can_move_1_vertically():
# Arrange
board = Board.empty()
queen = Queen(Player.BLACK)
queen_square = Square.at(4, 4)
board.set_piece(queen_square, queen)
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(5, 4) in moves
assert Square.at(6, 4) in moves
assert Square.at(3, 4) in moves
assert Square.at(2, 4) in moves
def test_queen_can_move_horizontally():
# Arrange
board = Board.empty()
queen = Queen(Player.BLACK)
queen_square = Square.at(4, 4)
board.set_piece(queen_square, queen)
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(4, 5) in moves
assert Square.at(4, 6) in moves
assert Square.at(4, 3) in moves
assert Square.at(4, 2) in moves
def test_queens_can_capture_right():
# Arrange
board = Board.empty()
queen = Queen(Player.WHITE)
queen_square = Square.at(4, 4)
board.set_piece(queen_square, queen)
enemy_1 = Pawn(Player.BLACK)
enemy_1_square = Square.at(4, 6)
board.set_piece(enemy_1_square, enemy_1)
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(4, 6) in moves
def test_queens_cannot_move_left_through_pieces():
# Arrange
board = Board.empty()
queen = Queen(Player.WHITE)
queen_square = Square.at(4, 4)
board.set_piece(queen_square, queen)
enemy_1 = Pawn(Player.BLACK)
enemy_1_square = Square.at(4, 3)
board.set_piece(enemy_1_square, enemy_1)
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(4, 2) not in moves
def test_white_king_checked_by_black_queen_diagonal():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
king_square = Square.at(2, 3)
board.set_piece(king_square, king)
enemy = Queen(Player.BLACK)
enemy_square = Square.at(1, 2)
board.set_piece(enemy_square, enemy)
# Act
check = king.is_in_check(board)
# Assert
assert check is True
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 move_piece(self, from_square, to_square):
"""
Moves the piece from the given starting square to the given destination square.
"""
moving_piece = self.get_piece(from_square)
if moving_piece is not None and moving_piece.player == self.current_player:
if isinstance(moving_piece, Pawn) & (to_square.row == 0
or to_square.row == 7):
moving_piece = Queen(self.current_player)
self.handle_castling(from_square, to_square, moving_piece)
en_passant = False
if isinstance(moving_piece, Pawn):
self.handle_en_passant(from_square, to_square)
if (((to_square.row == 3) & (from_square.row == 1))
or ((to_square.row == 4) & (from_square.row == 6))):
en_passant = True
self.set_piece(to_square, moving_piece)
self.set_piece(from_square, None)
moving_piece.moved = True
self.last_move = (moving_piece, to_square, en_passant)
self.current_player = self.current_player.opponent()
def test_white_queens_can_move_to_all_possible_squares():
# Arrange
board = Board.empty()
queen = Queen(Player.WHITE)
square = Square.at(1, 4)
board.set_piece(square, queen)
# Act
moves = queen.get_available_moves(board)
# Assert
assert set(moves) == set([
Square.at(0, 3),
Square.at(0, 4),
Square.at(0, 5),
Square.at(1, 0),
Square.at(1, 1),
Square.at(1, 2),
Square.at(1, 3),
Square.at(1, 5),
Square.at(1, 6),
Square.at(1, 7),
Square.at(2, 3),
Square.at(2, 4),
Square.at(2, 5),
Square.at(3, 2),
Square.at(3, 4),
Square.at(3, 6),
Square.at(4, 1),
Square.at(4, 4),
Square.at(4, 7),
Square.at(5, 0),
Square.at(5, 4),
Square.at(6, 4),
Square.at(7, 4)
])
def test_white_queens_can_move_to_all_unoccupied_squares():
# Arrange
board = Board.empty()
queen = Queen(Player.WHITE)
square = Square.at(1, 4)
board.set_piece(square, queen)
team1 = Pawn(Player.WHITE)
team1_square = Square.at(2, 5)
board.set_piece(team1_square, team1)
enemy1 = Pawn(Player.BLACK)
enemy1_square = Square.at(3, 4)
board.set_piece(enemy1_square, enemy1)
# Act
moves = queen.get_available_moves(board)
# Assert
assert set(moves) == set([
Square.at(0, 3),
Square.at(0, 4),
Square.at(0, 5),
Square.at(1, 0),
Square.at(1, 1),
Square.at(1, 2),
Square.at(1, 3),
Square.at(1, 5),
Square.at(1, 6),
Square.at(1, 7),
Square.at(2, 3),
Square.at(2, 4),
Square.at(3, 2),
Square.at(3, 4),
Square.at(4, 1),
Square.at(5, 0)
])
def test_white_king_not_in_check():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
king_square = Square.at(2, 3)
board.set_piece(king_square, king)
enemy_pawn = Pawn(Player.BLACK)
enemy_pawn_square = Square.at(3, 3)
board.set_piece(enemy_pawn_square, enemy_pawn)
enemy_rook = Rook(Player.BLACK)
enemy_rook_square = Square.at(3, 4)
board.set_piece(enemy_rook_square, enemy_rook)
enemy_bishop = Bishop(Player.BLACK)
enemy_bishop_square = Square.at(1, 3)
board.set_piece(enemy_bishop_square, enemy_bishop)
enemy_knight = Knight(Player.BLACK)
enemy_knight_square = Square.at(7, 7)
board.set_piece(enemy_knight_square, enemy_knight)
enemy_queen = Queen(Player.BLACK)
enemy_queen_square = Square.at(3, 0)
board.set_piece(enemy_queen_square, enemy_queen)
enemy_king = King(Player.BLACK)
enemy_king_square = Square.at(6, 6)
board.set_piece(enemy_king_square, enemy_king)
# Act
check = king.is_in_check(board)
# Assert
assert check is False
def test_queens_cannot_move_off_the_board():
# Arrange
board = Board.empty()
queen = Queen(Player.WHITE)
queen_square = Square.at(0, 0)
board.set_piece(queen_square, queen)
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)
friendly_3 = Pawn(Player.WHITE)
friendly_3_square = Square.at(1, 1)
board.set_piece(friendly_3_square, friendly_3)
# Act
moves = queen.get_available_moves(board)
# Assert
assert len(moves) == 0
def pawn_promotion_check(self, to_square):
piece_to_promote = self.get_piece(to_square)
if isinstance(piece_to_promote, Pawn):
if piece_to_promote.edge_check_row(to_square):
self.set_piece(to_square, Queen(self.current_player))
def promotePawn(self, square):
player = self.current_player
new_piece = Queen(player)
self.set_piece(square, new_piece)
def promote_pawn(self):
last_move = self.move_list[-1]
if last_move.is_pawn_promotion():
self.set_piece(last_move.square_to, Queen(self.current_player))