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")
#Agent(AlphaBetaPlayer(score_fn=custom_score_4), "AB_Custom_4"),
#Agent(AlphaBetaPlayer(score_fn=custom_score_5), "AB_Custom_5"),
#Agent(AlphaBetaPlayer(score_fn=custom_score_6), "AB_Custom_6")
]
# 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 test_alphabeta(self):
self.player1 = AlphaBetaPlayer()
self.player2 = AlphaBetaPlayer()
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 = AlphaBetaPlayer(search_depth=2,
score_fn=null_score,
timeout=10.)
self.player2 = AlphaBetaPlayer(search_depth=2,
score_fn=null_score,
timeout=10.)
self.game = Board(self.player1, self.player2)
def test_minimax(self):
self.game._board_state = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0,
0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 57
]
self.player1 = AlphaBetaPlayer(2, score_fn=open_move_score)
self.player2 = AlphaBetaPlayer(2, score_fn=open_move_score)
move = self.player1.alphabeta(self.game, 2)
def test_aggresive():
custom_score_2_0_5 = lambda game, player: custom_score_2(game, player, 0.5)
custom_score_2_1_5 = lambda game, player: custom_score_2(game, player, 1.5)
custom_score_2_2_0 = lambda game, player: custom_score_2(game, player, 2.0)
test_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
Agent(AlphaBetaPlayer(score_fn=custom_score_2_0_5), "AB_Aggr_0.5"),
Agent(AlphaBetaPlayer(score_fn=custom_score_2_1_5), "AB_Aggr_1.5"),
Agent(AlphaBetaPlayer(score_fn=custom_score_2_2_0), "AB_Aggr_2.0"),
]
return test_agents
def test2(): player1 = AlphaBetaPlayer() player2 = AlphaBetaPlayer() game = Board(player1, player2, 9, 9) game._board_state = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, 22] #print(player1.get_move(game, 6)) moves = game.get_legal_moves() for m in moves: fm = game.forecast_move(m).get_legal_moves() print (str(m) + " -->" + str(fm) + 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=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 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=defensive), "defensive"),
Agent(AlphaBetaPlayer(score_fn=aggressive), "aggressive"),
Agent(AlphaBetaPlayer(score_fn=center_play), "center play"),
Agent(AlphaBetaPlayer(score_fn=defensive_to_aggressive),
"defensive to aggressive")
]
# 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 test_weighted_move():
custom_score_3_0_5 = lambda game, player: custom_score_3(game, player, 0.5)
custom_score_3_1_0 = lambda game, player: custom_score_3(game, player, 1.0)
custom_score_3_1_5 = lambda game, player: custom_score_3(game, player, 1.5)
custom_score_3_2_0 = lambda game, player: custom_score_3(game, player, 2.0)
test_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
Agent(AlphaBetaPlayer(score_fn=custom_score_3_0_5), "AB_Wm_0.5"),
Agent(AlphaBetaPlayer(score_fn=custom_score_3_1_0), "AB_Wm_1.0"),
Agent(AlphaBetaPlayer(score_fn=custom_score_3_1_5), "AB_Wm_1.5"),
Agent(AlphaBetaPlayer(score_fn=custom_score_3_2_0), "AB_Wm_2.0")
]
return test_agents
def test_combined_adaptive():
custom_score_adaptive_0 = lambda game, player: custom_score_adaptive(
game, player, True)
custom_score_adaptive_1 = lambda game, player: custom_score_adaptive(
game, player, False)
test_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
Agent(AlphaBetaPlayer(score_fn=custom_score_adaptive_0),
"AB_Comb_Occ"),
Agent(AlphaBetaPlayer(score_fn=custom_score_adaptive_1),
"AB_Comb_1-Occ")
]
return test_agents
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 test5():
player1 = AlphaBetaPlayer(search_depth=100, score_fn=open_move_score)
player2 = AlphaBetaPlayer(search_depth=100, score_fn=custom_score_3)
game = isolation.Board(player1, player2, height=7, width=7)
game._board_state =[0, 0, 0, 'o13', 0, 0, 0, 'o17', 0, 0, 'x17', ' O ', ' X ', 'o09', 0, 'x19', 'o15', 'x27', 'o11',
'x03', 'o27', 0, 'o19', 'x11', 'x01', 'x15', 'o07', 0, 'x21', 0, 'x25', 'o05', 'x05', 'o25',
0, 0, 'x09', 'o21', 'x13', 0, 'o03', 0, 0, 'x23', 0, 'x07', 'o23', 0, 0, 1, 11, 12]
game._active_player, game._inactive_player = game._inactive_player, game._active_player
print(game.to_string())
print(game.active_player==game._player_2)
game_copy = game.copy()
time_millis = lambda: 1000 * timeit.default_timer()
move_start = time_millis()
time_left = lambda: 150000 - (time_millis() - move_start)
curr_move = game._active_player.get_move(game_copy, time_left)
return curr_move
def start_game():
# create an isolation board (by default 7x7)
player1 = RandomPlayer()
player2 = AlphaBetaPlayer(score_fn=custom_score_3)
game = Board(player1, player2)
assert (player1 == game.active_player)
player_position = choice(game.get_legal_moves())
game.apply_move(player_position)
ai_position = choice(game.get_legal_moves())
game.apply_move(ai_position)
move_history = [player_position, ai_position]
response = jsonify({
'legal_moves': game.get_legal_moves(),
'player_position': list(player_position),
'ai_position': list(ai_position),
'move_history': move_history
})
# 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.
return response
def test_combined_strategy():
custom_score_1_0_5 = lambda game, player: custom_score_comb(
game, player, 0.5)
custom_score_1_1_0 = lambda game, player: custom_score_comb(
game, player, 1.5)
custom_score_1_2_0 = lambda game, player: custom_score_comb(
game, player, 2.0)
test_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
Agent(AlphaBetaPlayer(score_fn=custom_score_1_0_5), "AB_Comb_0.5"),
Agent(AlphaBetaPlayer(score_fn=custom_score_1_1_0), "AB_Comb_1.0"),
Agent(AlphaBetaPlayer(score_fn=custom_score_1_2_0), "AB_Comb_2.0")
]
return test_agents
def play_game():
content = request.get_json(silent=True)
move_history = content['move_history']
# create an isolation board (by default 7x7)
player1 = RandomPlayer()
player2 = AlphaBetaPlayer(score_fn=custom_score_3)
game = Board(player1, player2)
assert (player1 == game.active_player)
for move in move_history:
game.apply_move(move)
isWinner = ''
if game.is_winner(player1):
isWinner = 'White Knight'
if game.is_winner(player2):
isWinner = 'Black Knight'
if isWinner:
response = jsonify({
'legal_moves': game.get_legal_moves(),
'player_position': list(player_position),
'ai_position': list(ai_position),
'move_history': move_history,
'isWinner': isWinner
})
player2.time_left = time_left
ai_move = player2.alphabeta(game, 6)
game.apply_move(ai_move)
player_position = game.get_player_location(player1)
move_history.append(ai_move)
ai_position = game.get_player_location(player2)
if game.is_winner(player1):
isWinner = 'White Knight'
if game.is_winner(player2):
isWinner = 'Black Knight'
response = jsonify({
'legal_moves': game.get_legal_moves(),
'player_position': list(player_position),
'ai_position': list(ai_position),
'move_history': move_history,
'isWinner': isWinner
})
# 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.
return response
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 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, timeout=50.),
"MinDist2Opp"),
Agent(AlphaBetaPlayer(score_fn=custom_score_2, timeout=50.),
"DiffDist2Ctr"),
Agent(AlphaBetaPlayer(score_fn=custom_score_3, timeout=50.),
"OpenComplex"),
]
# 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=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("Agent Heuristics:")
print("AB_Custom = avoid_corners_score")
print("AB_Custom_2 = next_moves_score")
print("AB_Custom_3 = weighted_chase_opponent_score\n")
print("{:^74}".format("*************************"))
print("{:^74}".format("Playing Matches"))
print("{:^74}".format("*************************"))
play_matches(cpu_agents, test_agents, NUM_MATCHES)
def custom_test():
# 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=custom_score), "AB_Custom"),
]
# Define a collection of agents to compete against the test agents
cpu_agents = [
Agent(AlphaBetaPlayer(score_fn=improved_score), "AB_Improved"),
]
print(DESCRIPTION)
print("{:^74}".format("*************************"))
print("{:^74}".format("Playing Matches"))
print("{:^74}".format("*************************"))
NUM_MATCHES = 50
play_matches(cpu_agents, test_agents, NUM_MATCHES)
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
def test_hash_different(self):
board = Board(AlphaBetaPlayer(), RandomPlayer())
board.apply_move(random.choice(board.get_legal_moves()))
board.apply_move(random.choice(board.get_legal_moves()))
b1 = board.forecast_move(board.get_legal_moves()[0])
b2 = board.forecast_move(board.get_legal_moves()[1])
self.assertNotEqual(b1.__hash__(), b2.__hash__())
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 test_alphabeta_valid(self):
test_start = self.time_millis()
time_left = lambda: 1000 - (self.time_millis() - test_start)
alphabeta = AlphaBetaPlayer()
board = Board(alphabeta, 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(alphabeta.get_move(board, time_left),
board.get_legal_moves(alphabeta))
def test6():
player1 = AlphaBetaPlayer(search_depth=1, score_fn=custom_score)
player2 = AlphaBetaPlayer(search_depth=1, score_fn=custom_score_3)
game = isolation.Board(player1, player2, height=5, width=5)
game.apply_move((0, 3))
print(game.to_string())
game.apply_move((4, 4))
print(game.to_string())
game.apply_move((3, 2))
print(game.to_string())
game.apply_move((1, 1))
game.apply_move((2, 0))
game.apply_move((3, 0))
game.apply_move((1, 2))
print(game.to_string())
print(custom_score(game, game.active_player))
print(custom_score(game, game.inactive_player))
print(custom_score_2(game, game.active_player))
print(custom_score_2(game, game.inactive_player))
print(custom_score_3(game, game.active_player))
print(custom_score_3(game, game.inactive_player))
print(improved_score(game, game.active_player))
print(improved_score(game, game.inactive_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 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")
]
# 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 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(MinimaxPlayer(score_fn=custom_score), "MM_Custom"),
# Agent(MinimaxPlayer(score_fn=custom_score_2), "MM_Custom_2"),
# Agent(MinimaxPlayer(score_fn=custom_score_3), "MM_Custom_3"),
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"),
Agent(AlphaBetaPlayer(score_fn=custom_score_4), "AB_Custom_4"),
Agent(AlphaBetaPlayer(score_fn=custom_score_5), "AB_Custom_5"),
# Agent(AlphaBetaPlayer(score_fn=custom_score_6), "AB_Custom_6"),
# 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"),
# Agent(RandomPlayer(), "Random")
]
# 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("*************************"))
test_scores = defaultdict(list)
for i in range(NUM_REPEATS):
print(" " * 74)
print("{:>37}{:d}".format("Sample ", i + 1))
print("-" * 74)
wins = play_matches(cpu_agents, test_agents, NUM_MATCHES)
for a in test_agents:
test_scores[a.name].append(wins[a.player] / NUM_MATCHES)
return wins, test_scores
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)
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)