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)
