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)
