def test_white_pawn_cannot_move_if_piece_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(5, 4) obstruction = Pawn(Player.BLACK) board.set_piece(obstructing_square, obstruction) # Act moves = pawn.get_available_moves(board) # Assert assert len(moves) == 0
def test_king_cannot_move_if_piece_in_front(): # Arrange board = Board.empty() king = King(Player.WHITE) king_square = Square.at(4, 4) board.set_piece(king_square, king) friend = Pawn(Player.WHITE) friend_square = Square.at(5, 5) board.set_piece(friend_square, friend) friend2 = Pawn(Player.WHITE) friendly_square2 = Square.at(3, 4) board.set_piece(friendly_square2, friend2) enemy = Pawn(Player.BLACK) enemy_square = Square.at(5, 4) board.set_piece(enemy_square, enemy) # Act moves = king.get_available_moves(board) # Assert print(moves) assert Square.at(5, 5) not in moves assert Square.at(3, 4) not in moves assert Square.at(5, 4) in moves
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 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 everthing to default else: from_square, to_squares = None, []
def get_lateral(self, squarelist, square, board, is_king=False): config = [(square.row + 1, BOARD_MAX + 1, 1, True), (square.row - 1, BOARD_MIN - 1, -1, True), (square.col + 1, BOARD_MAX + 1, 1, False), (square.col - 1, BOARD_MIN - 1, -1, False)] for c in config: for n in range(c[0], c[1], c[2]): obstruction = self.maybe_add_square( squarelist=squarelist, square=Square.at(n, square.col) if c[3] else Square.at( square.row, n), board=board, empty=True, takeable=True) if obstruction or is_king: break
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_king_checked_by_black_rook(): # Arrange board = Board.empty() king = King(Player.WHITE) king_square = Square.at(2, 3) board.set_piece(king_square, king) enemy = Rook(Player.BLACK) enemy_square = Square.at(2, 2) 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 find_piece(self, piece_to_find): """ Searches for the given piece on the board and returns its square. """ for row in range(BOARD_SIZE): for col in range(BOARD_SIZE): if self.board[row][col] is piece_to_find: return Square.at(row, col) raise Exception('The supplied piece is not on the board')
def get_available_moves(self, board): moves = [] current_square = board.find_piece(self) for vertical,horizontal in [(1,1),(1,-1),(-1,1),(-1,-1)]: for i in range(1,8): if inBounds(current_square.row+(vertical*i)) and inBounds(current_square.col+(horizontal*i)): square = Square.at(current_square.row+(vertical*i),current_square.col+(horizontal*i)) piece = board.get_piece(square) if piece == None: moves.append(square) elif piece.player != self.player: moves.append(square) break else: break for direction in [1,-1]: if direction == 1: max = 8 else: max = -1 for vertical in range(current_square.row+direction,max,direction): square = Square.at(vertical,current_square.col) piece = board.get_piece(square) if piece == None: moves.append(square) elif piece.player != self.player: moves.append(square) break else: break for horizontal in range(current_square.col+direction,max,direction): square = Square.at(current_square.row,horizontal) piece = board.get_piece(square) if piece == None: moves.append(square) elif piece.player != self.player: moves.append(square) break else: break return moves
def prawn_capture(self, board, current_square, valid_moves, row_direction, col_direction): next_square = Square.at(current_square.row + row_direction, current_square.col + col_direction) if board.does_square_exist( next_square) and not board.is_square_empty(next_square): check_piece = board.get_piece(next_square) board.check_for_capture(self, check_piece, valid_moves, next_square) return valid_moves
def test_new_board_has_white_pieces_at_bottom(): # Arrange board = Board.at_starting_position() # Act piece = board.get_piece(Square.at(0, 0)) # Assert assert piece.player == Player.WHITE
def get_available_moves(self, board): positionDelta = 0 currentLoc = board.find_piece(self) if self.player == Player.WHITE: positionDelta = 1 else: positionDelta = -1 single_move = Square.at(currentLoc.row + positionDelta, currentLoc.col) double_move = Square.at(currentLoc.row + positionDelta * 2, currentLoc.col) diagonal_move_1 = Square.at(currentLoc.row + positionDelta, currentLoc.col + positionDelta) diagonal_move_2 = Square.at(currentLoc.row + positionDelta, currentLoc.col - positionDelta) # Standard Forward moves moves = [] if board.squareInBounds(single_move) and board.squareInBounds( double_move): if board.get_piece(single_move) is None: moves.append(single_move) if (board.get_piece(double_move) is None) and not self.moved: moves.append(double_move) capturingMoves = [] if board.squareInBounds(diagonal_move_1) and board.squareInBounds( diagonal_move_2): piece1 = board.get_piece(diagonal_move_1) piece2 = board.get_piece(diagonal_move_2) if piece1 is not None and piece1.player != self.player: capturingMoves.append(diagonal_move_1) if piece2 is not None and piece2.player != self.player: capturingMoves.append(diagonal_move_2) return moves + capturingMoves
def check_en_passant(self, board, candidate_square, direction): moves = [] if board.last_move is not None: if candidate_square.is_on_board(): if board.get_piece(candidate_square) == board.last_move[0]: if board.last_move[2]: moves.append( Square.at(candidate_square.row + direction, candidate_square.col)) return moves
def test_new_board_has_black_pieces_at_top(): # Arrange board = Board.at_starting_position() # Act piece = board.get_piece(Square.at(7, 0)) # Assert assert piece.player == Player.BLACK
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 get_base_moves(self, board): base_moves = [] square = board.find_piece(self) base_moves.append(Square.at(square.row - 1, square.col - 1)) base_moves.append(Square.at(square.row - 1, square.col - 0)) base_moves.append(Square.at(square.row - 1, square.col + 1)) base_moves.append(Square.at(square.row - 0, square.col - 1)) base_moves.append(Square.at(square.row - 0, square.col + 1)) base_moves.append(Square.at(square.row + 1, square.col - 1)) base_moves.append(Square.at(square.row + 1, square.col - 0)) base_moves.append(Square.at(square.row + 1, square.col + 1)) return base_moves
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_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 get_enemy_locations(self, board): """ Get all squares containing enemy pieces """ enemy_pieces_squares = [] for square_row in range(8): for square_col in range(8): selected_square = Square.at(square_row, square_col) if self.check_enemy_piece(board, selected_square): enemy_pieces_squares.append(selected_square) return enemy_pieces_squares
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 get_available_moves(self, board): moves = [] white = self.player == Player.WHITE pos = board.find_piece(self) # in front self.maybe_add_square(squarelist=moves, square=Square.at( pos.row + 1 if white else pos.row - 1, pos.col), board=board, empty=True, takeable=False) if len(moves) == 1 and (not self.moved): self.maybe_add_square(squarelist=moves, square=Square.at( pos.row + 2 if white else pos.row - 2, pos.col), board=board, empty=True, takeable=False) # diagonal self.maybe_add_square(squarelist=moves, square=Square.at( pos.row + 1 if white else pos.row - 1, pos.col - 1), board=board, empty=False, takeable=True) self.maybe_add_square(squarelist=moves, square=Square.at( pos.row + 1 if white else pos.row - 1, pos.col + 1), board=board, empty=False, takeable=True) return 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_black_pawn_cannot_move_at_bottom_of_board(): # Arrange board = Board.empty() pawn = Pawn(Player.BLACK) square = Square.at(0, 4) board.set_piece(square, pawn) # Act moves = pawn.get_available_moves(board) # Assert assert len(moves) == 0
def test_white_pawn_cannot_move_at_top_of_board(): # Arrange board = Board.empty() pawn = Pawn(Player.WHITE) square = Square.at(7, 4) board.set_piece(square, pawn) # Act moves = pawn.get_available_moves(board) # Assert assert len(moves) == 0
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_black_pawn_changes_to_queen_when_moved_to_top_of_board(): # Arrange board = Board.empty() pawn = Pawn(Player.BLACK) square = Square.at(1, 4) board.set_piece(square, pawn) # Act moves = pawn.get_available_moves(board) # Assert assert len(moves) == 1
def get_available_moves(self, board): current_square = board.find_piece(self) row = current_square.row col = current_square.col available_moves = [] x = [-2, -2, -1, -1, 1, 1, 2, 2] y = [1, -1, 2, -2, 2, -2, -1, 1] for i in range(0, len(x)): sq = Square.at(row + x[i], col + y[i]) if self.can_move(sq, board): available_moves.append(sq) return available_moves
def get_available_moves(self, board): current_square = board.find_piece(self) row = current_square.row col = current_square.col available_moves = [] row_dir = 1 if self.player == Player.WHITE else -1 sq = Square.at(row + row_dir, col) if self.inside_board(sq, board) and board.get_piece(sq) == None: available_moves.append(sq) sq = Square.at(row + row_dir, col + 1) if self.inside_board(sq, board) and self.is_enemy(sq, board): available_moves.append(sq) sq = Square.at(row + row_dir, col - 1) if self.inside_board(sq, board) and self.is_enemy(sq, board): available_moves.append(sq) if self.has_moved == False: sq = Square.at(row + 2 * row_dir, col) if self.inside_board(sq, board) and board.get_piece(sq) == None: available_moves.append(sq) return available_moves
def get_available_moves(self, board): current_square = board.find_piece(self) row = current_square.row col = current_square.col available_moves = [] change = [-1, 0, 1] for row_change in change: for col_change in change: sq = Square.at(row + row_change, col + col_change) if self.can_move(sq, board): available_moves.append(sq) return available_moves