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())