def test_is_move_valid(self): r = Reversi(''' - - - - - - - - - - b w - - - - - - b w b - - - - - b w b - - - - w b w w w w - w w b b b - - - - - b b - - - - - - - b - - - - ''') self.assert_only_valid_moves(r, 'b', { 'A4', 'A5', 'A7', 'C1', 'D1', 'E1', 'E2', 'F4', 'F6', 'G4', 'G6', 'H5' }) r = Reversi(''' - - - - - - - - - - - b w - w - - - w b w b b - - - - b w - - - - - - b w b - - - - - - w - - - - - - - - - - - - - - - - - - - ''') self.assert_only_valid_moves(r, 'b', { 'B2', 'B3', 'B4', 'D1', 'D7', 'F1', 'F2', 'F4', 'F6', 'F7', 'G1', 'H1' }) r = Reversi(''' - - - - - w - - - - b - w - - - - - b b b - - - - - b w b w - - - - b w b w w - - - b w b b - - - - - b b - - - - - - b b - - - ''') self.assert_only_valid_moves( r, 'w', { 'B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'C8', 'D2', 'F2', 'F3', 'F7', 'F8', 'G6', 'G7' }) r = Reversi(''' - - - - - - - - - - - - - - - - - - w - w - - - - - w w w w - - - - w b b b b b - - - b b w - - - - - w b - - - - - w - b - - - ''') self.assert_only_valid_moves( r, 'w', {'C6', 'C7', 'D8', 'F7', 'F8', 'G4', 'G6', 'H4', 'H6'})
def test_does_south_traversal_allow_valid_move(self): r = Reversi(''' - - - - - - - - - - - - - - - - - - - - - - - - - - - w b - - - - - - b w - - - - - - - - - - - - - - - - - - - - - - - - - - - ''') moves_valid_for_south_traversal = {'D3'} moves_invalid_for_south_traversal = self.all_moves - moves_valid_for_south_traversal for move in moves_valid_for_south_traversal: self.assertTrue(r.is_traversal_valid_for('south', 'b', move), 'error for position: ' + move) for move in moves_invalid_for_south_traversal: self.assertFalse(r.is_traversal_valid_for('south', 'b', move), 'error for position: ' + move) r = Reversi(''' - - - - - - - - - - - w - - - - - - w w w - - - - - - w w - - - - - - w w - - - - - - w b b b - - - - w b - - - - - - b - - - - ''') self.assertTrue(r.is_traversal_valid_for('south', 'b', 'D1'))
def test_does_west_traversal_allow_valid_move(self): r = Reversi(''' - - - - - - - - - - - - - - - - - - - - - - - - - - - w b - - - - - - b w - - - - - - - - - - - - - - - - - - - - - - - - - - - ''') moves_valid_for_west_traversal = {'F5'} moves_invalid_for_west_traversal = self.all_moves - moves_valid_for_west_traversal for move in moves_valid_for_west_traversal: self.assertTrue(r.is_traversal_valid_for('west', 'b', move), 'error for position: ' + move) for move in moves_invalid_for_west_traversal: self.assertFalse(r.is_traversal_valid_for('west', 'b', move), 'error for position: ' + move) r = Reversi(''' - - - - - - - - - - - - - - - - - - w b w - - - - - w w b b - - - - w b b w - - b - b b w w - - b w w w - - - - b - - - - - - - ''') self.assertFalse(r.is_traversal_valid_for('west', 'w', 'B6'))
def start(): data = json.loads(request.data) if ('table' in data): reversi = Reversi(data['table']) else: reversi = Reversi() print(jsonify(reversi.getTabuleiro())) return jsonify(reversi.getJogo())
def reset(self) -> torch.Tensor: # (num_worker, 3, SIZE, SIZE) self.historys = [[] for _ in range(self.num_workers)] self.end = [False for _ in range(self.num_workers)] black = Reversi() white = Reversi() white.place(Minimax.brain(white, 1), 1) self.reversis = [deepcopy(black) for _ in range(self.num_workers // 2)] + [deepcopy(white) for _ in range(self.num_workers // 2)] states = self.pool.map(getBoardState, self.reversis) return torch.Tensor(states)
def test_white_wins(self): # set board ''' 0 1 2 3 4 5 6 7 O │ O │ O │ O │ O │ O │ O │ O │0 ───┼───┼───┼───┼───┼───┼───┼───┼ * │ O │ O │ O │ O │ O │ O │ O │1 ───┼───┼───┼───┼───┼───┼───┼───┼ * │ * │ O │ O │ O │ O │ O │ O │2 ───┼───┼───┼───┼───┼───┼───┼───┼ * │ * │ * │ O │ O │ O │ O │ O │3 ───┼───┼───┼───┼───┼───┼───┼───┼ * │ * │ * │ * │ O │ O │ O │ O │4 ───┼───┼───┼───┼───┼───┼───┼───┼ * │ * │ * │ * │ * │ O │ O │ O │5 ───┼───┼───┼───┼───┼───┼───┼───┼ * │ * │ * │ * │ * │ * │ O │ O │6 ───┼───┼───┼───┼───┼───┼───┼───┼ * │ * │ * │ * │ * │ * │ * │ O │7 ───┼───┼───┼───┼───┼───┼───┼───┼ ''' self.game = Reversi() for row in range(0, 8): for column in range(row, 8): self.game.board[Coord(row, column)] = self.game.WHITE for row in range(7, 0, -1): for column in range(row - 1, -1, -1): self.game.board[Coord(row, column)] = self.game.BLACK self.game.black_player.result = len(self.game.black_player_discs()) self.game.white_player.result = len(self.game.white_player_discs()) self.assertEqual(self.game.outcome(), self.game.GAME_STATES["WHITE_WINS"])
def test_move_changes_player(self): r = Reversi() self.assertEqual(r.player, 'b') r.move('A1') self.assertEqual(r.player, 'w') r.move('A2') self.assertEqual(r.player, 'b')
def setUp(self): # set board ''' 0 1 2 3 4 5 6 7 │ │ O │ O │ O │ │ │ O │0 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ * │ │ │ │ │1 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ │ │2 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ │ │3 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ │ │4 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ │ │5 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ │ │6 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ * │ * │7 ───┼───┼───┼───┼───┼───┼───┼───┼ ''' self.game = Reversi() self.game.board[Coord(1, 3)] = self.game.BLACK self.game.board[Coord(0, 2)] = self.game.WHITE self.game.board[Coord(0, 3)] = self.game.WHITE self.game.board[Coord(0, 4)] = self.game.WHITE self.game.board[Coord(7, 7)] = self.game.BLACK self.game.board[Coord(7, 6)] = self.game.BLACK self.game.board[Coord(3, 3)] = self.game.EMPTY self.game.board[Coord(3, 4)] = self.game.EMPTY self.game.board[Coord(4, 3)] = self.game.EMPTY self.game.board[Coord(4, 4)] = self.game.EMPTY
def test_black_wins(self): # set board ''' 0 1 2 3 4 5 6 7 │ │ │ │ │ │ │ │0 ───┼───┼───┼───┼───┼───┼───┼───┼ O │ O │ O │ O │ O │ O │ O │ O │1 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ │ │2 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ │ │3 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ │ │4 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ │ │5 ───┼───┼───┼───┼───┼───┼───┼───┼ * │ * │ * │ * │ * │ * │ * │ * │6 ───┼───┼───┼───┼───┼───┼───┼───┼ * │ * │ * │ * │ * │ * │ * │ * │7 ───┼───┼───┼───┼───┼───┼───┼───┼ ''' self.game = Reversi() self.game.board[Coord(3, 3)] = self.game.EMPTY self.game.board[Coord(3, 4)] = self.game.EMPTY self.game.board[Coord(4, 3)] = self.game.EMPTY self.game.board[Coord(4, 4)] = self.game.EMPTY for column in range(8): self.game.board[Coord(1, column)] = self.game.WHITE for row in range(6, 8): for column in range(8): self.game.board[Coord(row, column)] = self.game.BLACK self.game.black_player.result = len(self.game.black_player_discs()) self.game.white_player.result = len(self.game.white_player_discs()) self.assertEqual(self.game.outcome(), self.game.GAME_STATES["BLACK_WINS"])
def test_tie(self): # set board ''' 0 1 2 3 4 5 6 7 O │ O │ O │ O │ O │ O │ O │ O │0 ───┼───┼───┼───┼───┼───┼───┼───┼ O │ O │ O │ O │ O │ O │ O │ O │1 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ │ │2 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ │ │3 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ │ │4 ───┼───┼───┼───┼───┼───┼───┼───┼ │ │ │ │ │ │ │ │5 ───┼───┼───┼───┼───┼───┼───┼───┼ * │ * │ * │ * │ * │ * │ * │ * │6 ───┼───┼───┼───┼───┼───┼───┼───┼ * │ * │ * │ * │ * │ * │ * │ * │7 ───┼───┼───┼───┼───┼───┼───┼───┼ ''' self.game = Reversi() self.game.board[Coord(3, 3)] = self.game.EMPTY self.game.board[Coord(3, 4)] = self.game.EMPTY self.game.board[Coord(4, 3)] = self.game.EMPTY self.game.board[Coord(4, 4)] = self.game.EMPTY for row in range(2): for column in range(8): self.game.board[Coord(row, column)] = self.game.WHITE for row in range(6, 8): for column in range(8): self.game.board[Coord(row, column)] = self.game.BLACK self.assertEqual(self.game.outcome(), self.game.GAME_STATES['TIE'])
def test_reversi_skipPut(): game = Reversi() game.reset() assert not game.skipPut() game.board[3][3] = game.board[3][4] = game.board[4][3] = game.board[4][4] = reversi.EMPTY assert game.skipPut() assert game.history[-1] == []
def test_reversi_reset(): game = Reversi() game.reset() assert game.current == reversi.BLACK assert len(game.history) == 0 assert len(game.board) == 8 assert all(len(col) == 8 for col in game.board)
def test_reversi_state(self): app = Reversi() app.state = 'INIT' self.assertEqual(app.state, app.INIT) self.assertEqual(app.game, app._Reversi__init) app.state = 'DEMO' self.assertEqual(app.state, app.DEMO) self.assertEqual(app.game, app._Reversi__demo) app.state = 'PLAY' self.assertEqual(app.state, app.PLAY) self.assertEqual(app.game, app._Reversi__play) app.state = 'END' self.assertEqual(app.state, app.END) self.assertEqual(app.game, app._Reversi__end) app.state = 'REINIT' self.assertEqual(app.state, app.REINIT) self.assertEqual(app.game, app._Reversi__reinit) app.state = 'UNDEFINED' self.assertEqual(app.state, 'UNDEFINED') self.assertEqual(app.game, app._Reversi__reinit)
def main(): game = Reversi() run_game = True while run_game: print('Starting new game!', 'Black goes first, then white', sep = '\n') player_color = validate('Enter \'b\' to choose to play black, \'w\' to choose white: ', ['b', 'w']) difficulty = validate('Enter \'1\' to choose easy computer opponent, \'2\' for hard computer opponent: ', ['1', '2']) game.newGame() game.setPlayerColour(player_color) board_and_score(game) game_over = False while not game_over: # This loop is the entire round if player_color == 'w': # Computer gets to go first if not game.isGameOver(): computer_turn(difficulty, game) if not game.isGameOver(): game_over = human_turn(player_color, game) else: game_over = True else: game_over = True elif player_color == 'b': # Player gets to go first if not game.isGameOver(): game_over = human_turn(player_color, game) if not game.isGameOver() and not game_over: computer_turn(difficulty, game) else: game_over = True else: game_over = True print('Game over!') restart = validate('Do you want to play again (y/n)? ', ['y', 'n']) if restart == 'n': print('Goodbye!') run_game = False
def play_against_alphabeta(num_games, iterations, depth): mcts_wins_as_first = 0 mcts_wins_as_second = 0 draws = 0 for _ in tqdm(range(num_games // 2)): game = Reversi() mcts = MCTS(game) # mcts.run(20) for step in range(70): if step % 2 == 0: mcts.run(iterations) move = mcts.get_move() else: move = alphabeta_move(game, depth) # mcts.make_move(move) game.move(move) mcts = MCTS(game) if game.terminal(): winner = game.winner() if winner == 1: mcts_wins_as_first += 1 elif winner == 0.5: draws += 1 break for _ in tqdm(range(num_games // 2)): game = Reversi() mcts = MCTS(game) # mcts.run(20) for step in range(70): if step % 2 == 0: move = alphabeta_move(game, depth) else: mcts.run(iterations) move = mcts.get_move() # mcts.make_move(move) game.move(move) mcts = MCTS(game) if game.terminal(): winner = game.winner() if winner == 0: mcts_wins_as_second += 1 elif winner == 0.5: draws += 1 break print('winrate: {}+{}/{}, draws: {}'.format(mcts_wins_as_first, mcts_wins_as_second, num_games, draws))
def test_reversi_load_extra_file_format_error(self): app = Reversi() app.err_msg = TestErrMsg() with captured_stdout() as stdout: app._load_extra_file('./not_json.json') lines = stdout.getvalue().splitlines() self.assertEqual(lines[0], 'フォーマットエラーのため登録ファイルが読み込めませんでした')
def test_reversi_load_extra_file_no_file_error(self): app = Reversi() app.err_msg = TestErrMsg() with captured_stdout() as stdout: app._load_extra_file('./no_file') lines = stdout.getvalue().splitlines() self.assertEqual(lines[0], '指定された登録ファイルが見つかりませんでした')
def test_reversi_undo(): game_1, game_2 = Reversi(), Reversi() game_1.reset() game_2.reset() assert game_1.board == game_2.board assert game_1.history == game_2.history == [] assert game_1.undo() == (False, 0) game_1.put(2, 4) assert game_1.board != game_2.board assert game_1.history != game_2.history assert game_1.undo() == (True, 2) assert game_1.board == game_2.board assert game_1.history == game_2.history game_1.history.append([]) game_1.toggle() assert game_1.undo() == (True, 0)
def test_reversi_put(): game = Reversi() game.reset() assert game.put(2, 4) assert game.history[-1] == [(3, 4), (2, 4)] assert not game.put(2, 4) assert not game.put(0, 0) assert not game.put((0, 0)) # Tuple unpacking test assert game.put((2, 3))
def test_reversi_any(): game = Reversi() game.reset() assert game.any() assert game.any(reversi.BLACK) assert game.any(reversi.WHITE) game.board[3][3] = game.board[3][4] = game.board[4][3] = game.board[4][4] = reversi.EMPTY assert not game.any(reversi.BLACK) assert not game.any(reversi.WHITE)
def __init__(self, width, height): self.height = height self.width = width self.game = Reversi() self.is_clicked = False self.end = False self.last_move = [] self.in_menu = True self.player = -1 self.computer = 1
def test_reversi_hash(): import random game = Reversi() s = set() s.add(game) assert len(s) == 1 for i in range(12): game.put(random.choice(game.getAvailables())) assert game not in s s.add(game)
def test_reversi__init(self): class TestWindow: def __init__(self): self.extra_file = None def init_screen(self): print('init_screen') def set_state(self, state): print(state) def _load_extra_file(extra_file): print(extra_file) # no extra_file app = Reversi() app.window = TestWindow() app._load_extra_file = _load_extra_file with captured_stdout() as stdout: app._Reversi__init() lines = stdout.getvalue().splitlines() self.assertEqual(lines[0], 'init_screen') self.assertEqual(lines[1], 'normal') with self.assertRaises(IndexError): print(lines[2]) self.assertEqual(app.state, Reversi.DEMO) # extra_file app = Reversi() app.window = TestWindow() app.window.extra_file = 'extra_file' app._load_extra_file = _load_extra_file with captured_stdout() as stdout: app._Reversi__init() lines = stdout.getvalue().splitlines() self.assertEqual(lines[0], 'init_screen') self.assertEqual(lines[1], 'normal') self.assertEqual(lines[2], 'extra_file') self.assertEqual(app.window.extra_file, '') self.assertEqual(app.state, Reversi.DEMO)
def test_reversi_copy(): game = Reversi() game.reset() game.put(2, 4) other = game.copy() assert game is not other assert game.board == other.board assert all(a is not b for a, b in zip(game.board, other.board)) assert game.current == other.current assert game.history == other.history assert all(a is not b for a, b in zip(game.history, other.history))
def board_images(data=None, size=1040): if data is None: return 'NG' r = Reversi() r.insert(data) r.create_board_images() r.update_board_images() buf = BytesIO() r.board_images[size].save(buf, 'png') buf.seek(0, 0) return send_file(buf, mimetype='image/png')
def test_reversi_game_start(self): def test_thread_start(game_thread): print(game_thread.daemon) app = Reversi() app._thread_start = test_thread_start with captured_stdout() as stdout: app.game_start() lines = stdout.getvalue().splitlines() self.assertEqual(lines[0], 'True')
def test_reversi_thread_start(self): class TestThreadStart: def start(self): print('thread.start()') app = Reversi() with captured_stdout() as stdout: app._thread_start(TestThreadStart()) lines = stdout.getvalue().splitlines() self.assertEqual(lines[0], 'thread.start()')
def test_reversi_keyword_arg(self): app = Reversi(turn_disc_wait=0.001, sleep_time_play=0.002, sleep_time_end=0.003, sleep_time_turn=0.004, sleep_time_move=0.005) self.assertEqual(app.turn_disc_wait, 0.001) self.assertEqual(app.sleep_time_play, 0.002) self.assertEqual(app.sleep_time_end, 0.003) self.assertEqual(app.sleep_time_turn, 0.004) self.assertEqual(app.sleep_time_move, 0.005)
def test_reversi_gameloop(self): def test_game(): print('test_game') return True app = Reversi() app.game = test_game with captured_stdout() as stdout: app.gameloop() lines = stdout.getvalue().splitlines() self.assertEqual(lines[0], 'test_game')
def ia(): data = json.loads(request.data) reversi = Reversi(data['tabuleiro']) jogadorAtual = 'B' ia = Arvore(reversi, jogadorAtual) jogadaIA = ia.getJogada() jogadaValida = reversi.fazerMovimento(jogadorAtual, jogadaIA) jogo = reversi.getJogo() return jsonify(jogo)