def findPathToClosestDot(self, gameState: pacman.GameState): """ Returns a path (a list of actions) to the closest dot, starting from gameState. """ # Here are some useful elements of the startState startPosition = gameState.getPacmanPosition() food = gameState.getFood() walls = gameState.getWalls() problem = AnyFoodSearchProblem(gameState) # we don't know where the closest dot is, so let's estimate the closest dot import time start_time = time.time() # print("food (%s): %s" %(type(food), food)) # getting the closest dot to set it as the goal problem.goal = __getClosestGoal__( startPosition, food.asList()) # so that the heuristic knows the goal import search astar = search.astar(problem, heuristic=euclideanHeuristic) print("findPathToClosestDot() took %2.5f seconds" % (time.time() - start_time)) return astar
def betterEvaluationFunction(currentGameState: GameState): """ Your extreme ghost-hunting, pellet-nabbing, food-gobbling, unstoppable evaluation function (question 5). DESCRIPTION: <write something here so we know what you did> """ "*** YOUR CODE HERE ***" pos = currentGameState.getPacmanPosition() foods = currentGameState.getFood() walls = currentGameState.getWalls() capsules = currentGameState.getCapsules() ghosts = currentGameState.getGhostStates() score = currentGameState.getScore() foods_cost = _food_cost(foods.asList(), pos, walls) capsules_cost = _food_cost(capsules, pos, walls) ghosts_dis, s_ghosts_dis = _ghost_cost(ghosts, pos, walls) def d(x): if x == 0: return float('inf') return 9 / (x**2) ghosts_cost = sum(map(d, ghosts_dis)) s_ghosts_cost = sum(map(lambda x: x[0], filter(lambda x: x[0] < x[1], s_ghosts_dis))) return score - (2 * foods_cost) - capsules_cost - s_ghosts_cost - ghosts_cost
def __init__(self, startingGameState: pacman.GameState): self.start = (startingGameState.getPacmanPosition(), startingGameState.getFood()) self.walls = startingGameState.getWalls() self.startingGameState = startingGameState self._expanded = 0 # DO NOT CHANGE self.heuristicInfo = { } # A dictionary for the heuristic to store information
def __init__(self, startingGameState: pacman.GameState): """ Stores the walls, pacman's starting position and corners. """ self.walls = startingGameState.getWalls() self.startingPosition = startingGameState.getPacmanPosition() top, right = self.walls.height - 2, self.walls.width - 2 self.corners = ((1, 1), (1, top), (right, 1), (right, top)) for corner in self.corners: if not startingGameState.hasFood(*corner): print('Warning: no food in corner ' + str(corner)) self._expanded = 0 # DO NOT CHANGE; Number of search nodes expanded # Please add any code here which you would like to use # in initializing the problem "*** YOUR CODE HERE ***" self.startState = PositionWithFoods(self.startingPosition, self.corners) self.to_foods: Dict[Coordinate, Dict[Coordinate, float]] = {} for c in self.corners: queue = util.Queue() queue.push((c, 0)) distances = {} while not queue.isEmpty(): pos, dis = queue.pop() x, y = pos if pos in distances: continue distances[pos] = dis for action in DIRECTIONS: dx, dy = Actions.directionToVector(action) next_pos = int(x + dx), int(y + dy) nextx, nexty = next_pos if next_pos not in distances and not self.walls[nextx][ nexty]: queue.push((next_pos, dis + 1)) self.to_foods[c] = distances self.to_other_foods = {} def tmp(foods, curr): key = (curr, tuple(sorted(foods))) if len(foods) == 1: self.to_other_foods[key] = 0 return 0 if key in self.to_other_foods: return self.to_other_foods[key] left_overs = list(foods) left_overs.remove(curr) self.to_other_foods[key] = min( map(lambda c: self.to_foods[curr][c] + tmp(left_overs, c), left_overs)) return self.to_other_foods[key] for c in self.corners: tmp(self.corners, c)
def __init__(self, gameState: pacman.GameState): "Stores information from the gameState. You don't need to change this." # Store the food for later reference self.food = gameState.getFood() # Store info for the PositionSearchProblem (no need to change this) self.walls = gameState.getWalls() self.startState = gameState.getPacmanPosition() self.costFn = lambda x: 1 self._visited, self._visitedlist, self._expanded = {}, [], 0 # DO NOT CHANGE
def __init__(self, start_game_state: GameState): super().__init__(start_game_state) self._expanded = 0 # DO NOT CHANGE; Number of search nodes expanded self.startingPosition = start_game_state.getPacmanPosition() self.capsules = tuple(start_game_state.getCapsules()) self.foods = start_game_state.getFood() self.walls = start_game_state.getWalls() self.costFn = lambda x: 1 self.start_game_state = start_game_state self.is_eating_capsule = True
def findPathToClosestDot(self, gameState: pacman.GameState): """ Returns a path (a list of actions) to the closest dot, starting from gameState. """ # Here are some useful elements of the startState startPosition = gameState.getPacmanPosition() food = gameState.getFood() walls = gameState.getWalls() problem = AnyFoodSearchProblem(gameState) "*** YOUR CODE HERE ***" return search.bfs(problem)
def mazeDistance(point1, point2, gameState: pacman.GameState): """ Returns the maze distance between any two points, using the search functions you have already built. The gameState can be any game state -- Pacman's position in that state is ignored. Example usage: mazeDistance( (2,4), (5,6), gameState) This might be a useful helper function for your ApproximateSearchAgent. """ x1, y1 = point1 x2, y2 = point2 walls = gameState.getWalls() assert not walls[x1][y1], 'point1 is a wall: ' + str(point1) assert not walls[x2][y2], 'point2 is a wall: ' + str(point2) prob = PositionSearchProblem(gameState, start=point1, goal=point2, warn=False, visualize=False) return len(search.bfs(prob))