def check_move(self, pos):
if not self.pos_feasible_on_board(pos):
return False
prev_player_position = self.get_player_position_by_current(current = True)
if not any(utils.tup_add(prev_player_position, move) == pos for move in self.directions):
# print('moved from', prev_player_position, 'to', pos)
return False
return True
def player_cant_move(self, player_id):
player_pos = self.get_player_position(player_id)
all_next_positions = [
utils.tup_add(player_pos, direction)
for direction in self.directions
]
possible_next_positions = [
pos for pos in all_next_positions
if self.pos_feasible_on_board(pos)
]
return len(possible_next_positions) == 0
def finish_turn(self, best_move, depth):
new_pos = utils.tup_add(self.pos, best_move[1])
if new_pos in self.fruits_on_board_dict:
self.current_player_score += self.fruits_on_board_dict[new_pos]
del self.fruits_on_board_dict[new_pos]
## Add reference to lose
self.current_turn += 1
self.board[self.pos[0]][self.pos[1]] = -1
self.graph.remove_node(self.pos)
print(
' depth: {} my last pos : {} best move is to move to : {} with grade of : {} nodes in graph: {}'
.format(depth, self.pos, new_pos, best_move[0],
len(fetch_connected_nodes(self.graph, new_pos))))
self.pos = new_pos
self.board[self.pos[0]][self.pos[1]] = 1
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, specifying the Player's movement, chosen from self.directions
"""
finish_time = time.time() + self.turn_time
# if self.pos == (0, 6) or self.pos == (6, 3):
# finish_time += 500
if self.pos == (0, 4):
finish_time = time.time() + 500
depth = 1
best_move = (-np.inf, (-1, 0))
initial_state = utils.State(self.board, self.graph, (0, 0), self.pos,
self.opponent_pos, self.current_turn,
self.fruits_on_board_dict, finish_time,
None, self.current_player_score,
self.opponent_player_score)
while True:
try:
if depth > 40:
finish_time += 500
best_move = self.minimax_algo.search(initial_state, depth,
True)
if best_move[1] == (0, 0):
initial_state.board[self.pos[0]][self.pos[1]] = -1
poses = [(utils.tup_add(direction, self.pos), direction)
for direction in self.directions]
valid_poses = list(
filter(
lambda tup: self.is_move_legal(
initial_state, tup[0][0], tup[0][1]), poses))
if len(valid_poses) == 0:
raise ValueError("No valid moves")
return valid_poses[0][1]
elif (best_move[0] in [-1, 1]):
self.finish_turn(best_move, depth)
return best_move[1]
except TimeoutError:
# TODO: Add reference here for score.
self.finish_turn(best_move, depth)
return best_move[1]
depth += 1
