def test_find_shortest_path(self): # test king with obstacles board = generate_board({(1, 4), (0, 4), (2, 4)}) start_loc = (1, 2) end_loc = (1, 5) path = find_shortest_path(board, start_loc, end_loc, chess.KING) self.assertEqual(len(path), 5) self.assertEqual(path[0], start_loc) self.assertEqual(path[-1], end_loc) self.assertIn(path[1], generate_possible_moves(board, path[0], chess.KING)) self.assertIn(path[2], generate_possible_moves(board, path[1], chess.KING)) self.assertIn(path[3], generate_possible_moves(board, path[2], chess.KING)) # test bishop with obstacles board = generate_board({(4, 1), (3, 2), (2, 1)}) start_loc = (2, 1) end_loc = (5, 2) path = find_shortest_path(board, start_loc, end_loc, chess.BISHOP) self.assertEqual(len(path), 4) self.assertEqual(path[0], start_loc) self.assertEqual(path[-1], end_loc) self.assertIn(path[1], generate_possible_moves(board, path[0], chess.BISHOP)) self.assertIn(path[2], generate_possible_moves(board, path[1], chess.BISHOP)) # test knight with obstacles board = generate_board({(2, 2), (2, 3), (3, 3), (3, 2), (3, 4), (4, 4)}) start_loc = (4, 1) end_loc = (2, 5) path = find_shortest_path(board, start_loc, end_loc, chess.KNIGHT) self.assertEqual(len(path), 5) self.assertEqual(path[0], start_loc) self.assertEqual(path[-1], end_loc) self.assertIn(path[1], generate_possible_moves(board, path[0], chess.KNIGHT)) self.assertIn(path[2], generate_possible_moves(board, path[1], chess.KNIGHT)) self.assertIn(path[3], generate_possible_moves(board, path[2], chess.KNIGHT)) # test rook with obstacles board = generate_board({(2, 3), (4, 4), (4, 5), (4, 6), (5, 3), (6, 4)}) start_loc = (2, 1) end_loc = (5, 4) path = find_shortest_path(board, start_loc, end_loc, chess.ROOK) self.assertEqual(len(path), 5) self.assertEqual(path[0], start_loc) self.assertEqual(path[-1], end_loc) self.assertIn(path[1], generate_possible_moves(board, path[0], chess.ROOK)) self.assertIn(path[2], generate_possible_moves(board, path[1], chess.ROOK)) self.assertIn(path[3], generate_possible_moves(board, path[2], chess.ROOK))
def test_generate_board(self): # empty board board = generate_board([]) for row in board: for char in row: self.assertEqual(chess.EMPTY_CHAR, char) # board with occupied spots, both in and out of bounds occupied_spots = {(2, 3), (1, 1), (1, 1), (7, 3), (9, 12), (-1, 2)} board = generate_board(occupied_spots) for row in range(chess.NUM_ROWS): for col in range(chess.NUM_COLS): if (row, col) in occupied_spots: self.assertEqual(chess.OCCUPIED_CHAR, board[row][col]) else: self.assertEqual(chess.EMPTY_CHAR, board[row][col]) # board with all spots occupied occupied_spots = {(row, col) for row in range(chess.NUM_ROWS) for col in range(chess.NUM_COLS)} board = generate_board(occupied_spots) for row in range(chess.NUM_ROWS): for col in range(chess.NUM_COLS): self.assertEqual(chess.OCCUPIED_CHAR, board[row][col])
def test_keep_valid_moves(self): # test all valid board = generate_board({(6, 3)}) moves = {(1, 1), (2, 3), (4, 2)} result = keep_valid_moves(board, moves) self.assertEqual(moves, set(result)) # test empty board = generate_board({}) moves = set() result = keep_valid_moves(board, moves) self.assertEqual(set(), result) # test remove out of bounds board = generate_board({(6, 3)}) moves = {(1, 1), (2, -3), (14, 2)} result = keep_valid_moves(board, moves) self.assertEqual({(1, 1)}, result) # test occupied board = generate_board({(6, 3), (2, 3)}) moves = {(1, 1), (2, 3), (4, 2)} result = keep_valid_moves(board, moves) self.assertEqual({(1, 1), (4, 2)}, result) # test out of bounds and occupied board = generate_board({(6, 3)}) moves = {(1, -1), (2, 3), (4, 12)} result = keep_valid_moves(board, moves) self.assertEqual({(2, 3)}, result)
def test_is_occupied_spot(self): # test occupied board = generate_board({(3, 3), (0, 0)}) cur_loc = (3, 3) result = is_occupied_spot(board, cur_loc) self.assertTrue(result) # test not occupied board = generate_board({(1, 2), (3, 4)}) cur_loc = (3, 3) result = is_occupied_spot(board, cur_loc) self.assertFalse(result) # test out of bounds board = generate_board({}) cur_loc = (-3, 3) result = is_occupied_spot(board, cur_loc) self.assertIsNone(result)
def main(): # Example 1 - King Min Moves chess_piece = chess.KING board = chess.generate_board({}) start_location = (3, 3) end_location = (5, 1) min_num_moves = find_min_moves(board, start_location, end_location, chess_piece) if min_num_moves is None: print( "A {} cannot reach location {} from location {}.".format( chess_piece), end_location, start_location) else: print( "A {} can move from location {} to {} in {} moves minimum.".format( chess_piece, start_location, end_location, min_num_moves)) print() # Example 2 - Knight Path chess_piece = chess.KNIGHT board = chess.generate_board({(2, 2), (2, 3), (3, 3), (3, 2), (3, 4), (4, 4)}) start_location = (4, 1) end_location = (2, 5) path = chess.find_shortest_path(board, start_location, end_location, chess_piece) if path is None: print( "A {} cannot reach location {} from location {}.".format( chess_piece), end_location, start_location) else: print( "A {} can move from location {} to {} in {} moves minimum.".format( chess_piece, start_location, end_location, len(path) - 1)) print("One possible shortest path:", path) # Add some markings to the board to show path, and print board for move in path: board[move[0]][move[1]] = '-' board[start_location[0]][start_location[1]] = 'S' board[end_location[0]][end_location[1]] = 'E' chess.print_board(board) print() # Example 3 - Bishop Unreachable chess_piece = chess.BISHOP board = chess.generate_board({}) start_location = (1, 1) end_location = (0, 3) path = chess.find_shortest_path(board, start_location, end_location, chess_piece) if path is None: print("A {} cannot reach location {} from location {}.".format( chess_piece, end_location, start_location)) else: print( "A {} can move from location {} to {} in {} moves minimum.".format( chess_piece, start_location, end_location, len(path) - 1)) print("One possible shortest path:", path)
def test_find_min_moves(self): # test king middle board = generate_board({}) start_loc = (3, 3) end_loc = (5, 1) result = find_min_moves(board, start_loc, end_loc, chess.KING) self.assertEqual(result, 2) # test king edge board = generate_board({}) start_loc = (0, 0) end_loc = (7, 7) result = find_min_moves(board, start_loc, end_loc, chess.KING) self.assertEqual(result, 7) # test king with obstacles board = generate_board({(1, 4), (0, 4), (2, 4)}) start_loc = (1, 2) end_loc = (1, 5) result = find_min_moves(board, start_loc, end_loc, chess.KING) self.assertEqual(result, 4) # test bishop middle board = generate_board({}) start_loc = (2, 3) end_loc = (3, 6) result = find_min_moves(board, start_loc, end_loc, chess.BISHOP) self.assertEqual(result, 2) # test bishop edge board = generate_board({}) start_loc = (0, 7) end_loc = (7, 0) result = find_min_moves(board, start_loc, end_loc, chess.BISHOP) self.assertEqual(result, 1) # test bishop with obstacles board = generate_board({(4, 1), (3, 2), (2, 1)}) start_loc = (2, 1) end_loc = (5, 2) result = find_min_moves(board, start_loc, end_loc, chess.BISHOP) self.assertEqual(result, 3) # test knight middle board = generate_board({}) start_loc = (2, 1) end_loc = (6, 3) result = find_min_moves(board, start_loc, end_loc, chess.KNIGHT) self.assertEqual(result, 2) # test knight edge board = generate_board({}) start_loc = (0, 0) end_loc = (7, 5) result = find_min_moves(board, start_loc, end_loc, chess.KNIGHT) self.assertEqual(result, 4) # test knight with obstacles board = generate_board({(2, 2), (2, 3), (3, 3), (3, 2), (3, 4), (4, 4)}) start_loc = (4, 1) end_loc = (2, 5) result = find_min_moves(board, start_loc, end_loc, chess.KNIGHT) self.assertEqual(result, 4) # test rook middle board = generate_board({}) start_loc = (5, 1) end_loc = (3, 3) result = find_min_moves(board, start_loc, end_loc, chess.ROOK) self.assertEqual(result, 2) # test rook edge board = generate_board({}) start_loc = (0, 0) end_loc = (7, 7) result = find_min_moves(board, start_loc, end_loc, chess.ROOK) self.assertEqual(result, 2) # test rook with obstacles board = generate_board({(2, 3), (4, 4), (4, 5), (4, 6), (5, 3), (6, 4)}) start_loc = (2, 1) end_loc = (5, 4) result = find_min_moves(board, start_loc, end_loc, chess.ROOK) self.assertEqual(result, 4) # test unreachable - boxed off board = generate_board({(4, 4), (5, 5), (5, 3), (6, 4)}) start_loc = (2, 1) end_loc = (5, 4) result = find_min_moves(board, start_loc, end_loc, chess.ROOK) self.assertIsNone(result) # test unreachable - bishop on different color board = generate_board({}) start_loc = (1, 1) end_loc = (0, 3) result = find_min_moves(board, start_loc, end_loc, chess.BISHOP) self.assertIsNone(result) # test unreachable - out of bounds start location board = generate_board({}) start_loc = (-1, 1) end_loc = (0, 3) result = find_min_moves(board, start_loc, end_loc, chess.KING) self.assertIsNone(result) # test unreachable - out of bounds end location board = generate_board({}) start_loc = (1, 1) end_loc = (200, 3) result = find_min_moves(board, start_loc, end_loc, chess.KNIGHT) self.assertIsNone(result) # test unreachable - piece occupying end location board = generate_board({(2, 2)}) start_loc = (1, 1) end_loc = (2, 2) result = find_min_moves(board, start_loc, end_loc, chess.ROOK) self.assertIsNone(result) # same start and end location board = generate_board({}) start_loc = (1, 1) end_loc = (1, 1) result = find_min_moves(board, start_loc, end_loc, chess.KING) self.assertEqual(result, 0)
def test_generate_possible_moves(self): # test king middle board = generate_board({}) cur_loc = (3, 3) result = generate_possible_moves(board, cur_loc, chess.KING) expected = {(3, 2), (2, 2), (2, 3), (2, 4), (3, 4), (4, 4), (4, 3), (4, 2)} self.assertEqual(result, expected) # test king edge board = generate_board({}) cur_loc = (0, 0) result = generate_possible_moves(board, cur_loc, chess.KING) expected = {(0, 1), (1, 1), (1, 0)} self.assertEqual(result, expected) # test king edge with obstacles board = generate_board({(1, 2), (0, 2), (0, 3)}) cur_loc = (1, 3) result = generate_possible_moves(board, cur_loc, chess.KING) expected = {(0, 4), (1, 4), (2, 4), (2, 3), (2, 2)} self.assertEqual(result, expected) # test bishop middle board = generate_board({}) cur_loc = (1, 5) result = generate_possible_moves(board, cur_loc, chess.BISHOP) expected = {(0, 4), (0, 6), (2, 6), (2, 4), (3, 3), (4, 2), (5, 1), (6, 0), (3, 7)} self.assertEqual(result, expected) # test bishop edge board = generate_board({}) cur_loc = (1, 0) result = generate_possible_moves(board, cur_loc, chess.BISHOP) expected = {(0, 1), (2, 1), (3, 2), (4, 3), (5, 4), (6, 5), (7, 6)} self.assertEqual(result, expected) # test bishop with obstacles board = generate_board({}) cur_loc = (1, 5) result = generate_possible_moves(board, cur_loc, chess.BISHOP) expected = {(0, 4), (0, 6), (2, 6), (2, 4), (3, 3), (4, 2), (5, 1), (6, 0), (3, 7)} self.assertEqual(result, expected) # test knight middle board = generate_board({}) cur_loc = (4, 3) result = generate_possible_moves(board, cur_loc, chess.KNIGHT) expected = {(2, 2), (3, 1), (5, 1), (6, 2), (2, 4), (3, 5), (5, 5), (6, 4)} self.assertEqual(result, expected) # test knight edge board = generate_board({}) cur_loc = (7, 7) result = generate_possible_moves(board, cur_loc, chess.KNIGHT) expected = {(5, 6), (6, 5)} self.assertEqual(result, expected) # test knight with obstacles board = generate_board({(3, 1), (6, 2)}) cur_loc = (4, 3) result = generate_possible_moves(board, cur_loc, chess.KNIGHT) expected = {(2, 2), (5, 1), (2, 4), (3, 5), (5, 5), (6, 4)} self.assertEqual(result, expected) # test rook middle board = generate_board({}) cur_loc = (4, 3) result = generate_possible_moves(board, cur_loc, chess.ROOK) expected = {(3, 3), (2, 3), (1, 3), (0, 3), (5, 3), (6, 3), (7, 3), (4, 2), (4, 1), (4, 0), (4, 4), (4, 5), (4, 6), (4, 7)} self.assertEqual(result, expected) # test rook edge board = generate_board({}) cur_loc = (7, 0) result = generate_possible_moves(board, cur_loc, chess.ROOK) expected = {(7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0)} self.assertEqual(result, expected) # test rook with obstacles board = generate_board({(2, 3), (4, 0), (4, 2)}) cur_loc = (4, 3) result = generate_possible_moves(board, cur_loc, chess.ROOK) expected = {(3, 3), (5, 3), (6, 3), (7, 3), (4, 4), (4, 5), (4, 6), (4, 7)} self.assertEqual(result, expected) # test no moves - boxed off board = generate_board({(1, 0), (1, 2), (3, 0), (3, 2)}) cur_loc = (2, 1) result = generate_possible_moves(board, cur_loc, chess.BISHOP) self.assertEqual(0, len(result)) # test out of bounds location 1 board = generate_board({}) cur_loc = (-1, 1) result = generate_possible_moves(board, cur_loc, chess.KING) self.assertIsNone(result) # test out of bounds location 2 board = generate_board({}) cur_loc = (12, 1) result = generate_possible_moves(board, cur_loc, chess.KING) self.assertIsNone(result)