def setUp(self):
self.board_3x3 = Board(3)
self.board_5x5 = Board(5)
self.game = Game()
self.game.board = Board(3)
self.game.player1 = Player("Toothless", "X")
self.game.player2 = Player("Hiccup", "O")
def test_board_equality_returns_false(self):
pawn_a = Pawn(1, 0, 1, True)
pawn_b = Pawn(1, 0, 2, True)
king = King(1, 4, 0, True)
board_a = Board([pawn_a, king])
board_b = Board([pawn_b, king])
self.assertFalse(board_a == board_b)
def test_board_eq_4(self):
board_size = 3
board_3 = Board(board_size)
board_3.board = [['x', 'o', '.'], ['.', '.', '.'], ['.', '.', '.']]
board = Board(board_size)
board.board = [['x', 'o', '.'], ['.', '.', '.'], ['.', '.', '.']]
self.assertEqual(board_3, board)
def play(self, nested_array):
if nested_array == None:
nested_array = Board().draw_board()
else:
Board().draw_board()
if not self.is_human:
return self.computer(nested_array)
return self.human(nested_array)
def test_alive_cell_come_dead():
board = Board(3, 3)
board.alive(0, 0)
board.alive(0, 1)
evolved_board = board.evolve()
expected_evolved_board = Board(3, 3)
assert evolved_board == expected_evolved_board
def test_update_board_single_red_bubble(self):
empty_board = Board()
curr_board = Board([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0],
[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]])
game_state = GameState(curr_board, 1)
game_state.update_board(2, 2)
assert game_state.board == empty_board
assert game_state.result == GameResults.Win
def test_update_board_multiple_red_bubbles(self):
empty_board = Board()
curr_board = Board([[1, 0, 1, 0, 1], [0, 0, 0, 0, 0], [1, 0, 1, 0, 1],
[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [1, 0, 1, 0, 1]])
game_state = GameState(curr_board, 1)
game_state.update_board(0, 0)
assert game_state.board == empty_board
assert game_state.result == GameResults.Win
def test_board_eq_init_4(self):
board_size = 4
board_4 = Board(board_size)
board_4.board = [
['.', '.', '.', '.'],
['.', '.', '.', '.'],
['.', '.', '.', '.'],
['.', '.', '.', '.'],
]
board = Board(board_size)
self.assertEqual(board_4, board)
def test_update_board_level_18(self):
expected_board = Board()
curr_board = Board([[0, 3, 2, 4, 0], [1, 1, 1, 2, 0], [0, 1, 4, 1, 2],
[0, 4, 2, 0, 1], [1, 1, 1, 2, 2], [0, 4, 0, 1, 1]])
game_state = GameState(curr_board, 1)
game_state.update_board(4, 2)
assert game_state.board == expected_board
assert game_state.result == GameResults.Win
def test_get_surrounding(self):
y = 10
x = 10
data = self.get_json_data()
board = Board()
tile_map = data["map"]["tiles"]
result = board.get_surrounding(x, y, tile_map) != False
self.assertEqual(result, True)
board = Board()
tile_map = data["map"]["tiles"]
result = board.get_surrounding(x,y, tile_map) != False
self.assertEqual(result, True)
def test_update_board_level_16(self):
expected_board = Board([[1, 1, 1, 0, 0], [0, 0, 0, 0, 0],
[0, 0, 0, 0, 0], [0, 0, 0, 0, 0],
[0, 0, 0, 0, 0], [1, 0, 0, 0, 0]])
curr_board = Board([[2, 4, 4, 1, 1], [2, 2, 2, 0, 4], [0, 4, 2, 2, 2],
[1, 1, 1, 3, 1], [1, 4, 0, 1, 4], [4, 0, 3, 2, 0]])
game_state = GameState(curr_board, 1)
game_state.update_board(3, 2)
assert game_state.board == expected_board
assert game_state.result == GameResults.Lose
def test_update_board_red_green_bubbles(self):
expected_board = Board([[0, 0, 0, 0, 0], [0, 1, 0, 1, 0],
[1, 1, 0, 1, 1], [0, 2, 0, 2, 0],
[0, 1, 0, 1, 0], [0, 0, 0, 0, 0]])
# level 7
curr_board = Board([[0, 0, 0, 0, 0], [0, 1, 0, 1, 0], [1, 2, 1, 2, 1],
[0, 2, 0, 2, 0], [0, 1, 0, 1, 0], [0, 0, 0, 0, 0]])
game_state = GameState(curr_board, 2)
game_state.update_board(2, 2)
assert game_state.board == expected_board
assert game_state.result == None
def test_empty_cell_exists(self):
board_size = 3
valid_move = [0, 0]
occupied = [0, 1]
out_of_board = [0, board_size + 2]
board_available = Board(board_size)
board_available.board = [['.', 'o', 'x'], ['.', 'x', '.'],
['x', '.', 'o']]
board_full = Board(board_size)
board_full.board = [['x', 'o', 'x'], ['o', 'x', 'o'], ['x', 'x', 'o']]
self.assertTrue(board_available.empty_cell_exists())
self.assertFalse(board_full.empty_cell_exists())
def test_king_capture_covered_piece(self):
king = King("e4", "white")
board = Board([king, Knight("e5", "black"), Bishop("a1", "black")])
board.create_board()
output = king.move_to(board, "e5", "black")
expected_output = (False, "illegal move: king in check")
self.assertEqual(expected_output, output)
def play_game(dummy=True,
weights=None,
matches=0,
train=True,
types=[NEURAL_TYPE, NEURAL_TYPE]):
board = Board(weights, types)
red_player = board.players[RED]
green_player = board.players[GREEN]
red_won = False
green_won = False
moves = 0
won = False
while moves < MAX_PLAYS:
moved, _ = red_player.random_move() if dummy else red_player.best_move(
learn=False)
output_board(board, green_player.weights, green_player.moves, matches)
over, color = is_game_over(board, GREEN)
if not moved or over:
break
moved, match_errors = green_player.best_move(learn=train)
output_board(board, green_player.weights, green_player.moves, matches)
over, color = is_game_over(board, GREEN)
if not moved or over:
break
moves = green_player.moves
if not moves < MAX_PLAYS:
return TIE, green_player.weights, [0.001]
elif color == GREEN:
return WIN, green_player.weights, [0.001]
elif color == RED:
return LOSS, green_player.weights, [0.001]
def test_game_still_running(self):
"""Verify game still running"""
board = Board(4, 300, 20, 100, 1000, 1)
board.actual_round = 999
self.assertEqual(board.game_still_running(), True)
board.actual_round = 1000
self.assertEqual(board.game_still_running(), False)
def test_actual_round(self):
"""Verify actual round"""
board = Board(4, 300, 20, 100, 1000, 1)
board.actual_round = 2
self.assertEqual(board.actual_round, 2)
board.actual_round = 1
self.assertEqual(board.actual_round, 2)
def test_game_end(self):
# Can't move
b = Board()
b._board = [
2, 4, 2, 4,
4, 2, 4, 2,
2, 4, 2, 4,
4, 2, 4, 2
]
self.assertEqual(True, b.is_terminal())
# Zero check
b._board = [
2, 4, 2, 4,
4, 2, 4, 2,
2, 4, 2, 4,
4, 2, 0, 2
]
self.assertEqual(False, b.is_terminal())
# Right or left
b._board = [
2, 4, 2, 4,
4, 2, 4, 2,
2, 4, 8, 4,
4, 2, 2, 2
]
self.assertEqual(False, b.is_terminal())
# Up or down
b._board = [
2, 4, 2, 4,
4, 2, 4, 2,
2, 4, 8, 4,
4, 2, 8, 2
]
self.assertEqual(False, b.is_terminal())
def test_get_words_constrained(self):
trieRoot = Trie.words()
board = Board()
testCoord = Coord(4, 8)
startWord = "cabriole"
startCoord = Coord(3, 7)
board.place(("c", "a", "b", "r", "i", "o", "l", "e"), startCoord, True)
tiles = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
start = StartSequence(
4, 6, [None, "a", None, None, None, None, None, None, None], False)
plays = trieRoot.get_words_constrained(start, tiles, board)
plays = [tuple(play) for play in plays]
self.assertEqual(
set(plays), {('b', None), ('b', None, 'd'), ('b', None, 'd', 'e'),
('b', None, 'd', 'g', 'e'), ('b', None, 'a'),
('b', None, 'a', 'e', 'd'), ('b', None, 'g'),
('f', None), ('f', None, 'd'), ('f', None, 'd', 'e'),
('f', None, 'd', 'g', 'e'), ('f', None, 'c', 'e'),
('f', None, 'c', 'e', 'd'),
('f', None, 'c', 'a', 'd', 'e'), ('f', None, 'g'),
('d', None), ('d', None, 'b'), ('d', None, 'c', 'e'),
('d', None, 'g'), ('a', None), ('c', None, 'b'),
('c', None, 'f', 'e'), ('c', None, 'd'),
('c', None, 'd', 'e'), ('c', None, 'd', 'g', 'e'),
('c', None, 'g', 'e'), ('c', None, 'g', 'e', 'd'),
('g', None, 'b'), ('g', None, 'e'),
('g', None, 'e', 'd'), ('g', None, 'd')})
board.place(plays[10], Coord(start.x, start.y), start.ish)
def __init__(self,
window,
player1,
player2,
data_dir_path,
Q_learn=None,
Q={},
alpha=0.3,
gamma=0.9):
self.data_dir_path = data_dir_path
self.data_file_path = data_dir_path + "/"
self.window = window
self.user_interface = UserInterface(window, self)
self.board = Board()
self.evaluator = GameEvaluator()
self.is_q_learn_mode = False
self.player1 = player1
self.player2 = player2
self.current_player = player1
self.other_player = player2
self.games, self.game_stats, self.game_story = self.prepare_stats()
self.Q_learn = QLearning(self.player1, self.player2)
def solve():
selected_level = levels_menu()
algorithm, heuristic = algorithms_menu()
board_matrix, max_touches = utils.read_level_file(selected_level)
board = Board(board_matrix)
game_state = GameState(board, max_touches)
print_header(game_state)
utils.print_board(game_state.board)
start_time = time.time()
solution = algorithm.execute(game_state, heuristic)
end_time = time.time()
total_time = round(end_time - start_time, 2)
for move in solution:
move_row, move_col = move
game_state.update_board(move_row, move_col)
print("Move: [", move_row, ",", move_col, "]")
print_header(game_state)
utils.print_board(game_state.board)
if game_state.result == GameResults.Win:
print("**** You Won! ****")
else:
print("**** You Lost! ****")
print("\nSolved in ", total_time, " seconds", sep="")
print()
def pacman(input_file):
"""
Input:
1. input_file (String) =
contains the name of a text file you need to read that is in the same directory,
includes the ".txt" extension (ie. "input.txt")
Outputs:
1. final_pos_x (int) = final x location of Pacman
2. final_pos_y (int) = final y location of Pacman
3. coins_collected (int) =
the number of coins that have been collected by Pacman across all movements
"""
try:
lines_of_file: List[str] = FileParser().parse(path_to_file=input_file)
config_manager: ConfigManager = ConfigManager(inputs=lines_of_file)
board: Board = Board(config=config_manager)
for move in config_manager.moves:
if board.allows(move):
board.make_move(move)
return (
board.pacman_x,
board.pacman_y,
board.number_of_coins_collected,
)
except (IndexError, ValueError):
return -1, -1, 0
def test_is_winning_second_diagonal(self):
board_size = 3
board_3 = Board(board_size)
board_3.board = [['.', 'o', 'x'], ['.', 'x', '.'], ['x', '.', 'o']]
self.assertTrue(board_3.is_winning_second_diagonal('x'))
self.assertFalse(board_3.is_winning_second_diagonal('o'))
def test_king_capture_uncovered_piece(self):
king = King("e4", "white")
board = Board([king, Knight("e5", "black"), Bishop("a2", "black")])
board.create_board()
output = king.move_to(board, "e5", "black")
expected_output = (True, "legal move carried out")
self.assertEqual(expected_output, output)
def test_game_over_full(self):
board_size = 3
game_manager = GameManager(self.a1, self.a2, board_size)
board = Board(board_size)
board.board = [['o', 'o', 'x'], ['x', 'x', 'o'], ['o', 'x', 'o']]
game_manager.board = board
self.assertTrue(game_manager.game_over())
def test_game_not_over(self):
board_size = 3
game_manager = GameManager(self.a1, self.a2, board_size)
board = Board(board_size)
board.board = [['o', '.', '.'], ['x', 'x', '.'], ['o', '.', '.']]
game_manager.board = board
self.assertFalse(game_manager.game_over())
def test_is_winning_row_3(self):
board_size = 3
board_3 = Board(board_size)
board_3.board = [['x', 'x', 'x'], ['o', '.', '.'], ['.', 'o', '.']]
self.assertTrue(board_3.is_winning_row('x'))
self.assertFalse(board_3.is_winning_row('o'))
def test_place(self):
board = Board()
board.place(1, "X")
assert board.get(1) == "X"
assert board.get(2) == None
def test_out_of_bounds_check():
b = Board()
assert b.is_oob(0) == False
assert b.is_oob(30) == False
assert b.is_oob(63) == False
assert b.is_oob(64) == True
assert b.is_oob(-1) == True
def initGameCallBack(self):
if isinstance(self.interFrame, Frame):
self.interFrame.destroy()
self.timer.destroy()
self.counter.destroy()
if isinstance(self.gameFrame, Frame):
self.gameFrame.destroy()
storage = Storage()
self.mines = storage.get("mines")
h = storage.get("height")
w = storage.get("width")
self.isGameStarted = False
self.tiles = [[j for j in range(w)] for i in range(h)]
self.bombs = set()
self.bombsPrediction = set()
self.tilesAmount = w * h
self.board = Board(w, h, self.mines)
self.root.bind_class('Label', '<Button-1>', self.openTileEvent)
self.root.bind_class('Label', '<Button-2>', self.flagTileEvent)
self.root.bind('<KeyPress>', self.keyboardEvent)
self.code = ""
self.__createFrame()
self.__initInterface()
