def test_hard_computer_chooses_adjacent_corner_as_second_move(hard_computer): board = Board() board[0] = "X" board[1] = "O" move = hard_computer.move(board) assert move == 6 board = Board() board[0] = "X" board[3] = "O" move = hard_computer.move(board) assert move == 2
def test_board_diagnal_line(self): '''Test Board has_straight_line diagnal''' for size in self.board_size_list: for value in self.sample_values: board = Board(size) self._fill_board_diagnally(board, value=value) self.assertTrue(board.has_straight_line()) for size in self.board_size_list: for value in self.sample_values: board = Board(size) self._fill_board_diagnally(board, value=value, direction=1) self.assertTrue(board.has_straight_line())
def main(): run = True clock = pygame.time.Clock() board = Board() turn = 1 winner = None while run: clock.tick(FPS) for event in pygame.event.get(): if event.type == pygame.QUIT: run = False if (turn == -1): choice = random.choice(board.get_legal_moves()) board.move(choice[0], choice[1], -1) turn = 1 winner = board.check_winner(WIN) if event.type == pygame.MOUSEBUTTONDOWN and winner == None: pos = pygame.mouse.get_pos() row, col = get_row_col_from_mouse(pos) if turn == 1 and board.move(row, col, 1): turn = -1 winner = board.check_winner(WIN) if winner == "Draw": print("It is a Draw!") elif winner != None: print(str(winner) + " wins!") board.draw(WIN) pygame.display.update() pygame.quit()
def game(): current = Player.AI board = Board() winner = Player.UNKNOWN while winner == Player.UNKNOWN: if current == Player.HUMAN: board = human_turn(board) current = Player.AI else: board = ai_turn(board) current = Player.HUMAN print('-' * 20) print(board) winner = board.winner if not board.possible_moves(Player.AI) and winner == Player.UNKNOWN: winner = None if winner == Player.HUMAN: print('You won!') elif winner == Player.AI: print('Yoy lose!') else: print('It\'s a draw!')
def run_train(): game = Board(size=3) bot1 = Bot() bot2 = Bot() print("Start training..") bot1.train_mode(0.7) bot2.train_mode(0.7) for i in tqdm(range(10000)): game.run(bot1, bot2, verbose=False) if (i + 1) % 100 == 0: bot1.learning_rate *= 0.95 bot2.learning_rate *= 0.95 bot1.train_mode(0.5) bot2.train_mode(0.5) for _ in tqdm(range(10000)): game.run(bot1, bot2, verbose=False) print("End training..") print("Play dummy game..") bot1.fix_model() bot2.fix_model() bot1.serious_mode() bot2.serious_mode() game.run(bot1, bot2)
def game(): """Single game. """ board = Board() player_idx = 0 print(f"\nCurrent position:\n{board.render()}") while not board.is_full(): player_idx = (player_idx + 1) % len(SYMBOLS) symbol = SYMBOLS[player_idx] code = input_move(f"Enter move code 1 - 9 for '{symbol}': ") x, y = MOVE_CODES[code] try: board.move(symbol, x, y) print(f"\nCurrent position:\n{board.render()}") if board.is_win(): print(f"\nPlayer '{symbol}' wins!") break except BoardError as e: # Print error and let player re-enter move print(e, file=sys.stderr) player_idx = (player_idx + 1) % len(SYMBOLS) if board.is_draw(): print("\nThe game is a draw!")
def x_winning_move(self): x_winning_move = Board() x_winning_move.make_move(3, "X") x_winning_move.make_move(5, "O") x_winning_move.make_move(2, "X") x_winning_move.make_move(9, "O") return x_winning_move
def playIncompleteGameAIPlaysSecond(self): ai_game = Game(Player("X", self.mock_cli_input, self.ui), AIMinimax("O", Rules()), self.ui, Validations(), Rules(), Board()) ai_game._board.make_move(1, self.game._player1._symbol) ai_game._board.make_move(3, self.game._player2._symbol) self.db.add_game_to_database(ai_game)
def test_board_creation(self): board = Board(self.print_function) self.assertEqual(len(board.cells), 9) self.assertEqual(board.marked_cells, 0) for idx in range(0, 9): cell_number = str(idx + 1) self.assertEqual(board.cells[idx], cell_number)
def train(self, player='X', n=100000): self.reset() for episode in range(n): board = Board('X', 'O', ' ') state = board.state reward = 0 if player != 'X': board.make_random_move() while not board.game_over: if np.random.uniform() < self.eps: action = self.random_action(board) else: action = self.best_action(state, board) next_state, reward, terminated = \ board.step(player, action) q = self.Q[state, action] max_q = self.max_q(next_state) next_q = (1 - self.nu) * q + self.nu * (reward + self.gamma * max_q) self.Q[state, action] = next_q state = next_state
def test_board_detects_all_winning_patterns(): for s1, s2, s3 in patterns.winning_patterns: xo_board = Board(tokens=["X", "O"]) xo_board[s1] = "X" xo_board[s2] = "X" xo_board[s3] = "X" assert xo_board.is_over()
def testPlayerMove(self): result = self.player1.move(Board()) expected_result = 1 self.assertEqual(result, expected_result, msg='\nRetrieved:\n{0} \nExpected:\n{1}'.format( result, expected_result))
def testPlayerSymbolDisplayedWhenPlayersTurnToMakeAMove(self): self.player1.move(Board()) result = self.mock_cli_output._last_output expected_result = "Player X, please make a move or type 'q' to save and quit game:" self.assertTrue(result in expected_result, msg='\nRetrieved:\n{0} \nExpected:\n{1}'.format( result, expected_result))
def test_check_if_str_return_proper_repr4(self): test_board = Board(2, 2) test_board.set_element(0, 0, 'o') test_board.set_element(0, 1, 'o') test_board.set_element(1, 0, 'o') test_board.set_element(1, 1, 'o') expected_str = "o o \n\no o \n\n" self.assertEqual(test_board.__str__(), expected_str)
def test_board_vertical_line(self): '''Test Board has_straight_line vertical''' for size in self.board_size_list: for value in self.sample_values: for col in range(size): board = Board(size) self._fill_board_vertically(board, value=value, col=col) self.assertTrue(board.has_straight_line())
def o_winning_move(self): o_winning_move = Board() o_winning_move.make_move(1, "X") o_winning_move.make_move(5, "O") o_winning_move.make_move(2, "X") o_winning_move.make_move(3, "O") o_winning_move.make_move(8, "X") return o_winning_move
def test_board_horizontal_line(self): '''Test Board has_straight_line horizontal''' for size in self.board_size_list: for value in self.sample_values: for row in range(size): board = Board(size) self._fill_board_horizontally(board, value=value, row=row) self.assertTrue(board.has_straight_line())
def testPlayerMoveAgain(self): self.mock_cli_input.set_value(5) result = self.player1.move(Board()) expected_result = 5 self.assertEqual(result, expected_result, msg='\nRetrieved:\n{0} \nExpected:\n{1}'.format( result, expected_result))
def test_print_board_for_instructions(self): board = Board(self.print_function) board.print_board() expected_string = ' | | \n 1 | 2 | 3 \n | | \n' expected_string += '-----------------\n' expected_string += ' | | \n 4 | 5 | 6 \n | | \n' expected_string += '-----------------\n' expected_string += ' | | \n 7 | 8 | 9 \n | | \n' self.assertEqual(self.returned_string, expected_string)
def o_winning(self): o_winning = Board() o_winning.make_move(1, "X") o_winning.make_move(3, "O") o_winning.make_move(2, "X") o_winning.make_move(5, "O") o_winning.make_move(6, "X") o_winning.make_move(7, "O") return o_winning
def test_row_winner(self): board = Board() for x in range(board._cols): board.accept_move(x, 0, board.player_o) board.accept_move(x, 1, board.player_o) board.accept_move(x, 2, board.player_o) self.assertEqual(board.check_winner(), board.player_o, f"Error: player O should have won.") board.reset()
def test_hard_computer_wins_if_able(hard_computer): for args in patterns.winning_patterns: args = list(args) random.shuffle(args) a, b, c = args board = Board() board[a] = "X" board[b] = "X" move = hard_computer.move(board) assert move == c
def test_print_board_for_cleaned_marks(self): board = Board(self.print_function) board.clean_marks() board.print_board() expected_string = ' | | \n | | \n | | \n' expected_string += '-----------------\n' expected_string += ' | | \n | | \n | | \n' expected_string += '-----------------\n' expected_string += ' | | \n | | \n | | \n' self.assertEqual(self.returned_string, expected_string)
def x_winning(self): x_winning = Board() x_winning.make_move(1, "X") x_winning.make_move(2, "O") x_winning.make_move(3, "X") x_winning.make_move(4, "O") x_winning.make_move(5, "X") x_winning.make_move(7, "O") x_winning.make_move(9, "X") return x_winning
def test_col_winner(self): board = Board() for y in range(board._rows): board.accept_move(0, y, board.player_x) board.accept_move(1, y, board.player_x) board.accept_move(2, y, board.player_x) self.assertEqual(board.check_winner(), board.player_x, f"Error: player X should have won.") board.reset()
def ai_turn(board): weighted_moves = [] for move in board.possible_moves(Player.AI): w, t = tree_search(Board(board, move), Player.AI) weighted_moves.append((move, w / t)) if len(weighted_moves) == 0: return best_move, best_weight = weighted_moves[0] for move, weight in weighted_moves: if weight > best_weight: best_move = move best_weight = weight return Board(board=board, move=best_move)
def test_hard_computer_response_strategy_picks_mid_spot_turn_three(seed): hard_computer = players.HardComputer(seed=seed) hard_computer.token = "X" board = Board() board[2] = "O" board[4] = "X" board[6] = "O" move = hard_computer.move(board) assert move in patterns.middles
def testDisplaysBoardOnce(self): self.mock_cli_input.set_value('0') board = Board() board_string = self.setup_game._ui.print_board(board) self.setup_game.run() result = self.mock_cli_output._last_output self.assertTrue( board_string in result, msg='\nRetrieved:\n{0} \nExpected to contain:\n{1}'.format( result, board_string))
def draw_board(): result = Board() result.move('O', 1, 1) result.move('X', 0, 2) result.move('O', 1, 0) result.move('X', 1, 2) result.move('O', 2, 2) result.move('X', 0, 0) result.move('O', 0, 1) result.move('X', 2, 1) result.move('O', 2, 0) return result
def tie_game(self): tie_game = Board() tie_game.make_move(1, "X") tie_game.make_move(3, "O") tie_game.make_move(2, "X") tie_game.make_move(4, "O") tie_game.make_move(6, "X") tie_game.make_move(5, "O") tie_game.make_move(7, "X") tie_game.make_move(8, "O") tie_game.make_move(9, "X") return tie_game