def explore_or_exploit(self, gameboard, player, opponent_player):
chosen_move = None
random_number = np.random.random()
if random_number <= self.epsilon:
self.epsilon -= self.epsilon_decay
chosen_move = return_random_move(gameboard, player)
if constants.VERBOSITY > 1:
print("Epsilon value is now", self.epsilon)
if constants.VERBOSITY > 0: print("Chose to explore")
else:
best_score = constants.M_INFINITY
verb = constants.VERBOSITY
constants.VERBOSITY = 0
for move in board.return_all_pending_moves(gameboard, player):
if gameboard.fit_piece(move,
player,
opponent_player,
mode="ai"):
score = self.predict_model(gameboard.board, player.score,
opponent_player.score,
player.number)
if score > best_score:
best_score = score
chosen_move = move
gameboard.unfit_last_piece(player, opponent_player)
constants.VERBOSITY = verb
if constants.VERBOSITY > 0: print("Chose to exploit")
return chosen_move
def do_minimax(alpha, beta, gameboard, ai_player, opponent_player, \
maximizing_player, depth = 2):
if maximizing_player:
if depth == 0 or len(return_all_pending_moves(gameboard,
ai_player)) == 0:
return scoring_fn(ai_player.remaining_pieces)
return get_max(alpha, beta, gameboard, ai_player, opponent_player,
depth)
else:
if depth == 0 or len(
return_all_pending_moves(gameboard, opponent_player)) == 0:
return scoring_fn(opponent_player.remaining_pieces)
return get_min(alpha, beta, gameboard, ai_player, opponent_player,
depth)
def return_random_move(gameboard, player):
if player.is_1st_move:
return return_first_turn_move(player)
else:
all_moves = board.return_all_pending_moves(gameboard, player)
if len(all_moves) > 0:
chosen_move = random.choice(all_moves)
if constants.VERBOSITY > 0:
print("Chosen move for RandomMovesBot: %s" % (chosen_move))
return chosen_move
return None
def get_max(alpha, beta, gameboard, ai_player, opponent_player, depth):
max_eval = constants.M_INFINITY
ai_moves = return_all_pending_moves(gameboard, ai_player)
for move in ai_moves:
board_copy = copy.deepcopy(gameboard)
ai_copy = copy.deepcopy(ai_player)
opponent_copy = copy.deepcopy(opponent_player)
if board_copy.fit_piece(move, ai_copy, opponent_copy):
eval = do_minimax(alpha, beta, board_copy, ai_copy, \
opponent_copy, False, depth - 1)
max_eval = max(max_eval, eval)
alpha = max(alpha, eval)
if beta <= alpha:
break
return max_eval
def get_min(alpha, beta, gameboard, ai_player, opponent_player, depth):
min_eval = constants.INFINITY
player_moves = return_all_pending_moves(gameboard, opponent_player)
for move in player_moves:
board_copy = copy.deepcopy(gameboard)
ai_copy = copy.deepcopy(ai_player)
opponent_copy = copy.deepcopy(opponent_player)
if board_copy.fit_piece(move, opponent_copy, ai_copy):
eval = do_minimax(alpha, beta, board_copy, ai_copy, \
opponent_copy, True, depth - 1)
min_eval = min(min_eval, eval)
beta = min(beta, eval)
if beta <= alpha:
break
return min_eval
def main(gameboard, ai_player, opponent_player):
best_score = constants.M_INFINITY
best_move = None
if ai_player.is_1st_move:
best_move = do_first_move(ai_player)
else:
for move in return_all_pending_moves(gameboard, ai_player):
board_copy = copy.deepcopy(gameboard)
ai_copy = copy.deepcopy(ai_player)
opponent_copy = copy.deepcopy(opponent_player)
if board_copy.fit_piece(move, ai_copy, opponent_copy):
score = do_minimax(constants.INFINITY, constants.M_INFINITY, board_copy, \
ai_copy, opponent_copy, False)
if score > best_score:
best_score = score
best_move = move
return best_move
def main(gameboard, ai_player, opponent_player):
best_score = constants.M_INFINITY
best_move = None
if ai_player.is_1st_move:
best_move = do_first_move(ai_player)
else:
board_copy = copy.deepcopy(gameboard)
ai_copy = copy.deepcopy(ai_player)
opponent_copy = copy.deepcopy(opponent_player)
for move in return_all_pending_moves(board_copy, ai_copy):
simulate_move(board_copy, move, ai_copy, opponent_copy)
score = eval_fn(ai_player.board_corners, ai_player.remaining_pieces)
if score > best_score:
best_score = score
best_move = move
undo_move(board_copy, move, ai_copy, opponent_copy)
return best_move