def test4():
player1 = MinimaxPlayer(search_depth=1)
player2 = MinimaxPlayer(search_depth=0)
game = isolation.Board(player1, player2, height=5, width=5)
game.apply_move((0,3))
game.apply_move((4,4))
print(game.to_string())
def main():
# Define two agents to compare -- these agents will play from the same
# starting position against the same adversaries in the tournament
test_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
Agent(AlphaBetaPlayer(score_fn=custom_score), "AB_Custom"),
Agent(AlphaBetaPlayer(score_fn=custom_score_2), "AB_Custom_2"),
Agent(AlphaBetaPlayer(score_fn=custom_score_3), "AB_Custom_3")
]
# Define a collection of agents to compete against the test agents
cpu_agents = [
Agent(RandomPlayer(), "Random"),
Agent(MinimaxPlayer(score_fn=open_move_score), "MM_Open"),
Agent(MinimaxPlayer(score_fn=center_score), "MM_Center"),
Agent(MinimaxPlayer(score_fn=improved_score), "MM_Improved"),
Agent(AlphaBetaPlayer(score_fn=open_move_score), "AB_Open"),
Agent(AlphaBetaPlayer(score_fn=center_score), "AB_Center"),
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved")
]
print(DESCRIPTION)
for _ in range(10):
print("{:^74}".format("*************************"))
print("{:^74}".format("Playing Matches"))
print("{:^74}".format("*************************"))
play_matches(cpu_agents, test_agents, NUM_MATCHES)
def test_CustomScore3(self):
self.player1 = AlphaBetaPlayer()
self.player2 = AlphaBetaPlayer()
time_millis = lambda: 1000 * timeit.default_timer()
move_start = time_millis()
time_left = lambda : 150 - (time_millis() - move_start)
self.player1.time_left = time_left
self.player2.time_left = time_left
self.player1.score = game_agent.custom_score_3
self.player2.score = game_agent.custom_score_3
self.game = isolation.Board(self.player1, self.player2, 9, 9)
self.game.apply_move((3,3))
while True:
# player2
best_move = self.player2.alphabeta(self.game, 1)
if best_move == (-1, -1): break
self.game.apply_move(best_move)
# player1
best_move = self.player1.alphabeta(self.game, 1)
if best_move == (-1, -1): break
self.game.apply_move(best_move)
assert(len(self.game.get_legal_moves())==0)
def main():
# Define two agents to compare -- these agents will play from the same
# starting position against the same adversaries in the tournament
test_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
Agent(AlphaBetaPlayer(score_fn=ValueScore), "VS"),
Agent(AlphaBetaPlayer(score_fn=Value2Score), "V2S"),
Agent(AlphaBetaPlayer(score_fn=Value3Score), "V3S"),
Agent(AlphaBetaPlayer(score_fn=ValueWeightedScore), "VWS"),
Agent(AlphaBetaPlayer(score_fn=Value2WeightedScore), "V2WS"),
Agent(AlphaBetaPlayer(score_fn=Value3WeightedScore), "V3WS")
]
# Define a collection of agents to compete against the test agents
cpu_agents = [
Agent(RandomPlayer(), "Random"),
Agent(MinimaxPlayer(score_fn=open_move_score), "MM_Open"),
Agent(MinimaxPlayer(score_fn=center_score), "MM_Center"),
Agent(MinimaxPlayer(score_fn=improved_score), "MM_Improved"),
Agent(AlphaBetaPlayer(score_fn=open_move_score), "AB_Open"),
Agent(AlphaBetaPlayer(score_fn=center_score), "AB_Center"),
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved")
]
print(DESCRIPTION)
print("{:^74}".format("*************************"))
print("{:^74}".format("Playing Matches"))
print("{:^74}".format("*************************"))
play_matches(cpu_agents, test_agents, NUM_MATCHES)
def test1(): player1 = MinimaxPlayer() player2 = MinimaxPlayer() game = Board(player1, player2) # game.apply_move((1,1)) # game.apply_move((2,2)) # print (game._board_state) # print(game.to_string()) # print(len(game._board_state)) explored = [9,11,12,14,15,16,17,20,24,25,29,30,33,38,39,44] for i in explored: game._board_state[i] = 1 game._board_state[-1] = 17 game._board_state[-2] = 9 # game.apply_move((5, 3)) # player 1 # game.apply_move((4, 2)) # player 2 print (game.to_string()) moves = game.get_legal_moves() print(moves) for m in moves: fm = game.forecast_move(m).get_legal_moves() print (str(m) + " -->" + str(fm)) # player 1 for m in moves: print (str(m) + " --> " + str(player1.score(game.forecast_move(m), player1))) print (player1.get_move(game, 6))
def main():
# Define two agents to compare -- these agents will play from the same
# starting position against the same adversaries in the tournament
test_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
Agent(AlphaBetaPlayer(score_fn=custom_score),
"AB_CUSTOM_1"), # moves count delta
Agent(AlphaBetaPlayer(score_fn=custom_score_2),
"AB_CUSTOM_2"), # unique moves
Agent(AlphaBetaPlayer(score_fn=custom_score_3),
"AB_CUSTOM_3"), # weighted moves count delta
Agent(AlphaBetaPlayer(score_fn=moves_delta_unique), "DELTA_UNIQ"),
Agent(AlphaBetaPlayer(score_fn=moves_delta_unique_exp),
"DELTA_UNIQ_EXP"),
Agent(AlphaBetaPlayer(score_fn=moves_delta_exp), "DELTA_EXP"),
Agent(AlphaBetaPlayer(score_fn=moves_delta_walls), "DELTA_WALLS")
]
# Define a collection of agents to compete against the test agents
cpu_agents = [
Agent(RandomPlayer(), "Random"),
Agent(MinimaxPlayer(score_fn=open_move_score), "MM_Open"),
Agent(MinimaxPlayer(score_fn=center_score), "MM_Center"),
Agent(MinimaxPlayer(score_fn=improved_score), "MM_Improved"),
Agent(AlphaBetaPlayer(score_fn=open_move_score), "AB_Open"),
Agent(AlphaBetaPlayer(score_fn=center_score), "AB_Center"),
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved")
]
print(DESCRIPTION)
print("{:^74}".format("*************************"))
print("{:^74}".format("Playing Matches"))
print("{:^74}".format("*************************"))
play_matches(cpu_agents, test_agents, NUM_MATCHES)
def main():
# Define two agents to compare -- these agents will play from the same
# starting position against the same adversaries in the tournament
test_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
Agent(AlphaBetaPlayer(score_fn=ox2_ppd), "ox2_ppd"),
Agent(AlphaBetaPlayer(score_fn=ox2_ncd), "ox2_ncd"),
Agent(AlphaBetaPlayer(score_fn=ncd_ppd), "ncd_ppd"),
Agent(AlphaBetaPlayer(score_fn=ox2_ncd_ppd), "ox2_ncd_ppd"),
# Agent(AlphaBetaPlayer(score_fn=pos_center_dis), "pos_ct_dis"),
# Agent(AlphaBetaPlayer(score_fn=neg_center_dis), "neg_ct_dis"),
# Agent(AlphaBetaPlayer(score_fn=pos_player_dis), "pos_p_dis"),
# Agent(AlphaBetaPlayer(score_fn=neg_player_dis), "neg_p_dis")
]
# Define a collection of agents to compete against the test agents
cpu_agents = [
Agent(RandomPlayer(), "Random"),
Agent(MinimaxPlayer(score_fn=open_move_score), "MM_Open"),
Agent(MinimaxPlayer(score_fn=center_score), "MM_Center"),
Agent(MinimaxPlayer(score_fn=improved_score), "MM_Improved"),
Agent(AlphaBetaPlayer(score_fn=open_move_score), "AB_Open"),
Agent(AlphaBetaPlayer(score_fn=center_score), "AB_Center"),
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved")
]
print(DESCRIPTION)
print("{:^85}".format("*************************"))
print("{:^85}".format("Playing Matches"))
print("{:^85}".format("*************************"))
play_matches(cpu_agents, test_agents, NUM_MATCHES)
def test_minimax(self):
self.player1 = MinimaxPlayer(timeout=0.)
self.player2 = MinimaxPlayer(timeout=0.)
self.game = isolation.Board(self.player1, self.player2)
winner, history, outcome = self.game.play()
print("\nWinner: {}\nOutcome: {}".format(winner, outcome))
print(self.game.to_string())
print("Move history:\n{!s}".format(history))
def setUp(self):
# reload(game_agent)
self.player1 = "Player1"
self.player2 = "Player2"
self.game = isolation.Board(self.player1, self.player2)
self.player = MinimaxPlayer(self.game, SearchTimeout)
self.player.minimax(self.game, 3)
self.asserEqual(1, 1)
def test_minimax(self):
self.player1 = MinimaxPlayer()
self.player2 = MinimaxPlayer()
self.game = Board(self.player1, self.player2)
self.game.apply_move((2, 3))
self.game.apply_move((0, 5))
winner, history, outcome = self.game.play()
self.assertTrue(type(history) == list)
self.assertTrue(len(history) > 1)
def setUp(self):
reload(game_agent)
self.player1 = MinimaxPlayer(search_depth=1,
score_fn=improved_score,
timeout=10.)
self.player2 = MinimaxPlayer(search_depth=1,
score_fn=improved_score,
timeout=10.)
self.game = Board(self.player1, self.player2)
def test3():
player1 = MinimaxPlayer(search_depth=1)
player2 = MinimaxPlayer(search_depth=0)
game = isolation.Board(player1, player2, height=5, width=5)
game.apply_move((3,2))
game.apply_move((4,4))
print(game.to_string())
print(game.get_player_location(game.active_player))
print(possible_moves_count(*game.get_player_location(game.active_player), game))
print(possible_moves_count(*game.get_player_location(game.inactive_player), game))
def test2():
player1 = MinimaxPlayer(search_depth=1)
player2 = MinimaxPlayer(search_depth=0)
game = isolation.Board(player1, player2, height=4, width=4)
game.apply_move((2, 0))
game.apply_move((0, 1))
game.apply_move((1, 2))
game.apply_move((2, 2))
game.apply_move((3, 1))
print(game.to_string())
print(player2.score(game, player1))
class IsolationTest(unittest.TestCase):
def setUp(self):
# reload(game_agent)
self.player1 = "Player1"
self.player2 = "Player2"
self.game = isolation.Board(self.player1, self.player2)
self.player = MinimaxPlayer(self.game, SearchTimeout)
self.player.minimax(self.game, 3)
self.asserEqual(1, 1)
def a(self):
pass
def test_minimax_valid(self):
test_start = self.time_millis()
time_left = lambda: 1000 - (self.time_millis() - test_start)
minimax = MinimaxPlayer()
board = Board(minimax, RandomPlayer())
# Play two moves to make legal moves array much smaller
board.apply_move(random.choice(board.get_legal_moves()))
board.apply_move(random.choice(board.get_legal_moves()))
self.assertIn(minimax.get_move(board, time_left),
board.get_legal_moves(minimax))
def main():
# Define two agents to compare -- these agents will play from the same
# starting position against the same adversaries in the tournament
test_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
Agent(AlphaBetaPlayer(score_fn=custom_score), "AB_Custom"),
Agent(AlphaBetaPlayer(score_fn=custom_score_2), "AB_Custom_2"),
Agent(AlphaBetaPlayer(score_fn=custom_score_3), "AB_Custom_3")
]
# Define a collection of agents to compete against the test agents
cpu_agents = [
Agent(RandomPlayer(), "Random"),
Agent(MinimaxPlayer(score_fn=open_move_score), "MM_Open"),
Agent(MinimaxPlayer(score_fn=center_score), "MM_Center"),
Agent(MinimaxPlayer(score_fn=improved_score), "MM_Improved"),
Agent(AlphaBetaPlayer(score_fn=open_move_score), "AB_Open"),
Agent(AlphaBetaPlayer(score_fn=center_score), "AB_Center"),
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved")
]
print(DESCRIPTION)
print("{:^74}".format("*************************"))
print("{:^74}".format("Playing Matches"))
print("{:^74}".format("*************************"))
results = []
for i in range(5):
print("{:^74}".format("*************************"))
print("{:^74}".format("Playing Tournament N° {}".format(i + 1)))
print("{:^74}".format("*************************"))
tournament_results = play_matches(cpu_agents, test_agents, NUM_MATCHES)
results.append(tournament_results)
print("{:^74}".format("*************************"))
print("{:^74}".format("Final results"))
print("{:^74}".format("*************************"))
print(results)
with open(RESULTS, "w") as output:
count = 1
for result in results:
print("Tournament N° {}: {}".format(count, result))
output.write("Tournament N° {}".format(count) + str(result) + "\n")
count += 1
def optimize():
cpu_agents = [
Agent(RandomPlayer(), "Random"),
Agent(MinimaxPlayer(score_fn=open_move_score), "MM_Open"),
Agent(MinimaxPlayer(score_fn=center_score), "MM_Center"),
Agent(MinimaxPlayer(score_fn=improved_score), "MM_Improved"),
Agent(AlphaBetaPlayer(score_fn=open_move_score), "AB_Open"),
Agent(AlphaBetaPlayer(score_fn=center_score), "AB_Center"),
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved")
]
def fitness(a, b):
score_func = generate_score_function(a, b)
test_agent = Agent(AlphaBetaPlayer(score_fn=score_func), "AB_Custom")
results = play_matches(cpu_agents, [test_agent], NUM_MATCHES)
win_ratio = results[test_agent]
error = 100. / win_ratio
return error
param_stack = twiddle(fitness)
_, best_params1 = param_stack.pop()
_, best_params2 = param_stack.pop()
_, best_params3 = param_stack.pop()
print(best_params1)
print(best_params2)
print(best_params3)
score_func1 = generate_score_function(*best_params1)
score_func2 = generate_score_function(*best_params2)
score_func3 = generate_score_function(*best_params3)
test_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
Agent(AlphaBetaPlayer(score_fn=score_func1), "AB_Custom_1"),
Agent(AlphaBetaPlayer(score_fn=score_func2), "AB_Custom_2"),
Agent(AlphaBetaPlayer(score_fn=score_func3), "AB_Custom_3"),
]
print("{:^74}".format("*************************"))
print("{:^74}".format("Playing Matches"))
print("{:^74}".format("*************************"))
tournament_play_matches(cpu_agents, test_agents, NUM_MATCHES)
def main():
# Define two agents to compare -- these agents will play from the same
# starting position against the same adversaries in the tournament
test_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
Agent(AlphaBetaPlayer(score_fn=custom_score), "AB_Custom"),
Agent(AlphaBetaPlayer(score_fn=custom_score_2), "AB_Custom_2"),
Agent(AlphaBetaPlayer(score_fn=custom_score_3), "AB_Custom_3")
]
timeout = {"AB_Open": 10, "AB_Center": 10, "AB_Improved": 10}
test_agents2 = [
Agent(
AlphaBetaPlayer(score_fn=open_move_score,
timeout=timeout["AB_Open"]), "AB_Open"),
Agent(
AlphaBetaPlayer(score_fn=center_score,
timeout=timeout["AB_Center"]), "AB_Center"),
Agent(
AlphaBetaPlayer(score_fn=improved_score,
timeout=timeout["AB_Improved"]), "AB_Improved")
# Agent(AlphaBetaPlayer(score_fn=custom_score_3), "AB_Custom_3")
]
# Define a collection of agents to compete against the test agents
cpu_agents = [
Agent(RandomPlayer(), "Random"),
Agent(MinimaxPlayer(score_fn=open_move_score), "MM_Open"),
Agent(MinimaxPlayer(score_fn=center_score), "MM_Center"),
Agent(MinimaxPlayer(score_fn=improved_score), "MM_Improved"),
Agent(
AlphaBetaPlayer(score_fn=open_move_score,
timeout=timeout["AB_Open"]), "AB_Open"),
Agent(
AlphaBetaPlayer(score_fn=center_score,
timeout=timeout["AB_Center"]), "AB_Center"),
Agent(
AlphaBetaPlayer(score_fn=improved_score,
timeout=timeout["AB_Improved"]), "AB_Improved")
]
# assert test_agents[0][0].TIMER_THRESHOLD==90
print(DESCRIPTION)
print("{:^74}".format("*************************"))
print("{:^74}".format("Playing Matches"))
print("{:^74}".format("*************************"))
play_matches(cpu_agents, test_agents, NUM_MATCHES)
def test_MinimaxFailCase1(self):
self.player1 = MinimaxPlayer()
self.player2 = MinimaxPlayer()
time_millis = lambda: 1000 * timeit.default_timer()
move_start = time_millis()
time_left = lambda : 150 - (time_millis() - move_start)
self.player1.time_left = time_left
self.player2.time_left = time_left
self.player1.score = strategy.center_score
self.player2.score = strategy.center_score
self.game = isolation.Board(self.player1, self.player2, 9, 9)
self.game._board_state = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 39, 56]
best_move = self.player1.minimax(self.game, 1)
assert(best_move==(0,7))
def test_AlphaBetaFailCase1(self):
self.player1 = AlphaBetaPlayer()
self.player2 = AlphaBetaPlayer()
time_millis = lambda: 1000 * timeit.default_timer()
move_start = time_millis()
time_left = lambda : 150 - (time_millis() - move_start)
self.player1.time_left = time_left
self.player2.time_left = time_left
self.player1.score = strategy.improved_score
self.player2.score = strategy.improved_score
self.game = isolation.Board(self.player1, self.player2, 9, 9)
self.game._board_state = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 60, 14]
best_move = self.player1.alphabeta(self.game, 1, 0, 0)
def testBoard(self):
AB = AlphaBetaPlayer()
MM = MinimaxPlayer()
greedy = GreedyPlayer()
rand = RandomPlayer()
game = Board(AB, MM)
game.apply_move((1, 5))
game.applymove((2, 3))
self.assertTrue(game.check_legal_move((4, 5)))
self.assertEqual((2, 3), game.get_player_location(game._active_player))
def main():
# Define two agents to compare -- these agents will play from the same
# starting position against the same adversaries in the tournament
test_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
Agent(AlphaBetaPlayer(score_fn=my_moves_heuristic),
"my_moves_heuristic"),
Agent(AlphaBetaPlayer(score_fn=maximise_player_moves),
"maximise_player_moves"),
Agent(AlphaBetaPlayer(score_fn=minimise_opponent_moves),
"minimise_opponent_moves"),
Agent(
AlphaBetaPlayer(
score_fn=maximise_ratio_of_player_to_opponent_moves),
"maximise_ratio_of_player_to_opponent_moves"),
Agent(
AlphaBetaPlayer(
score_fn=minimise_ratio_of_player_to_opponent_moves),
"minimise_ratio_of_player_to_opponent_moves")
]
# Define a collection of agents to compete against the test agents
cpu_agents = [
Agent(RandomPlayer(), "Random"),
Agent(MinimaxPlayer(score_fn=open_move_score), "MM_Open"),
Agent(MinimaxPlayer(score_fn=center_score), "MM_Center"),
Agent(MinimaxPlayer(score_fn=improved_score), "MM_Improved"),
Agent(AlphaBetaPlayer(score_fn=open_move_score), "AB_Open"),
Agent(AlphaBetaPlayer(score_fn=center_score), "AB_Center"),
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved")
]
print(DESCRIPTION)
print("{:^74}".format("*************************"))
print("{:^74}".format("Playing Matches"))
print("{:^74}".format("*************************"))
print()
play_matches(cpu_agents, test_agents, NUM_MATCHES)
def main():
# Define two agents to compare -- these agents will play from the same
# starting position against the same adversaries in the tournament
test_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
Agent(AlphaBetaPlayer(score_fn=custom_score), "AB_Custom"),
Agent(AlphaBetaPlayer(score_fn=custom_score_2), "AB_Custom_2"),
Agent(AlphaBetaPlayer(score_fn=custom_score_3), "AB_Custom_3")
]
"""
Uncomment to add grid search function agents to test_agents
"""
# print("{} grid search functions".format(len(gs_funcs)))
# for name, func in gs_funcs.items():
# test_agents.append(Agent(AlphaBetaPlayer(score_fn=func), "AB_{}".format(name)))
# print("{} grid search2 functions".format(len(gs2_funcs)))
# for name, func in gs2_funcs.items():
# test_agents.append(Agent(AlphaBetaPlayer(score_fn=func), "AB_GS2_{}".format(name)))
# Define a collection of agents to compete against the test agents
cpu_agents = [
Agent(RandomPlayer(), "Random"),
Agent(MinimaxPlayer(score_fn=open_move_score), "MM_Open"),
Agent(MinimaxPlayer(score_fn=center_score), "MM_Center"),
Agent(MinimaxPlayer(score_fn=improved_score), "MM_Improved"),
Agent(AlphaBetaPlayer(score_fn=open_move_score), "AB_Open"),
Agent(AlphaBetaPlayer(score_fn=center_score), "AB_Center"),
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved")
]
print(DESCRIPTION)
print("{:^74}".format("*************************"))
print("{:^74}".format("Playing Matches"))
print("{:^74}".format("*************************"))
play_matches(cpu_agents, test_agents, NUM_MATCHES)
def setUp(self):
reload(game_agent)
player1 = MinimaxPlayer()
player2 = MinimaxPlayer()
game = Board(player1, player2)
game.apply_move((2, 3))
game.apply_move((0, 5))
m1 = player1.get_move(game, 5)
game.apply_move(m1)
m2 = player2.get_move(game, 6)
game.apply_move(m2)
def main():
# Define two agents to compare -- these agents will play from the same
# starting position against the same adversaries in the tournament
test_agent = \
Agent(AlphaBetaPlayer(score_fn=custom_score_2), "AB_Custom_2")
# Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
# Agent(AlphaBetaPlayer(score_fn=custom_score), "AB_Custom")
# Agent(AlphaBetaPlayer(score_fn=custom_score_3), "AB_Custom_3")
# Define a collection of agents to compete against the test agents
cpu_agent = \
Agent(MinimaxPlayer(score_fn=center_score), "MM_Center")
# Agent(MinimaxPlayer(score_fn=open_move_score), "MM_Open")
# Agent(RandomPlayer(), "Random"),
# Agent(MinimaxPlayer(score_fn=improved_score), "MM_Improved"),
# Agent(AlphaBetaPlayer(score_fn=open_move_score), "AB_Open"),
# Agent(AlphaBetaPlayer(score_fn=center_score), "AB_Center"),
# Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved")
play_round(cpu_agent, test_agent)
if not valid_choice:
print('Illegal move! Try again.')
except ValueError:
print('Invalid index! Try again.')
return legal_moves[index]
if __name__ == "__main__":
from isolation import Board
from game_agent import MinimaxPlayer
# create an isolation board (by default 7x7)
player1 = MinimaxPlayer(score_fn=open_move_score)
player2 = MinimaxPlayer(score_fn=open_move_score)
game = Board(player1, player2)
# place player 1 on the board at row 2, column 3, then place player 2 on
# the board at row 0, column 5; display the resulting board state. Note
# that the .apply_move() method changes the calling object in-place.
game.apply_move((2, 3))
game.apply_move((0, 5))
print(game.to_string())
# players take turns moving on the board, so player1 should be next to move
assert (player1 == game.active_player)
# get a list of the legal moves available to the active player
print(game.get_legal_moves())
if not valid_choice:
print('Illegal move! Try again.')
except ValueError:
print('Invalid index! Try again.')
return legal_moves[index]
if __name__ == "__main__":
from isolation import Board
# create an isolation board (by default 7x7)
player1 = RandomPlayer()
# player2 = GreedyPlayer()
player2 = MinimaxPlayer()
game = Board(player1, player2)
# place player 1 on the board at row 2, column 3, then place player 2 on
# the board at row 0, column 5; display the resulting board state. Note
# that the .apply_move() method changes the calling object in-place.
game.apply_move((2, 3))
game.apply_move((0, 5))
print(game.to_string())
# players take turns moving on the board, so player1 should be next to move
assert (player1 == game.active_player)
# get a list of the legal moves available to the active player
print(game.get_legal_moves())
from sample_players import (RandomPlayer, open_move_score,
improved_score, center_score)
from game_agent import (MinimaxPlayer, AlphaBetaPlayer, custom_score,
custom_score_2, custom_score_3)
from tournament import play_matches,play_round,update
from time import time
NUM_MATCHES = 5 # number of matches against each opponent
TIME_LIMIT = 150 # number of milliseconds before timeout
Agent = namedtuple("Agent", ["player", "name"])
NUM_MATCHES = 1
t0 = time()
for i in range(NUM_MATCHES):
#Agent1 = Agent(AlphaBetaPlayer(score_fn=open_move_score), "MM_Open")
Agent1 = Agent(MinimaxPlayer(score_fn=open_move_score), "MM_Open")
#Agent2 = Agent(RandomPlayer(), "Random")
Agent2 = Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved")
game = Board(Agent1.player, Agent2.player)
# initialize all games with a random move and response
for _ in range(2):
move = random.choice(game.get_legal_moves())
game.apply_move(move)
#print(game.to_string())
# play all games and tally the results
winner, log, termination = game.play() # real thing happens here
print(game.to_string())
print("winner:",winner, "opponet failed due to", termination)
print("total time: ", time()-t0)
class IsolationTest(unittest.TestCase):
"""Unit tests for isolation agents"""
def setUp(self):
reload(game_agent)
self.player1 = "Player1"
self.player2 = "Player2"
self.game = isolation.Board(self.player1, self.player2)
def test_CustomScore(self):
self.player1 = AlphaBetaPlayer()
self.player2 = AlphaBetaPlayer()
time_millis = lambda: 1000 * timeit.default_timer()
move_start = time_millis()
time_left = lambda : 150 - (time_millis() - move_start)
self.player1.time_left = time_left
self.player2.time_left = time_left
self.player1.score = game_agent.custom_score
self.player2.score = game_agent.custom_score
self.game = isolation.Board(self.player1, self.player2, 9, 9)
self.game.apply_move((3,3))
while True:
# player2
best_move = self.player2.alphabeta(self.game, 1)
if best_move == (-1, -1): break
self.game.apply_move(best_move)
# player1
best_move = self.player1.alphabeta(self.game, 1)
if best_move == (-1, -1): break
self.game.apply_move(best_move)
assert(len(self.game.get_legal_moves())==0)
def test_CustomScore2(self):
self.player1 = AlphaBetaPlayer()
self.player2 = AlphaBetaPlayer()
time_millis = lambda: 1000 * timeit.default_timer()
move_start = time_millis()
time_left = lambda : 150 - (time_millis() - move_start)
self.player1.time_left = time_left
self.player2.time_left = time_left
self.player1.score = game_agent.custom_score_2
self.player2.score = game_agent.custom_score_2
self.game = isolation.Board(self.player1, self.player2, 9, 9)
self.game.apply_move((3,3))
while True:
# player2
best_move = self.player2.alphabeta(self.game, 1)
if best_move == (-1, -1): break
self.game.apply_move(best_move)
# player1
best_move = self.player1.alphabeta(self.game, 1)
if best_move == (-1, -1): break
self.game.apply_move(best_move)
assert(len(self.game.get_legal_moves())==0)
def test_CustomScore3(self):
self.player1 = AlphaBetaPlayer()
self.player2 = AlphaBetaPlayer()
time_millis = lambda: 1000 * timeit.default_timer()
move_start = time_millis()
time_left = lambda : 150 - (time_millis() - move_start)
self.player1.time_left = time_left
self.player2.time_left = time_left
self.player1.score = game_agent.custom_score_3
self.player2.score = game_agent.custom_score_3
self.game = isolation.Board(self.player1, self.player2, 9, 9)
self.game.apply_move((3,3))
while True:
# player2
best_move = self.player2.alphabeta(self.game, 1)
if best_move == (-1, -1): break
self.game.apply_move(best_move)
# player1
best_move = self.player1.alphabeta(self.game, 1)
if best_move == (-1, -1): break
self.game.apply_move(best_move)
assert(len(self.game.get_legal_moves())==0)
def test_AlphaBetaFailCase1(self):
self.player1 = AlphaBetaPlayer()
self.player2 = AlphaBetaPlayer()
time_millis = lambda: 1000 * timeit.default_timer()
move_start = time_millis()
time_left = lambda : 150 - (time_millis() - move_start)
self.player1.time_left = time_left
self.player2.time_left = time_left
self.player1.score = strategy.improved_score
self.player2.score = strategy.improved_score
self.game = isolation.Board(self.player1, self.player2, 9, 9)
self.game._board_state = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 60, 14]
best_move = self.player1.alphabeta(self.game, 1, 0, 0)
def test_MinimaxFailCase1(self):
self.player1 = MinimaxPlayer()
self.player2 = MinimaxPlayer()
time_millis = lambda: 1000 * timeit.default_timer()
move_start = time_millis()
time_left = lambda : 150 - (time_millis() - move_start)
self.player1.time_left = time_left
self.player2.time_left = time_left
self.player1.score = strategy.center_score
self.player2.score = strategy.center_score
self.game = isolation.Board(self.player1, self.player2, 9, 9)
self.game._board_state = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 39, 56]
best_move = self.player1.minimax(self.game, 1)
assert(best_move==(0,7))
if not valid_choice:
print('Illegal move! Try again.')
except ValueError:
print('Invalid index! Try again.')
return legal_moves[index]
if __name__ == "__main__":
from isolation import Board
from game_agent import MinimaxPlayer
# create an isolation board (by default 7x7)
# player1 = RandomPlayer()
player1 = MinimaxPlayer()
player2 = GreedyPlayer()
game = Board(player1, player2)
# place player 1 on the board at row 2, column 3, then place player 2 on
# the board at row 0, column 5; display the resulting board state. Note
# that the .apply_move() method changes the calling object in-place.
game.apply_move((2, 3))
game.apply_move((0, 5))
print(game.to_string())
# players take turns moving on the board, so player1 should be next to move
assert (player1 == game.active_player)
# get a list of the legal moves available to the active player
print(game.get_legal_moves())
