def test_multiple_errors(self): turns = ['1', '2', '4', '5', '4', '5', '4', '5', '5', '5', '7'] msg = 'Congratulations to player number {}' tic_tac = TicTacToe() for turn in turns[:-1]: tic_tac.turn(turn) self.assertEqual(tic_tac.turn(turns[-1]), msg.format(1))
def input_name(): if name_2 == self.a_i: self.game = TicTacToe(name_1.get(), self.a_i) self.user_stroke() else: self.game = TicTacToe(name_1.get(), name_2.get()) self.user_stroke()
def main(): board_size = 3 exploration = 0.5 learning_rate = 5.0 discount = 5.0 training_episodes = 10000 episodes = 10 random_state = random.Random() player_x = TicTacToeAgent("X", RandomAction(random_state)) q_learning = QLearning(learning_rate, discount) training_player_o = TicTacToeAgent( "O", EpsilonExploration(q_learning, exploration)) training_environment = TicTacToe(training_player_o, player_x, board_size) run_training(training_environment, [training_player_o], training_episodes) policy = policy_from_q_values(q_learning.q_values) evaluation_player_o = TicTacToeAgent( "O", FollowPolicy(policy, RandomAction(random_state))) evaluation_environment = TicTacToe(evaluation_player_o, player_x, board_size) run_timed_episodes(evaluation_environment, episodes)
def test_draw(self): turns = ['1', '2', '5', '9', '6', '4', '3', '7', '8'] msg = 'Draw' tic_tac = TicTacToe() for turn in turns[:-1]: tic_tac.turn(turn) self.assertEqual(tic_tac.turn(turns[-1]), msg)
def test_game_winner(self): """Test all winning configurations.""" # arrange game_descriptions = [ ([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 'A win in the 1st column.'), ([(0, 1), (0, 0), (1, 1), (1, 0), (2, 1)], 'A win in the 2nd column.'), ([(0, 2), (0, 1), (1, 2), (1, 1), (2, 2)], 'A win in the 3st column.'), ([(0, 0), (1, 1), (0, 1), (1, 2), (0, 2)], 'A win in the 1st row.'), ([(1, 0), (0, 0), (1, 1), (0, 1), (1, 2)], 'A win in the 2nd row.'), ([(2, 0), (0, 1), (2, 1), (1, 1), (2, 2)], 'A win in the 3st row.'), ([(0, 0), (1, 0), (1, 1), (0, 1), (2, 2)], 'A win in the main diagonal.'), ([(0, 2), (1, 0), (1, 1), (0, 1), (2, 0)], 'A win in the minor diagonal.'), ] for turn_sequence, win_description in game_descriptions: game = TicTacToe() expected_winner = game.next_mark # assert for turn_index, turn in enumerate(turn_sequence): self.assertEqual( PlayerMark.EMPTY, game.winner, f'Winner before the turn #{turn_index} of the game "{win_description}"') game.mark_cell(*turn) self.assertEqual( expected_winner, game.winner, 'Winner after the last turn of the game "{win_description}"') self.assertTrue(game.has_ended(), "Game has ended")
def test_winner_2(self): msg = 'Congratulations to player number {}' turns = ['1', '2', '3', '5', '4', '8'] tic_tac = TicTacToe() for turn in turns[:-1]: tic_tac.turn(turn) self.assertEqual(tic_tac.turn(turns[-1]), msg.format(-1))
def test_terminates(self): game = TicTacToe() game.board[:] = 1 game.board[0, 0] = 0 ai = MinimaxAI(game) row, column = ai.decide_turn()
def test_makes_valid_turns(self): game = TicTacToe() game.o_ai = RandomAI(game) row, column = game.o_ai.decide_turn() assert 0 <= row <= 2 assert 0 <= column <= 2
def play_exploratory_move(self, game: TicTacToe): legal_moves = self.get_legal_moves(game) idx = randint(0, len(legal_moves) - 1) random_move = legal_moves[idx] outcome = game.update_board(random_move[0], random_move[1], self.marker) self.prev_state = TicTacToe.get_serialized_board(game.get_board()) return outcome
def run_trials(): for i in range(n_games): ttt = TicTacToe() x_ai = MinimaxAI(ttt) o_ai = RandomAI(ttt) ttt.o_ai = o_ai ttt.x_ai = x_ai result = ttt.loop() counters[result] += 1
def test_chooses_blocking_move(self): game = TicTacToe() game.x_next = False game.board = np.array([[-1, 1, 0], [1, 1, -1], [-1, 0, 1]]) ai = MinimaxAI(game) row, column = ai.decide_turn() assert (row, column) == (2, 1)
def tictactoe(): global game, bot, moving # reset moving moving = False game = TicTacToe() # randomize the first player game.active_player = random.choice([0, 1]) # use the bot that has memorized all the best moves bot = tic_tac_toe_bot return render_template("tictactoe.html", player=game.active_player)
def test_set_params(self): moves = [[0, 0, 'o'], [0, 2, 'x'], [1, 1, 'o'], [0, 1, 'x'], [2, 2, 'o'], [1, 0, 'x'], [2, 1, 'o']] t = TicTacToe() result = 0 for move in moves: result = t.place_marker(move[2], move[0], move[1]) self.assertIsNotNone(result) self.assertIs(result, t.STATES.NAUGHT_WON.value)
def get_possible_next_states(self, game: TicTacToe, legal_moves: list): planning_board = deepcopy(game.get_board()) possible_states = [] for move in legal_moves: planning_board[move[0]][move[1]] = self.marker state = TicTacToe.get_serialized_board(planning_board) possible_states.append(state) # reset planning board planning_board[move[0]][move[1]] = "" return possible_states
def test_who_wins(self): t = TicTacToe() testcase1 = [1, 0] testcase2 = [3, 0] result = t.who_wins(testcase1) self.assertIs(result, t.STATES.DRAW.value) result = t.who_wins(testcase2) self.assertIs(result, t.STATES.CROSS_WON.value)
def test_setting_mark_in_an_out_of_range_cell(self): """Test game's reaction to setting mark into a non-existing cell.""" #arrange game = TicTacToe() #act try: game.mark_cell(game.grid_size + 1, game.grid_size + 1) #assert except IndexError as error: self.fail(f"Exception raised unexpectedly: {error}.")
def __init__(self, game_presenter: GamePresenterBase, player1: GamePlayerBase, player2: GamePlayerBase): self.game_presenter = game_presenter self._current_player = player1 self._next_player = player2 self.game = TicTacToe() self._current_player.set_mark(self.game.next_mark) self._next_player.set_mark(self.game._previous_mark) self.on_mark_selected = None
def _restart_game(self) -> None: """ Restarts the game, and all variables associated with it """ self._game = TicTacToe(self._board_size) self._has_game_started = False self._update_player_prompt() for cell in self._board_cells: cell.setText(TicTacToe.NEUTRAL_PLAYER)
def test_set_coord(self): ''' Тесты функции set_coord()''' game = TicTacToe() for i in range(9): game.set_coord(i) with self.assertRaises(AlreadyExistsError): game.set_coord(3) game = TicTacToe() for i in range(1, 10): game.set_coord(i) self.assertListEqual(game._table, ['X', 'O', 'X', 'O', 'X', 'O', 'X', 'O', 'X'])
def test_getting_mark_from_a_cell(self): """Test requesting a mark from a game cell.""" #arrange game = TicTacToe() expected_mark = game.next_mark tested_cell = (0, 0) game.mark_cell(*tested_cell) #assert self.assertEqual( expected_mark, game.get_cell_mark(*tested_cell), "Cell's mark")
def randomTTT(numGames): t = TicTacToe() winnerStats = [0] * 3 gameLength = [0] * 10 for _ in range(numGames): winner, length = t.simulate() winnerStats[winner] += 1 gameLength[length] += 1 print(winnerStats[BLACK], " wins for X, ", winnerStats[WHITE], " wins for O, ", winnerStats[EMPTY], " draws") print("Game length:") for length in range(5, 10): if gameLength[length] > 0: print("Length ", length, ": ", gameLength[length])
def test_change_cell(self): """Trying to break changing precautions""" self.assertFalse(self.change_cell(0, 0, 'X')) self.assertFalse(self.change_cell(-1, -2, 'X')) self.assertFalse(self.change_cell(110, 10, 'X')) self.assertFalse(self.change_cell(0, 0, '0')) self.assertFalse(self.change_cell(0, 5, 'O')) self.assertFalse(self.change_cell(5, 0, 'O')) self.assertFalse(self.change_cell(0, 5, 6)) self.assertFalse(self.change_cell(0, 5, 'das')) instance = TicTacToe() instance.change_cell(1, 1, 'X') self.assertFalse(instance.change_cell(1, 1, 'X'))
def main(): tic_tac_toe = TicTacToe() tic_tac_toe.print_field() while True: input_ = input('Enter the coordinates: ').split() if tic_tac_toe.check_input(input_): if tic_tac_toe.move(): tic_tac_toe.print_field() if tic_tac_toe.check_win(): break
def main(): game = TicTacToe() gui = TicTacToeGui(0, 0, 500, 500, game) win = Window(title="Ultimate Tic Tac Toe", flags=["SCALED"], gui_objects=[gui]) win.start()
def get_state(self, game: TicTacToe): state = [ game.get_cell_mark(x, y).value for x in range(game.grid_size) for y in range(game.grid_size) ] return np.asarray(state)
def test_ttt_clear(self): ttt = TicTacToe() self.assertEqual(ttt.board, [[0, 0, 0], [0, 0, 0], [0, 0, 0]]) ttt.put('b2') self.assertEqual(ttt.board, [[0, 0, 0], [0, 'x', 0], [0, 0, 0]]) ttt.put('a1') self.assertEqual(ttt.board, [['o', 0, 0], [0, 'x', 0], [0, 0, 0]]) ttt.clear() self.assertEqual(ttt.board, [[0, 0, 0], [0, 0, 0], [0, 0, 0]])
def play_greedy_move(self, game: TicTacToe): legal_moves = self.get_legal_moves(game) possible_states = self.get_possible_next_states(game, legal_moves) best_state_index, best_state = self.choose_best_state_index(possible_states) # best_state_index is also best_move_index best_move = legal_moves[best_state_index] current_state = TicTacToe.get_serialized_board(game.get_board()) outcome = game.update_board(best_move[0], best_move[1], self.marker) # Finished game outcomes are handled differently if outcome == TicTacToe.END_MOVE: self.update_value(best_state) self.prev_state = best_state return outcome
def test_game_with_no_winner(self): """Test the draw game ending.""" # arrange game = TicTacToe() draw_complete_turn_sequence = [ (0, 0), (1, 1), (2, 2), (0, 1), (2, 1), (2, 0), (0, 2), (1, 2), (1, 0) ] # assert for turn_index, turn in enumerate(draw_complete_turn_sequence): self.assertEqual(PlayerMark.EMPTY, game.winner, f'Winner before the turn #{turn_index}') game.mark_cell(*turn) self.assertEqual(PlayerMark.EMPTY, game.winner, 'Winner after the last turn') self.assertTrue(game.has_ended(), "Game has ended")
def get_legal_moves(self, game: TicTacToe): legal_moves = [] board = game.get_board() for row in range(3): for col in range(3): if board[row][col] == "": legal_moves.append((row, col)) return legal_moves
def test_makes_valid_turns(self): game = TicTacToe() ai = MinimaxAI(game) row, column = ai.decide_turn() assert 0 <= row <= 2 assert 0 <= column <= 2
class TestTicTacToe(unittest.TestCase): def setUp(self): self.game = TicTacToe() def test_choose(self): self.game.choose(1, 1) expected = [' ', ' ', ' ', ' ', 'X', ' ', ' ', ' ', ' '] actual = self.game.get_board().get_data() self.assertEqual(actual, expected) def test_finished(self): self.game.choose(0, 0) self.game.choose(1, 0) self.game.choose(1, 1) self.game.choose(2, 2) self.game.choose(0, 1) self.game.choose(2, 1) self.game.choose(0, 2) actual = self.game.finished() expected = True self.assertEqual(actual, expected)
def setUp(self): self.game = TicTacToe()
def test_o_rows_board(self): game = TicTacToe() winner = game.winner(3, [], [(0,0), (0,1), (0,2)]) self.assertEquals(winner, "o")
def setUp(self): self.tic = TicTacToe()
class TicTacToeTests(unittest.TestCase): def setUp(self): self.tic = TicTacToe() def test_is_winner(self): self.tic.board[6] = 'X' self.tic.board[7] = 'X' self.tic.board[8] = 'X' self.assertTrue(self.tic.is_winner('X')) def test_is_winning(self): self.tic.board[3] = 'O' self.tic.board[4] = 'X' self.tic.board[5] = 'X' self.assertFalse(self.tic.is_winner('O')) def test_try_to_win_successfully(self): self.tic.computer_symbol = "O" self.tic.player_symbol = "X" self.tic.board[0] = 'X' self.tic.board[1] = ' ' self.tic.board[2] = 'O' self.tic.board[3] = ' ' self.tic.board[4] = 'X' self.tic.board[5] = 'X' self.tic.board[6] = 'O' self.tic.board[7] = ' ' self.tic.board[8] = 'O' self.tic.free_positions = [1, 3, 7] self.assertEqual(self.tic.computer_choose_position(3), 7) def test_config(self): self.tic.computer_symbol = "O" self.tic.player_symbol = "X" self.tic.board[0] = 'X' self.tic.board[1] = ' ' self.tic.board[2] = 'O' self.tic.board[3] = 'O' self.tic.board[4] = 'X' self.tic.board[5] = 'X' self.tic.board[6] = ' ' self.tic.board[7] = ' ' self.tic.board[8] = 'O' self.tic.free_positions = [1, 6, 7] self.tic.make_move(7, 'X') self.assertEqual(self.tic.computer_choose_position(3), 6) def test_computer_block_player(self): self.tic.computer_symbol = "O" self.tic.player_symbol = "X" self.tic.board[0] = 'X' self.tic.board[1] = ' ' self.tic.board[2] = ' ' self.tic.board[3] = 'O' self.tic.board[4] = 'X' self.tic.free_positions = [1, 5, 6, 7, 8] self.assertEqual(self.tic.computer_choose_position(1), 8) def test_computer_chooses_corner(self): self.tic.computer_symbol = "O" self.tic.player_symbol = "X" self.tic.board[4] = 'X' move = self.tic.computer_choose_position(1) self.tic.free_positions = [0, 1, 2, 3, 5, 6, 7, 8] corners = [0, 2, 6, 8] self.assertIn(move, corners)
def test_x_second_line(self): game = TicTacToe() winner = game.winner(3, [], [(1,0), (1,1), (1,2)]) self.assertEquals(winner, "o")
def test_x_wins(self): game = TicTacToe() winner = game.winner(1, [(0,0)], []) self.assertEquals(winner, "x")
def test_nobody_wins(self): game = TicTacToe() winner = game.winner(3, [], []) self.assertEquals(winner, "nobody")