def make_move(self, time_limit, players_score):
"""Make move with this Player.
input:
- time_limit: float, time limit for a single turn.
output:
- direction: tuple, specifing the Player's movement, chosen from self.directions
"""
def find_player_positions(player_index):
if player_index == 1:
return self.pos
pos = np.where(self.board == player_index)
# convert pos to tuple of ints
return tuple(ax[0] for ax in pos)
start_time = time()
player_positions = (find_player_positions(1), find_player_positions(2))
self.board[self.pos] = -1
curr_state = SearchAlgos.State(self.board.copy(), tuple(players_score),
player_positions, 0, self.penalty_score,
(0, 0), self.lifetime, self.initial_pos)
heavy_player = SearchAlgos.AlphaBeta(minimax_utility, minimax_succ,
None, start_time, time_limit,
minimax_heuristic)
depth = 4
value, direction = heavy_player.search(curr_state, depth, 1)
i = self.pos[0] + direction[0]
j = self.pos[1] + direction[1]
self.pos = (i, j)
self.board[self.pos] = 1
self.lifetime += 1
return direction
def __init__(self, game_time, penalty_score):
AbstractPlayer.__init__(
self, game_time, penalty_score
) # keep the inheritance of the parent's (AbstractPlayer) __init__()
#TODO: initialize more fields, if needed, and the Minimax algorithm from SearchAlgos.py
self.penalty_score = penalty_score
self.name = "LightAlphaBeta"
self.location = None
self.game_board = None
self.rival_location = None
self.rival_points = 0
self.points = 0
self.time_ended = False
self.start_time = 0
self.fruit_locations = dict()
self.fruit_life_time = None
self.best_fruit_value = 0
self.fruits_in_game = False
self.best_fruit_location = None
self.moves_available = []
self.moves_available_count = 0
self.rival_moves_available = []
self.rival_moves_available_count = 0
self.min_dimention = None
self.fruits_concentration = None
# self.init_concentration_dict()
self.search_algos = SearchAlgos.AlphaBeta(self.utility, None,
self.make_move, self.is_goal)
def make_move(self, time_limit, players_score):
"""Make move with this Player.
input:
- time_limit: float, time limit for a single turn.
output:
- direction: tuple, specifing the Player's movement, chosen from self.directions
"""
# print("start computing Heavy alpha-beta move") # printing for self test
if self.first_player == -1:
self.first_player = True
state = utils.State(copy.deepcopy(self.board), self.pos,
self.rival_pos, players_score, self.penalty_score,
self.turns_till_fruit_gone,
self.fruits_on_board_dict, self.first_player)
search_algo = SearchAlgos.AlphaBeta(utils.utility, utils.succ,
utils.perform_move, utils.goal)
best_move = search_algo.search(
state, 3, True) # always with max depth=3 (or 2 in other test)
if best_move[1] is None:
exit(0)
# print("Heavy alpha-beta choose the move: ", best_move) # printing for self test
self.board[self.pos] = -1
tmp1 = best_move[1]
self.pos = (self.pos[0] + tmp1[0], self.pos[1] + tmp1[1])
self.board[self.pos] = 1
self.turns_till_fruit_gone -= 1
return best_move[1]
def __init__(self, game_time, penalty_score):
AbstractPlayer.__init__(self, game_time, penalty_score) # keep the inheritance of the parent's (AbstractPlayer) __init__()
self.board = None
self.pos = None
self.alphabeta = SearchAlgos.AlphaBeta(utility=self.utility, succ=self.succ, perform_move=None, goal=self.goal,
heuristic=self.heuristic)
self.players_score = None
def __init__(self, game_time, penalty_score):
AbstractPlayer.__init__(
self, game_time, penalty_score
) # keep the inheritance of the parent's (AbstractPlayer) __init__()
self.alphaBeta = SearchAlgos.AlphaBeta(self.utility, self.succ,
self.perform_move, self.goal,
self.heuristic_function,
self.revert_move)
def make_move(self, time_limit, players_score):
"""Make move with this Player.
input:
- time_limit: float, time limit for a single turn.
output:
- direction: tuple, specifing the Player's movement, chosen from self.directions
"""
# print("start computing Global AB move") # printing for self test
start_time = time.time()
allowed_time = min(self.time_for_curr_iter, time_limit)
if self.first_player == -1:
self.first_player = True
state = utils.State(copy.deepcopy(self.board), self.pos,
self.rival_pos, players_score, self.penalty_score,
self.turns_till_fruit_gone,
self.fruits_on_board_dict, self.first_player,
time.time() + allowed_time - self.extra_safe_time)
search_algo = SearchAlgos.AlphaBeta(utils.utility, utils.succ,
utils.perform_move, utils.goal)
depth = 1
best_move = None, None
while depth <= self.max_turns:
try:
best_move = search_algo.search(state, depth, True)
except TimeoutError:
break
depth += 1
if best_move[1] is None:
# print("something went wrong,.. im out... probably not enough time for at least depth=1") # printing for self test
exit(0)
# print("depth is : ", depth - 1) # printing for self test
if self.time_for_each_iter is not None:
# print("my turn is: ", self.my_turn) # printing for self test
self.time_for_curr_iter += self.time_for_each_iter[
self.my_turn] - (time.time() - start_time)
self.my_turn -= 1
else:
self.time_for_curr_iter += (self.time_for_curr_iter /
self.risk_factor1) - (time.time() -
start_time)
# print("current iter took: ", time.time()-start_time) # printing for self test
# print("next iter will take: ", self.time_for_curr_iter)
# print("Global AB choose the move: ", best_move)
self.max_turns -= 1
self.board[self.pos] = -1
tmp1 = best_move[1]
self.pos = (self.pos[0] + tmp1[0], self.pos[1] + tmp1[1])
self.board[self.pos] = 1
self.turns_till_fruit_gone -= 1
return best_move[1]
def __init__(self, game_time, penalty_score):
AbstractPlayer.__init__(self, game_time,
penalty_score) # keep the inheritance of the parent's (AbstractPlayer) __init__()
# TODO: initialize more fields, if needed, and the AlphaBeta algorithm from SearchAlgos.py
self.board = None # player1 is my player
self.pos_players = None # tuple [0]-player1 pos, [1] -player2 pos
self.strategy = sa.AlphaBeta(utility=self.utility, succ=utils.State.succ, retriveLast=utils.State.retriveLast,
goal=utils.State.goal)
self.num_of_turns = (0, 0) # tuple [0]-player1 turns, [1] -player2 turns
self.fruits_on_board = None
self.little_edge = 0
def make_move(self, time_limit, players_score):
"""Make move with this Player.
input:
- time_limit: float, time limit for a single turn.
output:
- direction: tuple, specifing the Player's movement, chosen from self.directions
"""
global play_simple_player
def find_player_positions(player_index):
if player_index == 1:
return self.pos
pos = np.where(self.board == player_index)
return tuple(ax[0] for ax in pos)
start_time = time()
player_positions = (find_player_positions(1), find_player_positions(2))
self.board[self.pos] = -1
if not play_simple_player:
play_simple_player = not is_enemy_reachable(
self.board, self.pos) and self.lifetime >= 2 * min(
len(self.board[0]), len(self.board))
curr_state = SearchAlgos.State(self.board.copy(), tuple(players_score),
player_positions, 0, self.penalty_score,
(0, 0), self.lifetime)
time_limit = self.calculate_turn_time_limit(
int(self.lifetime / 2) - 1 + self.lifetime % 2)
global_alphabeta = SearchAlgos.AlphaBeta(minimax_utility, minimax_succ,
None, start_time, time_limit,
minimax_heuristic)
depth = 1
value, direction = global_alphabeta.search(curr_state, depth, 1)
while not global_alphabeta.developed_whole_tree:
try:
global_alphabeta.developed_whole_tree = True
value, direction = global_alphabeta.search(
curr_state, depth, 1)
depth += 1
except SearchAlgos.Interrupted:
break
i = self.pos[0] + direction[0]
j = self.pos[1] + direction[1]
self.pos = (i, j)
self.board[self.pos] = 1
self.lifetime += 1
return direction
def __init__(self, game_time, penalty_score):
AbstractPlayer.__init__(
self, game_time, penalty_score
) # keep the inheritance of the parent's (AbstractPlayer) __init__()
#TODO: initialize more fields, if needed, and the AlphaBeta algorithm from SearchAlgos.py
self.board = None
self.pos = None
self.flag = True
self.time_frame = None
self.global_time = game_time
self.alphabeta = SearchAlgos.AlphaBeta(utility=self.utility,
succ=self.succ,
perform_move=None,
goal=self.goal,
heuristic=self.heuristic)
self.players_score = None
def make_move(self, time_limit, players_score):
"""Make move with this Player.
input:
- time_limit: float, time limit for a single turn.
output:
- direction: tuple, specifing the Player's movement, chosen from self.directions
"""
# print("start computing alpha-beta move") # printing for self test
if self.first_player == -1:
self.first_player = True
state = utils.State(copy.deepcopy(self.board), self.pos,
self.rival_pos, players_score, self.penalty_score,
self.turns_till_fruit_gone,
self.fruits_on_board_dict, self.first_player,
time.time() + time_limit - .015)
search_algo = SearchAlgos.AlphaBeta(utils.utility, utils.succ,
utils.perform_move, utils.goal)
depth = 1
best_move = None, None
while depth <= self.max_turns:
try:
best_move = search_algo.search(state, depth, True)
except TimeoutError:
break
depth += 1
if best_move[1] is None:
# print("something went wrong,.. im out") # printing for self test
exit(0)
# print("depth is : ", depth - 1) # printing for self test
# print("alpha-beta choose the move: ", best_move) # printing for self test
self.board[self.pos] = -1
tmp1 = best_move[1]
self.pos = (self.pos[0] + tmp1[0], self.pos[1] + tmp1[1])
self.board[self.pos] = 1
self.turns_till_fruit_gone -= 1
return best_move[1]
def set_game_params(self, board):
"""Set the game parameters needed for this player.
This function is called before the game starts.
(See GameWrapper.py for more info where it is called)
input:
- board: np.array, a 2D matrix of the board.
No output is expected.
"""
self.board = board # need to set my pos, the rival pos, all the grey area and all fruits
self.max_turns = len(board) * len(board[0]) - 2
self.turns_till_fruit_gone = min(len(board), len(board[0])) * 2
for r, row in enumerate(board):
for c, num in enumerate(row):
if num == -1:
self.max_turns -= 1
if num == 1:
self.pos = (r, c) # this my pos
elif num == 2:
self.rival_pos = (r, c)
elif num > 2:
self.fruits_on_board_dict[(
r, c
)] = num # need to do this manually only for this player
self.time_for_curr_iter = (-2 / 3) * self.game_time / ((
(1 / 3)**self.max_turns) - 1)
min_iter_time = time.time()
state = utils.State(copy.deepcopy(self.board), self.pos,
self.rival_pos, [0, 0], self.penalty_score,
self.turns_till_fruit_gone,
self.fruits_on_board_dict, True)
search_algo = SearchAlgos.AlphaBeta(utils.utility, utils.succ,
utils.perform_move, utils.goal)
search_algo.search(state, 2, True)
min_iter_time = (time.time() - min_iter_time) * 1.25
if min_iter_time == 0:
min_iter_time = 0.0022
self.my_turn = int((1 + self.max_turns) / 2)
tmp_time = self.time_for_curr_iter
tmp_depth = self.my_turn
while tmp_depth and tmp_time > min_iter_time: # check every iter is possible for at least depth=1
tmp_time = tmp_time / self.risk_factor1
tmp_depth -= 1
if tmp_time < min_iter_time: # not every iter is possible for at least depth=1. plan B for time sharing:
avg_time = self.game_time / self.my_turn
self.time_for_each_iter = {}
index_left = self.my_turn
index_right = 0
exchange_tmp = avg_time - min_iter_time
while index_left >= index_right and exchange_tmp > 0: # exchange time between the latest iter and the first
self.time_for_each_iter[index_left] = avg_time + exchange_tmp
self.time_for_each_iter[
index_right] = min_iter_time + self.extra_safe_time
index_right += 1
index_left -= 1
min_iter_time *= self.risk_factor2
exchange_tmp = avg_time - (min_iter_time +
self.extra_safe_time)
while index_left >= index_right:
self.time_for_each_iter[index_left] = avg_time
self.time_for_each_iter[index_right] = avg_time
index_right += 1
index_left -= 1
self.time_for_curr_iter = self.time_for_each_iter[self.my_turn]
self.my_turn -= 1
