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 minimax_succ(state): pos = state.player_positions[state.curr_player] succ_states = [] board = state.board.copy() board[pos] = -1 min_fruit_time = min(len(board[0]), len(board)) if state.lifetime >= 2 * min_fruit_time: board = np.where(board >= 3, 0, board) for d in utils.get_directions(): i = pos[0] + d[0] j = pos[1] + d[1] if 0 <= i < len(board) and 0 <= j < len(board[0]) and ( board[i][j] not in [-1, 1, 2]): # then move is legal new_pos = (i, j) fruit_score = board[new_pos] players_score = list(state.players_score) players_score[state.curr_player] += fruit_score player_positions = list(state.player_positions) player_positions[state.curr_player] = new_pos old_board_value = board[new_pos] board[new_pos] = (state.curr_player + 1) yield SearchAlgos.State(board.copy(), tuple(players_score), tuple(player_positions), 1 - state.curr_player, state.penalty, d, state.lifetime + 1, state.initial_pos) # reset the board: positions + scores board[new_pos] = old_board_value players_score[state.curr_player] -= fruit_score
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 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) minimax = SearchAlgos.MiniMax(minimax_utility, minimax_succ, None, start_time, time_limit, minimax_heuristic) depth = 1 value, direction = minimax.search(curr_state, depth, 1) while not minimax.developed_whole_tree: try: minimax.developed_whole_tree = True value, direction = minimax.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