def setup_board(self): player1 = sample_players.RandomPlayer() player2 = sample_players.RandomPlayer() game = isolation.Board(player1, player2) game.apply_move((3, 2)) #1 game.apply_move((4, 2)) game.apply_move((2, 2)) #1 game.apply_move((5, 2)) game.apply_move((1, 2)) #1 game.apply_move((6, 2)) game.apply_move((0, 2)) #1 game.apply_move((6, 3)) game.apply_move((0, 1)) #1 game.apply_move((6, 4)) ''' 0 1 2 3 4 5 6 0 | | 1 | - | | | | | 1 | | | - | | | | | 2 | | | - | | | | | 3 | | | - | | | | | 4 | | | - | | | | | 5 | | | - | | | | | 6 | | | - | 2 | | | | ''' return game
def recordGameSamples(game_count=1000): player = sample_players.RandomPlayer() opponent = sample_players.RandomPlayer() samples = { 'Custom1': [], 'Custom1³': [], 'Custom2': [], 'Custom2³': [], 'Custom3': [], 'Block Opponent': [], 'Win%': [] } for i in range(0, game_count): # Initialize a new game. game = isolation.Board(player, opponent) game_depth = 1 closer_to_center = 0 closer_to_center_cubed = 0 opponent_sided = 0 opponent_blocked = 0 delta_moves = 0 delta_moves_cubed = 0 # Play a game with random moves and record the data. while True: legal_player_moves = game.get_legal_moves() # Get the current player's next move. curr_move = game._active_player.get_move(game, lambda x: 10000) if curr_move is None: curr_move = Board.NOT_MOVED # If the game is over, store the winner. if curr_move not in legal_player_moves: samples['Custom2'].append(closer_to_center) samples['Custom2³'].append(closer_to_center_cubed) samples['Custom3'].append(opponent_sided) samples['Block Opponent'].append(opponent_blocked) samples['Custom1'].append(delta_moves) samples['Custom1³'].append(delta_moves_cubed) samples['Win%'].append(1 if game.is_winner(player) else 0) break game.apply_move(curr_move) # Record features after player's move. if game._inactive_player == player and game_depth >= 2: closer_to_center += score_center_distance(game, player) closer_to_center_cubed += score_center_distance_cubed( game, player) opponent_sided += score_sided(game, player) opponent_blocked += score_opponent_blocked(game, player) delta_moves += score_delta_moves(game, player) delta_moves_cubed += score_delta_moves_cubed(game, player) game_depth += 1 # Output progress. print('\r{}%'.format(i * 100 // game_count), end='') sys.stdout.flush() return pd.DataFrame.from_dict(samples)
def setUp(self): import sample_players reload(game_agent) self.player1 = game_agent.AlphaBetaPlayer() self.player1.time_left = lambda: 10000 self.player2 = sample_players.RandomPlayer() self.game = isolation.Board(self.player1, self.player2)
def test_alpha_beta(self): minimax_player = game_agent.MinimaxPlayer( score_fn=sample_players.open_move_score) random_player = sample_players.RandomPlayer() game = isolation.Board(minimax_player, random_player) result = game.play(time_limit=TIME_LIMIT) pdb.set_trace()
def test_alphabeta(self): reload(game_agent) self.player1 = game_agent.AlphaBetaPlayer() self.player2 = sample_players.RandomPlayer() self.game = isolation.Board(self.player1, self.player2) time_left = lambda : 10. print(self.player1.get_move(self.game, time_left))
def setUp_random_vs_minimax(self): reload(game_agent) self.player1 = sample_players.RandomPlayer() self.player2 = game_agent.MinimaxPlayer(search_depth=10) self.game = isolation.Board(self.player1, self.player2, width=5, height=3) pass
def setUp(self): reload(game_agent) self.player1 = game_agent.MinimaxPlayer() self.player2 = sample_players.GreedyPlayer() self.player3 = sample_players.RandomPlayer() self.player4 = game_agent.AlphaBetaPlayer() self.player5 = game_agent.AlphaBetaPlayer() self.player6 = game_agent.MinimaxPlayer() self.game = None
def setUp(self): print("Setup called") reload(game_agent) self.player1 = "Player1" self.player2 = "Player2" #self.player1 = game_agent.MinimaxPlayer(score_fn=game_agent.custom_score) self.player1 = game_agent.AlphaBetaPlayer( score_fn=game_agent.custom_score) self.player2 = sample_players.RandomPlayer() self.game = isolation.Board(self.player1, self.player2)
def test_play(self): from isolation import Board # create an isolation board (by default 7x7) player1 = game_agent.AlphaBetaPlayer() player2 = sample_players.RandomPlayer() 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((4, 3)) game.apply_move((3, 4)) 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("Player: ", game.active_player, " with current moves: ") print(game.get_legal_moves()) # get a successor of the current state by making a copy of the board and # applying a move. Notice that this does NOT change the calling object # (unlike .apply_move()). new_game = game.forecast_move((1, 1)) assert (new_game.to_string() != game.to_string()) print("\nOld state:\n{}".format(game.to_string())) print("\nNew state:\n{}".format(new_game.to_string())) # play the remainder of the game automatically -- outcome can be "illegal # move", "timeout", or "forfeit" winner, history, outcome = game.play() print("\nWinner: {}\nOutcome: {}".format(winner, outcome)) print(game.to_string()) print("Move history:\n{!s}".format(history))
def setUp(self): reload(game_agent) self.player1 = game_agent.AlphaBetaPlayer() self.player2 = sample_players.RandomPlayer() self.game = isolation.Board(self.player1, self.player2)
def setUp(self): import sample_players reload(game_agent) self.player1 = game_agent.MinimaxPlayer() self.player2 = sample_players.RandomPlayer() self.game = isolation.Board(self.player1, self.player2)
def testAlphaBeta2(self): player1 = ga.AlphaBetaPlayer(search_depth=2, score_fn=sp.open_move_score) player2 = sp.RandomPlayer() game = isolation.Board(player1, player2, 3, 3) game.play(150)