def run_games(config):
game = Othello()
model = ""
x = config.iterations
while(x != 0):
x -= 1
models = sorted(glob.glob(config.data.model_location+"*.h5"))
if model == "":
model = models[-1]
print("Loading new model: %s" % util.getPlayerName(model))
ai = AIPlayer(config.buffer_size, config.game.simulation_num_per_move, model=model)
elif models[-1] != model:
model = models[-1]
print("Loading new model: %s" % util.getPlayerName(model))
ai.load(model)
start=time()
for j in range(config.nb_game_in_file):
util.print_progress_bar(j, config.nb_game_in_file, start=start)
side = -1
turn = 1
while not game.game_over():
ai.tau = config.game.tau_1
if config.game.tau_swap < turn:
ai.tau = config.game.tau_2
t = ai.pick_move(game, side)
game.play_move(t[0], t[1], side)
side *= -1
turn += 1
ai.update_buffer(game.get_winner())
game.reset_board()
#print("Average Game Time: ", (time()-start)/(config.nb_game_in_file))
util.print_progress_bar(config.nb_game_in_file, config.nb_game_in_file, start=start)
save_games(config, ai.buffer)
t.join()
def test_is_legal_move(self):
game = Othello()
game.initialize_board()
# Test illegal moves before making any legal moves
illegal_moves = [(), (3, 3), (3, 4), (4, 3), (4, 4), (-1, 0),
(8, 2), (-5, 9), (0, 0), (3, 1), (2, 2), (5, 3)]
for move in illegal_moves:
self.assertFalse(game.is_legal_move(move))
# Test legal moves for player 1 (black tile)
legal_moves = [(2, 3), (3, 2), (5, 4), (4, 5)]
for move in legal_moves:
self.assertTrue(game.is_legal_move(move))
# Let player 1 make a legal move
game.move = (2, 3)
game.make_move()
# Test legal/illegal moves for player 2 (white tile)
game.current_player = 1
legal_moves = [(2, 4), (2, 2), (4, 2)]
for move in legal_moves:
self.assertTrue(game.is_legal_move(move))
illegal_moves = [(3, 2), (5, 3), (5, 4), (4, 5), (3, 5), (6, 1)]
for move in illegal_moves:
self.assertFalse(game.is_legal_move(move))
def test__init__():
othello = Othello(400, 4, "Name", "black")
board = Board(400, 4)
gc = GameController(400, 400, "Name", "black")
tiles = [Tile(100) for _ in range(16)]
tile = tiles.pop()
tile.set_white()
board.grids[1][1] = tile
tile = tiles.pop()
tile.set_black()
board.grids[1][2] = tile
tile = tiles.pop()
tile.set_black()
board.grids[2][1] = tile
tile = tiles.pop()
tile.set_white()
board.grids[2][2] = tile
assert othello.board == board
assert othello.gc == gc
assert othello.tiles == tiles
assert othello.valid_grids == set({})
assert othello.is_black
assert not othello.is_control
def test_flip():
othello = Othello(400, 4, "Name", "black")
othello.flip(0, 0, "dr", 1)
assert othello.board.grids[1][1].is_black
othello.flip(0, 0, "dr", 1)
othello.flip(0, 3, "dl", 1)
assert not othello.board.grids[1][2].is_black
othello.flip(0, 3, "dl", 1)
othello.flip(3, 0, "ur", 1)
assert not othello.board.grids[2][1].is_black
othello.flip(3, 0, "ur", 1)
othello.flip(3, 3, "ul", 1)
assert othello.board.grids[2][2].is_black
othello.flip(3, 3, "ul", 1)
othello.flip(1, 0, "r", 1)
assert othello.board.grids[1][1].is_black
othello.flip(1, 0, "r", 1)
othello.flip(1, 3, "l", 1)
assert not othello.board.grids[1][2].is_black
othello.flip(1, 3, "l", 1)
othello.flip(0, 1, "d", 1)
assert othello.board.grids[1][1].is_black
othello.flip(0, 1, "d", 1)
othello.flip(3, 1, "u", 1)
assert not othello.board.grids[2][1].is_black
othello.flip(3, 1, "u", 1)
def test_get_valid_flips(self):
# Set up a testable game
game = Othello(8)
game.active_color = 'white'
game.board.record_tile(Point(2, 2), 'white')
game.board.record_tile(Point(5, 4), 'black')
game.board.record_tile(Point(6, 5), 'black')
game.board.record_tile(Point(7, 5), 'white')
game.board.record_tile(Point(6, 6), 'white')
game.board.record_tile(Point(5, 6), 'black')
game.board.record_tile(Point(5, 7), 'black')
game.board.record_tile(Point(4, 6), 'black')
# Test good input (a move that results in a variety of flips or lack
# thereof in each direction)
test_move = game.get_valid_flips(Point(5, 5))
expected_outcome = [Point(6, 5), Point(4, 4), Point(3, 3)]
self.assertEqual(test_move, expected_outcome)
# Test bad inputs:
# 1. Move outside the board
# 2. Move that targets an occupied square
# 3. Argument is None instead of a point
outside_board_test = game.get_valid_flips(Point(100, 100))
occupied_board_test = game.get_valid_flips(Point(2, 2))
none_point_test = game.get_valid_flips(None)
self.assertEqual(outside_board_test, [])
self.assertEqual(occupied_board_test, [])
self.assertEqual(none_point_test, [])
def test_update_info():
othello = Othello(400, 4, "Name", "black")
othello.gc.is_black = False
othello.is_control = True
othello.update_info()
assert othello.gc.is_black
assert not othello.is_control
def minimax(board,
depth,
player,
alpha=-np.inf,
beta=np.inf,
eval_func='pos_score',
king_version=False):
if depth == 0:
if eval_func == 'pos_score':
return pos_score_sum(board)
elif eval_func == 'mobi':
return mobility(board)
elif eval_func == 'pos_mobi':
return pos_plus_mobi(board)
elif eval_func == 'king_pos_score': # this is for King Othello
return king_pos_score_sum(board)
if not king_version:
game = Othello()
else:
game = KingOthello()
game.board = board
game.current_player = player
possible_moves = game.find_all_valid_moves()
if possible_moves:
if player == BLACK: # maximizing player
max_eval = -np.inf
for move in possible_moves:
game_copy = deepcopy(game)
game_copy.take_move(move[0], move[1])
eval = minimax(game_copy.board, depth - 1, opposite(player),
alpha, beta)
max_eval = max(max_eval, eval)
alpha = max(alpha, eval)
if beta <= alpha:
break
return max_eval
else: # WHITE, minimizing player
min_eval = np.inf
for move in possible_moves:
game_copy = deepcopy(game)
game_copy.take_move(move[0], move[1])
eval = minimax(game_copy.board, depth - 1, opposite(player),
alpha, beta)
min_eval = min(min_eval, eval)
beta = min(beta, eval)
if beta <= alpha:
break
return min_eval
else: # no possible move for current player
game.switch_turn()
possible_moves = game.find_all_valid_moves(
) # check whether opponent has moves
if possible_moves:
return minimax(game.board, depth - 1, opposite(player), alpha,
beta) # hand over to opponent, nothing changed
else: # the opponent has no moves either, game over
return pos_score_sum(game.board)
def test_has_tile_to_flip(self):
game = Othello()
game.initialize_board()
# Test when the board is in the initial state
# Test two moves for player 1 (black tile) in all flipping directions
self.assertTrue(game.has_tile_to_flip((2, 3), (+1, 0)))
no_flip_dirs = [(-1, -1), (-1, +1), (0, -1), (0, +1),
(+1, -1), (-1, 0), (+1, +1)]
for direction in no_flip_dirs:
self.assertFalse(game.has_tile_to_flip((2, 3), direction))
self.assertTrue(game.has_tile_to_flip((3, 2), (0, +1)))
no_flip_dirs = [(-1, -1), (-1, +1), (0, -1), (+1, 0),
(+1, -1), (-1, 0), (+1, +1)]
for direction in no_flip_dirs:
self.assertFalse(game.has_tile_to_flip((3, 2), direction))
# Let player 1 make a legal move
game.move = (2, 3)
game.make_move()
# Test two moves for player 2 (white tile)
game.current_player = 1
self.assertTrue(game.has_tile_to_flip((2, 4), (+1, 0)))
no_flip_dirs = [(-1, -1), (-1, +1), (0, -1), (0, +1),
(+1, -1), (-1, 0), (+1, +1)]
for direction in no_flip_dirs:
self.assertFalse(game.has_tile_to_flip((2, 4), direction))
self.assertTrue(game.has_tile_to_flip((2, 2), (+1, +1)))
no_flip_dirs = [(-1, -1), (-1, 0), (-1, +1), (0, -1),
(0, +1), (+1, -1), (+1, 0)]
for direction in no_flip_dirs:
self.assertFalse(game.has_tile_to_flip((2, 2), direction))
# Test when player 1 has tiles to flip but player 2 does not
game.board = [[2, 0, 2, 2, 2, 2, 2, 2],
[2, 2, 2, 2, 1, 1, 1, 1],
[2, 1, 2, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1],
[2, 2, 1, 1, 1, 2, 2, 1],
[0, 2, 1, 1, 2, 2, 2, 1],
[1, 2, 1, 2, 2, 2, 2, 1],
[1, 2, 2, 2, 2, 2, 0, 1]]
game.current_player = 0
flip_dirs = {(0, 1) : [(+1, 0), (+1, +1)],
(5, 0) : [(-1, 0), (0, +1), (-1, +1)],
(7, 6) : [(-1, 0), (0, -1), (-1, -1)]}
for move in flip_dirs:
for direction in flip_dirs[move]:
self.assertTrue(game.has_tile_to_flip(move, direction))
game.current_player = 1
for direction in MOVE_DIRS:
self.assertFalse(game.has_tile_to_flip((0, 1), direction))
self.assertFalse(game.has_tile_to_flip((5, 0), direction))
self.assertFalse(game.has_tile_to_flip((7, 6), direction))
def mobility(board):
# defined number of possible moves : black - white
g1 = Othello()
g1.board = board
g1.current_player = BLACK
score_black = len(g1.find_all_valid_moves())
g1.current_player = WHITE
score_white = len(g1.find_all_valid_moves())
return score_black - score_white
def test_report_winner(self, mocked_print):
game = Othello(4)
game.report_winner()
game = Othello(4)
game.board.black_tiles = 3
game.report_winner()
game = Othello(4)
game.board.white_tiles = 4
game.report_winner()
# Check that report_winner prints correct text to the terminal
self.assertEqual(mocked_print.mock_calls, \
[call("Game over! Score is 2 for black and 2 for white."),
call("It's a tie!"),
call("Game over! Score is 3 for black and 2 for white."),
call("Black wins!"),
call("Game over! Score is 2 for black and 4 for white."),
call("White wins!")])
def test_update_legal_move():
othello = Othello(400, 4, "Name", "black")
othello.update_legal_move()
# worked in "d"
assert isinstance(othello.board.grids[0][1], Record)
assert not othello.board.grids[0][1].record["u"]
assert othello.board.grids[0][1].record["d"] == 1
assert not othello.board.grids[0][1].record["l"]
assert not othello.board.grids[0][1].record["r"]
assert not othello.board.grids[0][1].record["ul"]
assert not othello.board.grids[0][1].record["ur"]
assert not othello.board.grids[0][1].record["dl"]
assert not othello.board.grids[0][1].record["dr"]
# worked in "r"
assert isinstance(othello.board.grids[1][0], Record)
assert othello.board.grids[1][0].record["r"] == 1
# worked in "u"
assert isinstance(othello.board.grids[3][2], Record)
assert othello.board.grids[3][2].record["u"] == 1
# worked in "l"
assert isinstance(othello.board.grids[2][3], Record)
assert othello.board.grids[2][3].record["l"] == 1
assert not isinstance(othello.board.grids[0][0], Record)
# worked in "ul"
othello.board.grids[1][1].flip()
othello.update_legal_move()
assert isinstance(othello.board.grids[3][3], Record)
assert othello.board.grids[3][3].record["ul"] == 1
othello.board.grids[1][1].flip()
# worked in "ur"
othello.board.grids[2][1].flip()
othello.update_legal_move()
assert isinstance(othello.board.grids[3][0], Record)
assert othello.board.grids[3][0].record["ur"] == 1
othello.board.grids[2][1].flip()
# worked in "dr"
othello.board.grids[2][2].flip()
othello.update_legal_move()
assert isinstance(othello.board.grids[0][0], Record)
assert othello.board.grids[0][0].record["dr"] == 1
othello.board.grids[2][2].flip()
# worked in "dl"
othello.board.grids[1][2].flip()
othello.update_legal_move()
assert isinstance(othello.board.grids[0][3], Record)
assert othello.board.grids[0][3].record["dl"] == 1
othello.board.grids[1][2].flip()
def main():
random_state = random.Random()
player_w = OthelloAgent("W", RandomAction(random_state))
player_b = OthelloAgent("B", RandomAction(random_state))
environment = Othello(player_w, player_b)
episode = OthelloVerboseEpisode()
run_episode(environment, episode)
def __call__(self, number_of_games):
for i in range(number_of_games):
#print("Training game:",i)
game = Othello(self.window, self.players, self.affichage)
game()
self.games.append(game)
for id_player, player in enumerate(self.players):
if isinstance(player, NeuralNetwork):
self.teach(id_player, game)
self.players[id_player].train()
def test_skip_or_finish():
# test when game is not finished
othello = Othello(400, 4, "Name", "black")
othello.update_legal_move()
othello.skip_or_finish()
assert not othello.gc.is_finished
# test when skipping this turn
othello.board.take_off(1, 1)
othello.board.take_off(1, 2)
othello.board.take_off(2, 1)
othello.board.take_off(2, 2)
for i in range(4):
othello.is_black = False
othello.put_tile_on(0, i)
if i > 0:
othello.is_black = True
othello.put_tile_on(1, i)
othello.update_legal_move()
othello.skip_or_finish()
assert othello.gc.is_skip
assert not othello.is_black
othello.control(2, 0)
othello.update_legal_move()
othello.skip_or_finish()
assert not othello.gc.is_skip
# test whether no empty grids will finish the game
othello = Othello(400, 2, "Name", "black")
othello.skip_or_finish()
assert othello.gc.is_finished
# test whether no legal moves will finish the game
othello.board.take_off(0, 0)
othello.skip_or_finish()
assert othello.gc.is_finished
# test whether all tiles are in one color will finish the game
othello.board.take_off(1, 1)
othello.skip_or_finish()
assert othello.gc.is_finished
def main():
episodes = 10
random_state = random.Random()
player_w = OthelloAgent("W", MonteCarloTreeSearch())
player_b = OthelloAgent("B", RandomAction(random_state))
environment = Othello(player_w, player_b)
run_timed_episodes(environment, episodes)
def test_put_tile_on():
othello = Othello(400, 4, "Name", "black")
tile = Tile(100)
othello.put_tile_on(0, 0)
assert othello.board.grids[0][0] == tile
othello.is_black = False
othello.put_tile_on(0, 0)
tile.flip()
assert othello.board.grids[0][0] == tile
def main():
episodes = 10
random_state = random.Random()
player_w = OthelloAgent("W", AlphaBetaPruning(2))
player_b = OthelloAgent("B", RandomAction(random_state))
environment = Othello(player_w, player_b)
run_timed_episodes(environment, episodes)
def test_get_coord(self):
# Test for board of size 4x4
game = Othello(4)
# Test valid points (on board but not on line)
valid_points = [(40.1, 39.5), (75.0, -77.2), (-22.78, -11.16),
(-61.99, 5.0), (-71.23, 1.0)]
expected_results = [(1, 2), (3, 3), (2, 1), (1, 0), (1, 0)]
for i in range(len(valid_points)):
game.get_coord(valid_points[i][0], valid_points[i][1])
self.assertEqual(game.move, expected_results[i])
# Test invalid points (on line or not on board)
invalid_points = [(0.0, 0.0), (-100.0, 100.0), (150.23, 77.0),
(5.0, -100.10), (-68.98, 177.54), (-71.23, 0.0)]
for point in invalid_points:
game.get_coord(point[0], point[1])
self.assertEqual(game.move, ())
# Test for board of size 8x8
game = Othello()
# Test valid points (on board but not on line)
valid_points = [(40.1, 39.5), (175.0, -77.2),
(-22.78, -11.16), (-61.99, 105.1),
(-159.23, 175.02), (-111.0, 99.9), (82.56, 130.78)]
expected_results = [(3, 4), (5, 7), (4, 3), (1, 2),
(0, 0), (2, 1), (1, 5)]
for i in range(len(valid_points)):
game.get_coord(valid_points[i][0], valid_points[i][1])
self.assertEqual(game.move, expected_results[i])
# Test invalid points (on line or not on board)
invalid_points = [(0.0, 0.0), (-100.0, 100.0), (100.0, 100.0),
(250.23, 77.0), (5.0, -200.10), (-68.98, 377.54),
(-1.5, 200.0), (200.0, 200.0), (-200.0, -200.0),
(200.0, -100.0), (-71.23, 0.0)]
for point in invalid_points:
game.get_coord(point[0], point[1])
self.assertEqual(game.move, ())
def test_game_AI():
othello = Othello(400, 4, "Name", "white")
othello.update_info()
othello.game_AI()
assert any([
isinstance(othello.board.grids[0][1], Tile),
isinstance(othello.board.grids[1][0], Tile),
isinstance(othello.board.grids[3][2], Tile),
isinstance(othello.board.grids[2][3], Tile)
])
for i, j in [(0, 1), (1, 0), (3, 2), (2, 3)]:
if isinstance(othello.board.grids[i][j], Tile):
assert othello.board.grids[i][j].is_black
def test_init(self):
# Test for board of size 0
game = Othello(0)
self.assertEqual(game.n, 0)
self.assertEqual(game.board, [])
# Test for board of size 2x2
game = Othello(2)
self.assertEqual(game.n, 2)
expected_board = [[0, 0], [0, 0]]
self.assertEqual(game.board, expected_board)
# Test for board of size 4x4
game = Othello(4)
self.assertEqual(game.n, 4)
expected_board = [[0, 0, 0, 0], [0, 0, 0, 0],
[0, 0, 0, 0], [0, 0, 0, 0]]
self.assertEqual(game.board, expected_board)
self.assertEqual(game.square_size, 50)
self.assertEqual(game.board_color, 'forest green')
self.assertEqual(game.line_color, 'black')
self.assertEqual(game.tile_size, 20)
self.assertEqual(game.tile_colors, ['black', 'white'])
self.assertEqual(game.move, ())
self.assertEqual(game.current_player, 0)
self.assertEqual(game.num_tiles, [2, 2])
# Test for board of size 8x8
game = Othello()
self.assertEqual(game.n, 8)
self.assertEqual(game.board, EMPTY_BOARD)
self.assertEqual(game.square_size, 50)
self.assertEqual(game.board_color, 'forest green')
self.assertEqual(game.line_color, 'black')
self.assertEqual(game.tile_size, 20)
self.assertEqual(game.tile_colors, ['black', 'white'])
self.assertEqual(game.move, ())
self.assertEqual(game.current_player, 0)
self.assertEqual(game.num_tiles, [2, 2])
def test_initialize_board(self):
# Test for board of size 0
game = Othello(0)
game.initialize_board()
self.assertEqual(game.board, [])
# Test for board of size 2x2
game = Othello(2)
game.initialize_board()
expected_board = [[2, 1], [1, 2]]
self.assertEqual(game.board, expected_board)
# Test for board of size 4x4
game = Othello(4)
game.initialize_board()
expected_board = [[0, 0, 0, 0], [0, 2, 1, 0],
[0, 1, 2, 0], [0, 0, 0, 0]]
self.assertEqual(game.board, expected_board)
# Test for board of size 8x8
game = Othello()
game.initialize_board()
self.assertEqual(game.board, INITIAL_BOARD)
def test_eq(self):
game1 = Othello(4)
game2 = Othello(4)
game3 = Othello(8)
self.assertTrue(game1 == game2)
self.assertFalse(game1 == game3)
self.assertFalse(game2 == game3)
game1.board[0][0] = 1
self.assertFalse(game1 == game2)
game2.board[0][0] = 1
self.assertTrue(game1 == game2)
game1.current_player = 1
self.assertFalse(game1 == game2)
game2.current_player = 1
self.assertTrue(game1 == game2)
game2.current_player = 2
self.assertFalse(game1 == game2)
def test_is_valid_coord(self):
# Test for board of size 0 (no valid coordinate)
game = Othello(0)
coords = [(0, 0), (1, 2), (3, 8), (0, 1), (-4, 3), (8, -7), (-1, -5)]
for coord in coords:
self.assertFalse(game.is_valid_coord(coord[0], coord[1]))
# Test for board of size 4x4
game = Othello(4)
invalid_coords = [(4, 0), (1, 4), (5, 8), (3, 9), (0, -1),
(-2, 3), (8, -7), (-1, -5), (-2, -2)]
for coord in invalid_coords:
self.assertFalse(game.is_valid_coord(coord[0], coord[1]))
valid_coords = []
for i in range(4):
for j in range(4):
valid_coords.append((i, j))
for coord in valid_coords:
self.assertTrue(game.is_valid_coord(coord[0], coord[1]))
# Test for board of size 8x8
game = Othello()
invalid_coords = [(8, 0), (1, 8), (9, 10), (3, 9), (0, -1),
(-2, 3), (8, -7), (-1, -5), (-2, -2)]
for coord in invalid_coords:
self.assertFalse(game.is_valid_coord(coord[0], coord[1]))
valid_coords = []
for i in range(8):
for j in range(8):
valid_coords.append((i, j))
for coord in valid_coords:
self.assertTrue(game.is_valid_coord(coord[0], coord[1]))
def test_convert_coord(self):
# Test for board of size 4x4
game = Othello(4)
valid_coords = [(0.0, 0.0), (40.1, 39.5), (75.0, -77.2),
(-22.78, -11.16), (-61.99, 5.0), (-71.23, 0.0)]
expected_results = [(1, 2), (1, 2), (3, 3), (2, 1), (1, 0), (1, 0)]
for i in range(len(valid_coords)):
self.assertEqual(game.convert_coord(valid_coords[i][0],
valid_coords[i][1]), expected_results[i])
invalid_coords = [(-100.0, 100.0), (100.0, 100.0), (150.23, 77.0),
(5.0, -100.10), (-68.98, 177.54), (-1.5, 200.2)]
for i in range(len(invalid_coords)):
self.assertEqual(game.convert_coord(invalid_coords[i][0],
invalid_coords[i][1]), ())
# Test for board of size 8x8
game = Othello()
valid_coords = [(0.0, 0.0), (40.1, 39.5), (175.0, -77.2),
(-22.78, -11.16), (-61.99, 105.1), (-71.23, 0.0),
(-159.23, 175.02), (-111.0, 99.9), (82.56, 130.78),
(-100.0, 100.0), (100.0, 100.0)]
expected_results = [(3, 4), (3, 4), (5, 7), (4, 3), (1, 2), (3, 2),
(0, 0), (2, 1), (1, 5), (1, 2), (1, 6)]
for i in range(len(valid_coords)):
self.assertEqual(game.convert_coord(valid_coords[i][0],
valid_coords[i][1]), expected_results[i])
invalid_coords = [(250.23, 77.0), (5.0, -200.10), (-68.98, 377.54),
(-1.5, 200.0), (200.0, 200.0), (-200.0, -200.0),
(200.0, -100.0)]
for i in range(len(invalid_coords)):
self.assertEqual(game.convert_coord(invalid_coords[i][0],
invalid_coords[i][1]), ())
def test_make_move(self):
game = Othello()
game.initialize_board()
# Test making illegal moves before making any legal moves
illegal_moves = [(), (3, 3), (3, 4), (4, 3), (4, 4), (-1, 0),
(8, 2), (-5, 9), (0, 0), (3, 1), (2, 2), (5, 3)]
for move in illegal_moves:
game.move = move
game.make_move()
self.assertEqual(game.board, INITIAL_BOARD)
self.assertEqual(game.num_tiles, [2, 2])
# Test making legal moves for different players
game.move = (2, 3)
game.make_move()
self.assertEqual(game.board[2][3], 1)
self.assertEqual(game.board[3][3], 1)
self.assertEqual(game.board[4][3], 1)
game.current_player = 1
game.move = (2, 2)
game.make_move()
self.assertEqual(game.board[2][2], 2)
self.assertEqual(game.board[3][3], 2)
self.assertEqual(game.board[4][4], 2)
game.current_player = 0
game.move = (4, 5)
game.make_move()
self.assertEqual(game.board[4][3], 1)
self.assertEqual(game.board[4][4], 1)
self.assertEqual(game.board[4][5], 1)
# Test making illegal moves after making some legal moves
game.current_player = 1
game.move = (5, 4)
game.make_move()
self.assertEqual(game.board[5][4], 0)
game.move = (5, 2)
game.make_move()
self.assertEqual(game.board[5][2], 0)
game.move = (6, 0)
game.make_move()
self.assertEqual(game.board[6][0], 0)
def test_get_legal_moves(self):
game = Othello()
game.initialize_board()
# Test legal moves for player 1 (black tile)
legal_moves = [(2, 3), (3, 2), (4, 5), (5, 4)]
self.assertEqual(game.get_legal_moves(), legal_moves)
# Let player 1 make a legal move
game.move = (2, 3)
game.make_move()
# Test legal moves for player 2 (white tile)
game.current_player = 1
legal_moves = [(2, 2), (2, 4), (4, 2)]
self.assertEqual(game.get_legal_moves(), legal_moves)
# Test when player 1 has legal moves but player 2 has no legal moves
game.current_player = 0
game.board = [[2, 0, 2, 2, 2, 2, 2, 2],
[2, 2, 2, 2, 1, 1, 1, 1],
[2, 1, 2, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1],
[2, 2, 1, 1, 1, 2, 2, 1],
[0, 2, 1, 1, 2, 2, 2, 1],
[1, 2, 1, 2, 2, 2, 2, 1],
[1, 2, 2, 2, 2, 2, 0, 1]]
legal_moves = [(0, 1), (5, 0), (7, 6)]
self.assertEqual(game.get_legal_moves(), legal_moves)
game.current_player = 1
self.assertEqual(game.get_legal_moves(), [])
# Test when the board is full (both players have no legal moves)
game.board = [[2, 1, 2, 2, 2, 2, 2, 2], [2, 1, 1, 2, 1, 1, 1, 1],
[2, 1, 2, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 2, 1, 1], [1, 1, 1, 1, 1, 2, 1, 1],
[1, 2, 1, 2, 2, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1]]
self.assertEqual(game.get_legal_moves(), [])
game.current_player = 0
self.assertEqual(game.get_legal_moves(), [])
def test_control():
othello = Othello(400, 4, "Name", "black")
# test if I can make an illegal move
othello.update_info()
othello.control(0, 0)
assert not othello.board.grids[0][0]
assert othello.is_black
assert not othello.is_control
# test if I can make a legal move
othello.update_info()
othello.control(0, 1)
assert not othello.is_black
assert othello.is_control
assert isinstance(othello.board.grids[0][1], Tile)
assert othello.board.grids[0][1].is_black
assert isinstance(othello.board.grids[1][1], Tile)
assert othello.board.grids[1][1].is_black
def test_has_legal_move(self):
game = Othello()
game.initialize_board()
# Test when the board is in the initial state
self.assertTrue(game.has_legal_move())
# Test when player 1 (black tile) has legal moves
game.board = [[2, 0, 0, 1, 0, 0, 0, 2], [2, 1, 1, 1, 0, 0, 2, 0],
[2, 1, 2, 1, 2, 2, 2, 2], [1, 1, 1, 1, 1, 2, 1, 0],
[2, 2, 2, 1, 2, 1, 2, 0], [0, 2, 1, 1, 1, 2, 1, 2],
[1, 1, 2, 0, 1, 2, 1, 1], [1, 0, 0, 2, 1, 0, 0, 1]]
self.assertTrue(game.has_legal_move())
# Test when player 2 (white tile) has legal moves
game.current_player = 1
game.board = [[2, 0, 0, 1, 1, 1, 1, 2], [2, 1, 1, 2, 0, 0, 1, 1],
[2, 1, 2, 1, 2, 2, 1, 2], [1, 1, 1, 1, 1, 1, 2, 0],
[2, 2, 1, 1, 1, 2, 2, 0], [0, 2, 1, 1, 2, 2, 1, 2],
[1, 1, 1, 2, 2, 2, 2, 1], [1, 0, 1, 1, 1, 2, 0, 1]]
self.assertTrue(game.has_legal_move())
# Test when player 2 (white tile) has no legal moves
game.board = [[2, 0, 2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 1, 1, 1, 1],
[2, 1, 2, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1],
[2, 2, 1, 1, 1, 2, 2, 1], [0, 2, 1, 1, 2, 2, 2, 1],
[1, 2, 1, 2, 2, 2, 2, 1], [1, 2, 2, 2, 2, 2, 0, 1]]
self.assertFalse(game.has_legal_move())
# Test when the board is full (both players have no legal moves)
game.board = [[2, 1, 2, 2, 2, 2, 2, 2], [2, 1, 1, 2, 1, 1, 1, 1],
[2, 1, 2, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 2, 1, 1], [1, 1, 1, 1, 1, 2, 1, 1],
[1, 2, 1, 2, 2, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1]]
self.assertFalse(game.has_legal_move())
game.current_player = 0
self.assertFalse(game.has_legal_move())
if not os.path.isfile(f"result-{i}.txt"):
outfile_name = f"result-{i}.txt"
print(i)
i = i + 1
with open(outfile_name, 'w') as outfile:
outfile.write(outfile_info_string + "\n")
for game_counter in range(games_nr):
print(f"game: {game_counter}")
# Store the players in a dict with the internal player codes as key to allow easy access and maintaining the correct order
players = {PLAYER_ONE: player_one, PLAYER_TWO: player_two}
times = {PLAYER_ONE: 0, PLAYER_TWO: 0}
# Create a new game state
game = Othello()
# Initialize it to start a new game
game.init_game()
# store the start time
start = time.time()
# While the game is still running continue to make turns
while not game.game_is_over():
# Get the symbol for the current player
current_player = game.get_current_player()
# Get the Player object assigned to that player
player_object = players[current_player]
# Ask the Player to calculate it's move based on the current state
calculation_start = time.time()
move = player_object.get_move(game)
calculation_time = time.time() - calculation_start
def run(self):
self.game_gui = Canvas(self.root, width=600, height=600, background='green')
self.game_gui.bind("<Button-1>", self.click)
self.game_gui.focus_set()
self.game_gui.bind("<Key>", self.key)
self.game_gui.pack()
for i in range(1, 8):
self.game_gui.create_line(0, i*75, 600, i*75)
self.game_gui.create_line(i*75, 0, i*75, 600)
self.pieces = []
for i in range(8):
self.pieces.append([])
for j in range(8):
self.pieces[i].append(self.game_gui.create_oval(i*75+5, j*75+5, (i+1)*75-5, (j+1)*75-5, fill="green", outline="green"))
self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
self.root.resizable(0,0)
self.running = True
config = EvaluateConfig()
tf_util.update_memory(config.gpu_mem_fraction)
AIPlayer.create_if_nonexistant(config)
self.game = Othello()
if(random() > 0.5):
self.human = 1
else:
self.human = -1
ai = create_player(config.model_1, config)
#print("You are playing against", config.model_1)
#print("Playing games with %d simulations per move" % config.game.simulation_num_per_move)
self.side = -1
self.draw_board()
self.value = ai.evaluate(self.game, self.side)
while self.running and not self.game.game_over():
#play move
if self.side != self.human:
self.value = ai.evaluate(self.game, self.side)
self.root.title("Othello (Thinking of Move) Current Value: %0.2f (1 white wins, -1 black wins)" % self.value)
self.root.config(cursor="wait")
t = ai.pick_move(self.game, self.side)
self.game.play_move(t[0], t[1], self.side)
self.draw_board()
self.side *= -1
self.value = ai.evaluate(self.game, self.side)
else:
if len(self.game.possible_moves(self.side)) == 0:
self.side *= -1
continue
if self.side == -1:
color = "black"
else:
color = "white"
self.root.title("Othello (Play as %s) Current Value: %0.2f (1 white wins, -1 black wins)" % (color, self.value))
self.root.config(cursor="")
if self.update:
self.update = False
if (self.x, self.y) in self.game.possible_moves(self.side):
self.game.play_move(self.x, self.y, self.side)
self.draw_board()
self.side *= -1
time.sleep(0.01)
if self.human == self.game.get_winner():
self.root.title("Othello (You Win!)")
elif self.game.get_winner() == 0:
self.root.title("Othello (Its a draw!)")
else:
self.root.title("Othello (You Lose!)")
