def allManhattanHeuristic(state, problem): 
    position, foodGrid = state
    foodPositions = foodGrid.asList()
    if len(foodPositions)==0:return 0

    allManhattan = 0
    allPositions = [position] + foodPositions
    
    for pos in foodPositions:
        minManhattan = 999999
        for pos2 in allPositions:
            dist = util.manhattanDistance( pos2, pos )
            if dist == 0: 
                continue
            if dist < minManhattan:
                minManhattan = dist
        allManhattan += minManhattan

    minManhattan = 999999
    for pos in foodPositions:
        dist = util.manhattanDistance( position, pos )
        if dist < minManhattan:
            minManhattan = dist
    allManhattan = (allManhattan + minManhattan)/2
    return allManhattan
Example #2
0
    def evaluationFunction(self, currentGameState, action):
        """
        Design a better evaluation function here.

        The evaluation function takes in the current and proposed successor
        GameStates (pacman.py) and returns a number, where higher numbers are better.

        The code below extracts some useful information from the state, like the
        remaining food (newFood) and Pacman position after moving (newPos).
        newScaredTimes holds the number of moves that each ghost will remain
        scared because of Pacman having eaten a power pellet.

        Print out these variables to see what you're getting, then combine them
        to create a masterful evaluation function.
        """
        # Useful information you can extract from a GameState (pacman.py)
        successorGameState = currentGameState.generatePacmanSuccessor(action)
        newPos = successorGameState.getPacmanPosition()
        newFood = successorGameState.getFood()
        newGhostStates = successorGameState.getGhostStates()
        newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]

        "*** YOUR CODE HERE ***"
        yo = newFood.height/2
        xo = newFood.width/2
        origin = (xo, yo)
        q1 = []
        q2 = []
        q3 = []
        q4 = []
        for x in range(0, newFood.width):
            for y in range (0, newFood.height):
                if newFood[x][y] == True:
                    if x > xo:
                        if y > yo:                        
                            q1.append((x, y))
                        else:
                            q4.append((x, y))
                    else:
                        if y > yo:
                            q2.append((x, y))
                        else:
                            q3.append((x, y))
        q = [q1, q2, q3, q4]
        z = max(q)
        tot = len(z)
        avgx = 0
        avgy = 0
        for i in z:
            avgx += (float(i[0])/tot)
            avgy += (float(i[1])/tot)
        n = manhattanDistance((avgx, avgy), newPos)
        z1 = [manhattanDistance(i.getPosition(), newPos) for i in newGhostStates]
        t = 0
        for i in q:
            if len(i) == 0:
                t += 100
        if min(z1) < 2:
            t -= 300
        return successorGameState.getScore()*4 - n*(2) + t
  def evaluationFunction(self, currentGameState, action):
    """
    Design a better evaluation function here.

    The evaluation function takes in the current and proposed successor
    GameStates (pacman.py) and returns a number, where higher numbers are better.

    The code below extracts some useful information from the state, like the
    remaining food (newFood) and Pacman position after moving (newPos).
    newScaredTimes holds the number of moves that each ghost will remain
    scared because of Pacman having eaten a power pellet.

    Print out these variables to see what you're getting, then combine them
    to create a masterful evaluation function.
    """
    # Useful information you can extract from a GameState (pacman.py)
    successorGameState = currentGameState.generatePacmanSuccessor(action)
    newPos = successorGameState.getPacmanPosition()
    newFood = successorGameState.getFood()
    newGhostStates = successorGameState.getGhostStates()
    newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]

    heuristic = 0
    
    for st in newScaredTimes:
        heuristic += st
         
	ghostDistances = []
	for gs in newGhostStates:
	 ghostDistances += [manhattanDistance(gs.getPosition(),newPos)]

	foodList = newFood.asList()

	wallList = currentGameState.getWalls().asList()

	emptyFoodNeighbors = 0
	foodDistances = []

	def foodNeighbors(foodPos):
		foodNeighbors = []
		foodNeighbors.append((foodPos[0]-1,foodPos[1]))
		foodNeighbors.append((foodPos[0],foodPos[1]-1))
		foodNeighbors.append((foodPos[0],foodPos[1]+1))
		foodNeighbors.append((foodPos[0]+1,foodPos[1]))
		return foodNeighbors

	for f in foodList:
		neighbors = foodNeighbors(f)
		for fn in neighbors:
		 if fn not in wallList and fn not in foodList:
			emptyFoodNeighbors += 1
		foodDistances += [manhattanDistance(newPos,f)]

	inverseFoodDist = 0
	if len(foodDistances) > 0:
		inverseFoodDist = 1.0/(min(foodDistances))
     
	heuristic += (min(ghostDistances)*((inverseFoodDist**4)))
	heuristic += successorGameState.getScore()-(float(emptyFoodNeighbors)*4.5)
	return heuristic
  def evaluationFunction(self, currentGameState, action):
    """
    Design a better evaluation function here.

    The evaluation function takes in the current and proposed successor
    GameStates (pacman.py) and returns a number, where higher numbers are better.

    The code below extracts some useful information from the state, like the
    remaining food (oldFood) and Pacman position after moving (newPos).
    newScaredTimes holds the number of moves that each ghost will remain
    scared because of Pacman having eaten a power pellet.

    Print out these variables to see what you're getting, then combine them
    to create a masterful evaluation function.
    """
    # Useful information you can extract from a GameState (pacman.py)
    successorGameState = currentGameState.generatePacmanSuccessor(action)
    newPos = successorGameState.getPacmanPosition()
    oldFood = currentGameState.getFood()
    newGhostStates = successorGameState.getGhostStates()
    newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]

    "*** YOUR CODE HERE ***"

    foodDistance = [manhattanDistance(newPos, foodPos) for foodPos in oldFood.asList()]
    minFoodDistance = min(foodDistance)

    ghostsPositions = [ghost.getPosition() for ghost in newGhostStates]
    ghostsDistance = [manhattanDistance(newPos, ghostPos) for ghostPos in ghostsPositions]
    minGhostDistance = min(ghostsDistance)

    return 1/(minFoodDistance+0.1) - 1/(minGhostDistance+0.1)
Example #5
0
def cornersHeuristic(state, problem):
    """
    A heuristic for the CornersProblem that you defined.

      state:   The current search state
               (a data structure you chose in your search problem)

      problem: The CornersProblem instance for this layout.

    This function should always return a number that is a lower bound
    on the shortest path from the state to a goal of the problem; i.e.
    it should be admissible (as well as consistent).
    """
    corners = problem.corners # These are the corner coordinates
    walls = problem.walls # These are the walls of the maze, as a Grid (game.py)

    "*** YOUR CODE HERE ***"
    cornersBoolean = state[1]
    currentPosition = state[0]
    maxManhattan = 0

    for cornerPosition, visited in cornersBoolean.iteritems():
        if (visited == False) & (util.manhattanDistance(currentPosition, cornerPosition) > maxManhattan):
            maxManhattan = util.manhattanDistance(currentPosition, cornerPosition)

    return maxManhattan
def betterEvaluationFunction(currentGameState):
  """
    Your extreme ghost-hunting, pellet-nabbing, food-gobbling, unstoppable
    evaluation function (question 5).

    DESCRIPTION: <I add the score of the scared time of the ghosts when counting the final 
    score of the currentGameState and use almost exactly the same evaluation function as 
    question one(I thought we have to come up with a very good evaluation function there, so
    I did a lot of work there. The distance of the food and the distance between the current 
    position between pacman and ghost are the two significant factor in deciding the score. 
    And I sum the reciprocal of food distance and then minus the sum of reciprocal of the 
    suitable ghost distance. For scared times, because the longer the time is, the higher 
    winning rate the pacman has. Therefore I use the result add the summation of the scared
    time >
  """
  "*** YOUR CODE HERE ***"

  newPos = currentGameState.getPacmanPosition()
  newFood = currentGameState.getFood()
  newGhostStates = currentGameState.getGhostStates()
  newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]
  Foodlist = newFood.asList()
  listDis1 = []
  listDis2 = []
  for elem in Foodlist:
      listDis1.append(1.0/util.manhattanDistance(newPos, elem))
  for elem in newGhostStates:
      dis = util.manhattanDistance(newPos, elem.getPosition())
      if dis!=0.0 and dis<3:
          listDis2.append(1.0/dis)
  foodTotal = sum(listDis1)
  ghostTotal = sum(listDis2)
  scaredScore = sum(newScaredTimes)
  return currentGameState.getScore()+foodTotal-28*ghostTotal+scaredScore*1.2
  def evaluationFunction(self, currentGameState, action):
    """
    Design a better evaluation function here.

    The evaluation function takes in the current and proposed successor
    GameStates (pacman.py) and returns a number, where higher numbers are better.

    The code below extracts some useful information from the state, like the
    remaining food (newFood) and Pacman position after moving (newPos).
    newScaredTimes holds the number of moves that each ghost will remain
    scared because of Pacman having eaten a power pellet.

    Print out these variables to see what you're getting, then combine them
    to create a masterful evaluation function.
    """
    # Useful information you can extract from a GameState (pacman.py)
    successorGameState = currentGameState.generatePacmanSuccessor(action)
    newPos = successorGameState.getPacmanPosition()
    newFood = successorGameState.getFood()
    newGhostStates = successorGameState.getGhostStates()
    newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]

    "*** YOUR CODE HERE ***"
    Foodlist = newFood.asList()
    listDis1 = []
    listDis2 = []
    for elem in Foodlist:
        listDis1.append(1.0/util.manhattanDistance(newPos, elem))
    for elem in newGhostStates:
        dis = util.manhattanDistance(newPos, elem.getPosition())
        if dis!=0.0 and dis<3:
            listDis2.append(1.0/dis)
    foodTotal = sum(listDis1)
    ghostTotal = sum(listDis2)
    return successorGameState.getScore()+foodTotal-28*ghostTotal
    def evaluationFunction(self, currentGameState, action):
        """
        Design a better evaluation function here.

        The evaluation function takes in the current and proposed successor
        GameStates (pacman.py) and returns a number, where higher numbers are better.

        The code below extracts some useful information from the state, like the
        remaining food (newFood) and Pacman position after moving (newPos).
        newScaredTimes holds the number of moves that each ghost will remain
        scared because of Pacman having eaten a power pellet.

        Print out these variables to see what you're getting, then combine them
        to create a masterful evaluation function.
        """
        # Useful information you can extract from a GameState (pacman.py)
        successorGameState = currentGameState.generatePacmanSuccessor(action)
        newPos = successorGameState.getPacmanPosition()
        newFood = successorGameState.getFood()
        newGhostStates = successorGameState.getGhostStates()
        newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]

        
        newFoodPositions = newFood.asList()
        score = 0
        if newFoodPositions:
          closestFoodPos, closestFoodDist = min([(foodPos,util.manhattanDistance(newPos, foodPos)) for foodPos in newFoodPositions], key = lambda x: x[1])

          closestGhostPos, closestGhostDist = min([(ghostState.getPosition(), util.manhattanDistance(newPos, ghostState.getPosition()) ) for ghostState in newGhostStates], key = lambda x: x[1])

          score = (1.0/(closestFoodDist + 1)) - (2.0/(closestGhostDist + 1))

        return successorGameState.getScore() + score
Example #9
0
def betterEvaluationFunction(currentGameState):
	"""
	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 ***"
	newPos = currentGameState.getPacmanPosition()
	newFood = currentGameState.getFood()
	newGhostStates = currentGameState.getGhostStates()
	newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]
	
	ghostDis = util.manhattanDistance(newPos, newGhostStates[0].getPosition())
	disFood = dict()
	foodDis = 0
	if (len(newFood.asList())!=0):
		for f in newFood.asList():
			disFood[f] = util.manhattanDistance(newPos, f)
		minFood = min(disFood, key=disFood.get)
		foodDis = disFood[minFood]
		
	return -0.05*foodDis-len(newFood.asList())-2**(2-ghostDis)
	#return currentGameState.getScore()
	util.raiseNotDefined()
Example #10
0
  def checkDeath( state, agentIndex):
    agentState = state.data.agentStates[agentIndex]
    if state.isOnRedTeam(agentIndex):
      otherTeam = state.getBlueTeamIndices()
    else:
      otherTeam = state.getRedTeamIndices()
    if agentState.isPacman:
      for index in otherTeam:
        otherAgentState = state.data.agentStates[index]
        if otherAgentState.isPacman: continue
        ghostPosition = otherAgentState.getPosition()
        if ghostPosition == None: continue
        if manhattanDistance( ghostPosition, agentState.getPosition() ) <= COLLISION_TOLERANCE:
          # award points to the other team for killing Pacmen
          if otherAgentState.scaredTimer <= 0:
            AgentRules.dumpFoodFromDeath(state, agentState, agentIndex)

            score = KILL_POINTS
            if state.isOnRedTeam(agentIndex):
              score = -score
            state.data.scoreChange += score
            agentState.isPacman = False
            agentState.configuration = agentState.start
            agentState.scaredTimer = 0
            break
          else:
            score = KILL_POINTS
            if state.isOnRedTeam(agentIndex):
              score = -score
            state.data.scoreChange += score
            otherAgentState.isPacman = False
            otherAgentState.configuration = otherAgentState.start
            otherAgentState.scaredTimer = 0
    else: # Agent is a ghost
      for index in otherTeam:
        otherAgentState = state.data.agentStates[index]
        if not otherAgentState.isPacman: continue
        pacPos = otherAgentState.getPosition()
        if pacPos == None: continue
        if manhattanDistance( pacPos, agentState.getPosition() ) <= COLLISION_TOLERANCE:
          #award points to the other team for killing Pacmen
          if agentState.scaredTimer <= 0:
            AgentRules.dumpFoodFromDeath(state, otherAgentState, agentIndex)

            score = KILL_POINTS
            if not state.isOnRedTeam(agentIndex):
              score = -score
            state.data.scoreChange += score
            otherAgentState.isPacman = False
            otherAgentState.configuration = otherAgentState.start
            otherAgentState.scaredTimer = 0
            break
          else:
            score = KILL_POINTS
            if state.isOnRedTeam(agentIndex):
              score = -score
            state.data.scoreChange += score
            agentState.isPacman = False
            agentState.configuration = agentState.start
            agentState.scaredTimer = 0
def betterEvaluationFunction(currentGameState):

    """
      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 ***"
    newPos = currentGameState.getPacmanPosition()
    newFood = currentGameState.getFood()
    newGhostStates = currentGameState.getGhostStates()
    newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]
  
    newFoodPositions = newFood.asList()
    score = 0
    if newFoodPositions:
        closestFoodPos, closestFoodDist = min([(foodPos,util.manhattanDistance(newPos, foodPos)) for foodPos in newFoodPositions], key = lambda x: x[1])
        closestGhostPos, closestGhostDist = min([(ghostState.getPosition(), util.manhattanDistance(newPos, ghostState.getPosition()) ) for ghostState in newGhostStates], key = lambda x: x[1])
        
        if closestFoodDist >= 2*closestGhostDist:
            a = 100.0
            b = 2.0
        else:
            a = 5.0
            b = 2.0
      
        score = (a/(closestFoodDist + 1)) - (b/(closestGhostDist + 1))

    return currentGameState.getScore() + score    
Example #12
0
  def evaluationFunction(self, currentGameState, action):
    """
    Design a better evaluation function here.

    The evaluation function takes in the current and proposed successor
    GameStates (pacman.py) and returns a number, where higher numbers are better.

    The code below extracts some useful information from the state, like the
    remaining food (newFood) and Pacman position after moving (newPos).
    newScaredTimes holds the number of moves that each ghost will remain
    scared because of Pacman having eaten a power pellet.

    Print out these variables to see what you're getting, then combine them
    to create a masterful evaluation function.
    """
    # Useful information you can extract from a GameState (pacman.py)
    successorGameState = currentGameState.generatePacmanSuccessor(action)
    newPos = successorGameState.getPacmanPosition()
    newFood = successorGameState.getFood()
    newGhostStates = successorGameState.getGhostStates()
    newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]

    food=[]
    for x in newFood.asList():
      food.append(manhattanDistance(newPos,x))
    score=0
    if len(food)>0 :
      score=1/sum(food)+5/min(food)+successorGameState.getScore()
    for x in newGhostStates:
      if manhattanDistance(newPos,x.getPosition())<2:
        return -10
    if score > 0:
      return score
    return successorGameState.getScore()
  def evaluationFunction(self, currentGameState, action):
    """
    Design a better evaluation function here.

    The evaluation function takes in the current and proposed successor
    GameStates (pacman.py) and returns a number, where higher numbers are better.

    The code below extracts some useful information from the state, like the
    remaining food (oldFood) and Pacman position after moving (newPos).
    newScaredTimes holds the number of moves that each ghost will remain
    scared because of Pacman having eaten a power pellet.

    Print out these variables to see what you're getting, then combine them
    to create a masterful evaluation function.
    """
    # Useful information you can extract from a GameState (pacman.py)
    successorGameState = currentGameState.generatePacmanSuccessor(action)
    newPos = successorGameState.getPacmanPosition()
    oldFood = currentGameState.getFood().asList()
    newGhostStates = successorGameState.getGhostStates()
    newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]

    capsules = currentGameState.getCapsules()
    oldFood += capsules
    ghostDistances = [manhattanDistance(newPos, ghost.getPosition()) for ghost in newGhostStates]
    closestFood = min([manhattanDistance(newPos, food) for food in oldFood])
    minIndex = 0
    for i in range(len(ghostDistances)):
      if ghostDistances[i] < ghostDistances[minIndex]:
        minIndex = i

    time = newScaredTimes[minIndex]
    eval = time + ghostDistances[minIndex]/float(closestFood + 1)

    return eval
Example #14
0
def betterEvaluationFunction(currentGameState):
    """
      Your extreme ghost-hunting, pellet-nabbing, food-gobbling, unstoppable
      evaluation function (question 5).

      DESCRIPTION: <write something here so we know what you did>
    """

    newPos = currentGameState.getPacmanPosition()
    newFood = currentGameState.getFood()
    newGhostStates = currentGameState.getGhostStates()
    newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]

    farest_food = 0
    nearest_food = 99999
    if newFood.count() > 0:
        for food in newFood.asList():
            farest_food = max(farest_food, manhattanDistance(newPos, food))
            nearest_food = min(nearest_food, manhattanDistance(newPos, food))
    else:
        nearest_food = 0

    ng = 99999
    fg = 0
    for ghost in newGhostStates:
        ng = min(ng, manhattanDistance(newPos, ghost.getPosition()))
        fg = max(fg, manhattanDistance(newPos, ghost.getPosition()))

    evaluation = currentGameState.getScore() - newFood.count(False) - 0.7 * nearest_food + 0.5 * ng

    return evaluation
Example #15
0
  def evaluationFunction(self, currentgameState, action):
    """
    Design a better evaluation function here.

    The evaluation function takes in the current and proposed successor
    gameStates (pacman.py) and returns a number, where higher numbers are better.

    The code below extracts some useful information from the state, like the
    remaining food (newFood) and Pacman position after moving (newPos).
    newScaredTimes holds the number of moves that each ghost will remain
    scared because of Pacman having eaten a power pellet.

    Print out these variables to see what you're getting, then combine them
    to create a masterful evaluation function.
    """
    # Useful information you can extract from a gameState (pacman.py)
    successorgameState = currentgameState.generatePacmanSuccessor(action)
    newPos = successorgameState.getPacmanPosition()
    newFood = successorgameState.getFood()
    newGhostStates = successorgameState.getGhostStates()
    foodNum = currentgameState.getFood().count()
    if len(newFood.asList()) == foodNum:  # if this action does not eat a food 
        dis = BIGNUM
        for pt in newFood.asList():
            if manhattanDistance(pt , newPos) < dis :
                dis = manhattanDistance(pt, newPos)
    else:
        dis = 0
    for ghost in newGhostStates:  # the impact of ghost surges as distance get close
        dis += 4 ** (2 - manhattanDistance(ghost.getPosition(), newPos))
    return -dis
    def evaluationFunction(self, currentGameState, action):
        """
        Design a better evaluation function here.

        The evaluation function takes in the current and proposed successor
        GameStates (pacman.py) and returns a number, where higher numbers are better.

        The code below extracts some useful information from the state, like the
        remaining food (newFood) and Pacman position after moving (newPos).
        newScaredTimes holds the number of moves that each ghost will remain
        scared because of Pacman having eaten a power pellet.

        Print out these variables to see what you're getting, then combine them
        to create a masterful evaluation function.
        """
        # Useful information you can extract from a GameState (pacman.py)
        successorGameState = currentGameState.generatePacmanSuccessor(action)
	oldPos = currentGameState.getPacmanPosition()
        newPos = successorGameState.getPacmanPosition()
        newFood = successorGameState.getFood()
        newGhostStates = successorGameState.getGhostStates()
	newG = successorGameState.getGhostPositions()
        newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]
	food = newFood.asList()
	a = [util.manhattanDistance(newPos,df) for df in food]
	b = [util.manhattanDistance(oldPos,df) for df in food]
	g = min([util.manhattanDistance(newG[i],newPos) for i in range(len(newG))])
	#print action
	if (len(a) ==len(b)):
		return -1/g + 1
	else:
		return 1/a -1/g	
	'''if b in set(newG):
Example #17
0
def betterEvaluationFunction(currentGameState):
    """
      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 ***"
    newPos = currentGameState.getPacmanPosition()
    newFood = currentGameState.getFood()
    newGhostStates = currentGameState.getGhostStates()
    newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]
    
    score = 0
    min_dis = float('inf')
    for pos in  newFood.asList():
        temp = manhattanDistance(pos, newPos)
        if temp < min_dis:
            min_dis = temp
    if (min_dis < float('inf')):
        score -= min_dis

    score -= 1000*currentGameState.getNumFood()            
    score -= len(currentGameState.getCapsules())*10
    for pos in currentGameState.getGhostPositions():
        dis = manhattanDistance(pos, newPos)
        if (dis <= 3): score = -float('inf')
    score += currentGameState.getScore()*10
    return score        
def enhancedPacmanFeatures(state, action):
    """
    For each state, this function is called with each legal action.
    It should return a counter with { <feature name> : <feature value>, ... }
    """
    features = util.Counter()
    "*** YOUR CODE HERE ***"
    # util.raiseNotDefined()
    state = state.generateSuccessor(0, action)
    pacLocation = state.getPacmanPosition()

    features['numFoodLeft'] = state.getNumFood()

    foodLocs = state.getFood().asList()
    nearestFoodDist = 0
    if foodLocs:
        nearestFoodDist = min([util.manhattanDistance(pacLocation, food) for food in foodLocs])
    nearestFoodDist = 10.0/nearestFoodDist if nearestFoodDist else nearestFoodDist
    features['nearestFoodDist'] = nearestFoodDist

    ghostLocs = state.getGhostPositions()
    nearestGhostDist = 0
    if ghostLocs:
        nearestGhostDist = min(util.manhattanDistance(loc, pacLocation) for loc in ghostLocs)
    nearestGhostDist = 10.0/nearestGhostDist if nearestGhostDist else nearestGhostDist
    features['nearestGhostDist'] = nearestGhostDist

    return features
def betterEvaluationFunction(currentGameState):
    """
      Your extreme ghost-hunting, pellet-nabbing, food-gobbling, unstoppable
      evaluation function (question 5).

      DESCRIPTION: <write something here so we know what you did>
    """
    pos = currentGameState.getPacmanPosition()
    lfood = currentGameState.getFood()
    ghostStates = currentGameState.getGhostStates()
    gpos =currentGameState.getGhostPositions()
    nfood=currentGameState.getNumFood()
    caps=currentGameState.getCapsules()
    st = [ghostState.scaredTimer for ghostState in ghostStates]
    food = lfood.asList()
    minfoodd = min([util.manhattanDistance(pos,df) for df in food])
    mincapsd=min([util.manhattanDistance(pos,d) for d in caps])
    g =sum([1.0/(util.manhattanDistance(gpos[i],pos)+0.1) for i in range(len(gpos))])
    numOfScaredGhosts = 0
    m = 0
    print nfood,minfoodd,mincapsd
    for ghostState in ghostStates: 
        if ghostState.scaredTimer is 0:
            numOfScaredGhosts += 1
    if numOfScaredGhosts > 0 :
	m = -300.0
    else:
	m = 300.0
    return -100.0*len(caps) -20.0*len(food) +1.0/minfoodd +m*g	
    util.raiseNotDefined()
def betterEvaluationFunction(currentGameState):
    """
    Your extreme ghost-hunting, pellet-nabbing, food-gobbling, unstoppable
    evaluation function (question 5).

    DESCRIPTION: <write something here so we know what you did>
    I want to incentivize winning so I return infinity if that is a win state.
    A large part of my strategy was "don't die." Dying gives you usually ~300 or less points, which will hurt your average. Winning usually gives
    you more points than losing.
    Here are the things I considered, along with some commentary on my decision making regarding them:1
    
    distance to the closest ghost: (disttoghost): I wanted pacman to run away from ghosts if they got too close. I did this
    by doing score += max(disttoghost, 4) * 2. If the ghost is more than distance 4 away, I didn't really care, and there is no difference between
    the ghost being 5 away and 500 away, because it's not close enough to threaten pacman. I added the max because my pacman would sometimes try to get
    farther away from a ghost already a long way away instead of going for food. That led to a lot of pacman idling in corners, wasting time and points. I added
    the * 2 so that the penalty for being near a ghost would be more severe and hopefully cause pacman to tend away from getting too close.
    
    closest food: I wanted to reward heading towards food, but not to the extent that it overrode the penalty of getting too close to a ghost. Thus, the score
    will be higher the closer pacman goes towards a food. By subtracting 1.5 * the distance, I got further distances to food to receive lower scores. This, however,
    introduced a problem where sometimes pacman would refuse to eat an isolated food because that would make the next turn's distance to food much higher. Thus, I had 
    to add the next thing.
    
    bonus for eating food: I subtracted 4 times the number of remaining foods, so that eating food would cause a more markedly higher score. You can only eat one food
    per move, so this made eating food preferable over not eating food.
    
    capsules: I thought that eating ghosts would increase my score, so I tried to slightly incentivize moving onto a capsule so that eating ghosts could increase my score.
    Thus, I subtracted 3.5 from scores for each existing capsule. This would only make a difference near the capsule.
    
    I then watched pacman's actions and adjusted the weights and numbers to visible strategic flaws.
    
    When I last submitted this, this averaged slightly over 1000. Let's hope it does so again.
    
    
  """
    "*** YOUR CODE HERE ***"
    if currentGameState.isWin():
        return float("inf")
    if currentGameState.isLose():
        return -float("inf")
    score = scoreEvaluationFunction(currentGameState)
    newFood = currentGameState.getFood()
    foodPos = newFood.asList()
    closestfood = float("inf")
    for pos in foodPos:
        thisdist = util.manhattanDistance(pos, currentGameState.getPacmanPosition())
        if thisdist < closestfood:
            closestfood = thisdist
    numghosts = currentGameState.getNumAgents() - 1
    i = 1
    disttoghost = float("inf")
    while i <= numghosts:
        nextdist = util.manhattanDistance(currentGameState.getPacmanPosition(), currentGameState.getGhostPosition(i))
        disttoghost = min(disttoghost, nextdist)
        i += 1
    score += max(disttoghost, 4) * 2
    score -= closestfood * 1.5
    capsulelocations = currentGameState.getCapsules()
    score -= 4 * len(foodPos)
    score -= 3.5 * len(capsulelocations)
    return score
    def ddist_ghost(self,state,action):
        pacState = state.getPacmanState()
        legalActions = state.getLegalPacmanActions()
        pacpos = pacState.getPosition()
        speed = 1.0

        actionVector = Actions.directionToVector( action , speed )
        ghostsPositions = [self.ghostsdict['bad'][0].getPosition()]
        for i in range(3):
            ghostsPositions.append(self.ghostsdict['good'][i][0].getPosition())
        newPosition = (pacpos[0]+actionVector[0], pacpos[1]+actionVector[1])
        curDistancesG = [manhattanDistance(pacpos,ghostPosition) for ghostPosition in ghostsPositions]
        distanceGhosts = [manhattanDistance(newPosition,ghostPosition) for ghostPosition in ghostsPositions]

        capsulesPositions = [cap[0] for cap in self.capsules]
        curDistancesC = [manhattanDistance(pacpos,capsulePosition) for capsulePosition in capsulesPositions]
        distanceCapsules = [manhattanDistance(newPosition,capsulePosition) for capsulePosition in capsulesPositions]

        distances = np.array(distanceGhosts+distanceCapsules)
        curDistances = np.array(curDistancesG+curDistancesC)

        candiAns = (distances-curDistances)/np.absolute(curDistances.clip(1))
        if state.scaredGhostPresent():
            candiAns[0] = -candiAns[0]
            candiAns[-2] = 0
            candiAns[-1] = 0
        return candiAns
Example #22
0
def betterEvaluationFunction(currentGameState):
    """
      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 ***"
    newPos = currentGameState.getPacmanPosition()
    newFood = currentGameState.getFood().asList()
    newGhostStates = currentGameState.getGhostStates()
    newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]
    newCapsules = currentGameState.getCapsules()
    score = currentGameState.getScore()
    scared = sum(newScaredTimes)

    dist2food = 100

    if len(newFood) > 0:
        dist2food = min(dist2food, min([manhattanDistance(newPos, food) for food in newFood]))

    dist2food = 1.0/dist2food


    dist2cap = 100

    if len(newCapsules) > 0:
        dist2cap = min(dist2cap, min([manhattanDistance(newPos, cap) for cap in newCapsules]))

    dist2cap = 1.0/dist2cap

    return score + dist2food + dist2cap + scared
def betterEvaluationFunction(currentGameState):
    """
      Your extreme ghost-hunting, pellet-nabbing, food-gobbling, unstoppable
      evaluation function (question 5).

      DESCRIPTION: 
          Score more if we have less food left
          Score more if the distance to all the remaining food is less
          Score more if the nerest ghost is further away (up to a point, effectively ignore them once they get far enough away)
    """
    food = currentGameState.getFood()
    foodList = food.asList()
    foodDistance = 0.001 # Make sure we don't have divide by zero
    pacmanPos = currentGameState.getPacmanPosition()
    for food in foodList:
        foodDistance += manhattanDistance(pacmanPos, food)
     
    minGhostDistance = None
    for ghostPos in currentGameState.getGhostPositions():
        ghostDistance = manhattanDistance(pacmanPos, ghostPos)
        if minGhostDistance == None or minGhostDistance > ghostDistance:
           minGhostDistance = ghostDistance        
    if minGhostDistance > 3:
        minGhostDistance = 0   

    return currentGameState.getScore() + 10.0 * (1.0 / foodDistance) + 10.0 * (2.0 / (currentGameState.getNumFood() + 1.0)) + 0.1 * minGhostDistance
Example #24
0
def betterEvaluationFunction(currentGameState):
    """
      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 ***"
    # precalculamos algunas variables
    pacmanPos = currentGameState.getPacmanPosition()
    ghostStates = currentGameState.getGhostStates()
    food = currentGameState.getFood()
    # por defect retornamos el score propio del estado
    score = currentGameState.getScore()
    # si el estado es ganador retornamos directamente un score muy bueno
    if currentGameState.isWin(): return 100 + score
    # cuanta mas comida queda por comer menos score
    if food.count() > 0: score += (1.0 / food.count()) * 20
    # si un fantasma esta asustado nos lo comemos, sino huimos
    for ghost in ghostStates:
        ghostPos = ghost.getPosition()
        if ghost.scaredTimer < 1:
            if manhattanDistance(pacmanPos, ghostPos) == 1:
                score = -100
        else:
            score += (1.0 / manhattanDistance(pacmanPos, ghostPos)) * 10
    # cuanto mas cerca estemos de la comida mas cercana mas score
    d2f = float("inf")
    for f in food.asList():
        d2f = min(d2f, manhattanDistance(pacmanPos, f))
    score -= d2f

    return score
Example #25
0
def cornersHeuristic(state, problem):
    """
    A heuristic for the CornersProblem that you defined.
    
      state:   The current search state
               (a data structure you chose in your search problem)
    
      problem: The CornersProblem instance for this layout.
    
    This function should always return a number that is a lower bound on the
    shortest path from the state to a goal of the problem; i.e.  it should be
    admissible (as well as consistent).
    """
    corners = problem.corners
    walls = problem.walls
    currPos, cornersLeft = state
    dist = []
    weights = [ (util.manhattanDistance(currPos, corner), corner) for corner in cornersLeft ]
    while weights:
        curMin = min(weights, key=lambda a: a[0])
        weights.remove(curMin)
        dist.append(curMin[0])
        weights = [ (util.manhattanDistance(curMin[1], corner), corner) for w, corner in weights ]

    return sum(dist)
Example #26
0
def betterEvaluationFunction(currentGameState):
    """
      Your extreme ghost-hunting, pellet-nabbing, food-gobbling, unstoppable
      evaluation function (question 5).

      DESCRIPTION: <write something here so we know what you did>
    """
    pos = currentGameState.getPacmanPosition()
    foodGrid = currentGameState.getFood()
    ghostStates = currentGameState.getGhostStates()

    closet_ghost_pos = None
    ghostContrib = 0
    for ghost in ghostStates:
        ghost_pos = util.manhattanDistance(pos, ghost.getPosition())
        closet_ghost_pos = ghost_pos if not closet_ghost_pos or ghost_pos < closet_ghost_pos else closet_ghost_pos

        ghostContrib = -0.5*1.0/(closet_ghost_pos + 1)
        if ghost.scaredTimer:
            ghostContrib *= -2

    # compute food contrib
    closest_food = None
    closest_food_distance = None
    for food in foodGrid.asList():
        food_distance = util.manhattanDistance(pos, food)
        if not closest_food or closest_food_distance > food_distance:
            closest_food_distance = food_distance
            closest_food = food

    if not closest_food_distance:
        closest_food_distance = 1000000
    foodContrib = 1.0/closest_food_distance - 2.1*len(foodGrid.asList())

    # is a wall in our way?
    wall_contrib = 0
    if closest_food:
        if closest_food[0] < pos[0]:
            if currentGameState.hasWall(pos[0] - 1, pos[1]):
                wall_contrib -= 1
        elif closest_food[0] > pos[0]:
            if currentGameState.hasWall(pos[0] + 1, pos[1]):
                wall_contrib -= 1
        elif closest_food[1] < pos[1]:
            if currentGameState.hasWall(pos[0], pos[1] - 1):
                wall_contrib -= 1
        elif closest_food[1] > pos[1]:
            if currentGameState.hasWall(pos[0], pos[1] + 1):
                wall_contrib -= 1

    # find closest power pellet
    powerPelletContrib = [1.0/util.manhattanDistance(pos, pellet) for pellet in currentGameState.getCapsules()]
    if not powerPelletContrib:
        powerPelletContrib = 0
    else:
        powerPelletContrib = 0.9*min(powerPelletContrib)

    value = 0.5*wall_contrib + foodContrib + ghostContrib + 10*currentGameState.getScore() + powerPelletContrib

    return value
Example #27
0
    def evaluationFunction(self, currentGameState, action):
        """
        Design a better evaluation function here.

        The evaluation function takes in the current and proposed successor
        GameStates (pacman.py) and returns a number, where higher numbers are better.

        The code below extracts some useful information from the state, like the
        remaining food (newFood) and Pacman position after moving (newPos).
        newScaredTimes holds the number of moves that each ghost will remain
        scared because of Pacman having eaten a power pellet.

        Print out these variables to see what you're getting, then combine them
        to create a masterful evaluation function.
        """
        # Useful information you can extract from a GameState (pacman.py)
        successorGameState = currentGameState.generatePacmanSuccessor(action)
        newPos = successorGameState.getPacmanPosition()
        newFood = successorGameState.getFood()
        newGhostStates = successorGameState.getGhostStates()

        ghostContrib = -1*min([1.0/(util.manhattanDistance(newPos, ghost.getPosition()) + 1) for ghost in newGhostStates])
        foodArray = [1.0/(util.manhattanDistance(newPos, food) + 1) for food in newFood.asList()]
        if not foodArray:
            foodArray = [1]
        foodContrib = max(foodArray)
        scoreContrib = (successorGameState.getScore() - currentGameState.getScore())


        value = scoreContrib + ghostContrib + foodContrib
        return value
Example #28
0
    def evaluationFunction(self, currentGameState, action):
        """
        Design a better evaluation function here.

        The evaluation function takes in the current and proposed successor
        GameStates (pacman.py) and returns a number, where higher numbers are better.

        The code below extracts some useful information from the state, like the
        remaining food (newFood) and Pacman position after moving (newPos).
        newScaredTimes holds the number of moves that each ghost will remain
        scared because of Pacman having eaten a power pellet.

        Print out these variables to see what you're getting, then combine them
        to create a masterful evaluation function.
        """
        # Useful information you can extract from a GameState (pacman.py)
        successorGameState = currentGameState.generatePacmanSuccessor(action)
        newPos = successorGameState.getPacmanPosition()
        newFood = successorGameState.getFood()
        newGhostStates = successorGameState.getGhostStates()
        newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]

        "*** YOUR CODE HERE ***"
        foodList = newFood.asList()
        minFoodDist, minGhostDist = 0, 0
        if len(foodList) > 0:
            minFoodDist, closestFood = min((manhattanDistance(newPos, food), food) for food in foodList)
        if len(newGhostStates) > 0:
            minGhostDist, closestGhost = min((manhattanDistance(newPos, ghost.getPosition()), ghost) for ghost in newGhostStates)
        ghostScore = 0
        if minGhostDist < 3 and closestGhost.scaredTimer <= 0:
            ghostScore = -100
        score = 1.0 / (minFoodDist + len(foodList) + 1) + ghostScore
        return score + successorGameState.getScore()
def betterEvaluationFunction(currentGameState):
  """
    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 ***"
  #util.raiseNotDefined()
  #successorGameState = currentGameState.generatePacmanSuccessor(action)
  newPos = currentGameState.getPacmanPosition()
  newFood = currentGameState.getFood()
  newGhostStates = currentGameState.getGhostStates()
  #newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]

  ghostScore = 0
  foodDistance = []
  minFoodDistance = 10000000
  for food in newFood.asList():
      foodDistance.append(manhattanDistance(food, newPos))
  if len(foodDistance)>=1:
    minFoodDistance = min(foodDistance)
  foodScore = 1.0/(100+minFoodDistance)
  foodScore += 5.0/(len(newFood.asList())+1)
   
  for ghost in newGhostStates:
      dist = manhattanDistance(newPos, ghost.getPosition())
      if dist <= 1 and ghost.scaredTimer <= 0:
        return -100000000000
      elif dist < 3 and ghost.scaredTimer > 0:
        ghostScore += 1000000
  return foodScore + ghostScore
Example #30
0
    def evaluationFunction(self, currentGameState, action):
        """
        Design a better evaluation function here.

        The evaluation function takes in the current and proposed successor
        GameStates (pacman.py) and returns a number, where higher numbers are better.

        The code below extracts some useful information from the state, like the
        remaining food (newFood) and Pacman position after moving (newPos).
        newScaredTimes holds the number of moves that each ghost will remain
        scared because of Pacman having eaten a power pellet.

        Print out these variables to see what you're getting, then combine them
        to create a masterful evaluation function.
        """
        # Useful information you can extract from a GameState (pacman.py)
        successorGameState = currentGameState.generatePacmanSuccessor(action)
        newPos = successorGameState.getPacmanPosition()
        newFood = successorGameState.getFood().asList()
        newGhostStates = successorGameState.getGhostStates()
        newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]

        "*** YOUR CODE HERE ***"

        dist2ghost = min([manhattanDistance(newPos, ghost.getPosition()) for ghost in newGhostStates])
        dist2food = newFood and min([manhattanDistance(newPos, food) for food in newFood]) or 0
        scaredScore = sum(newScaredTimes)
        dist2food = (1.0/dist2food) if (dist2food) else dist2food

        return successorGameState.getScore() + dist2food * dist2ghost + scaredScore
Example #31
0
def strategyOne(state, problem):
    position, foodGrid = state
    if len(foodGrid.asList())==0:
        return 0
    nextTarger=minDistPoint(position,foodGrid.asList())
    return util.manhattanDistance(position,nextTarger)
    def evaluationFunction(self, currentGameState, action):
        """
        Design a better evaluation function here.

        The evaluation function takes in the current and proposed successor
        GameStates (pacman.py) and returns a number, where higher numbers are better.

        The code below extracts some useful information from the state, like the
        remaining food (newFood) and Pacman position after moving (newPos).
        newScaredTimes holds the number of moves that each ghost will remain
        scared because of Pacman having eaten a power pellet.

        Print out these variables to see what you're getting, then combine them
        to create a masterful evaluation function.
        """
        # Useful information you can extract from a GameState (pacman.py)
        successorGameState = currentGameState.generatePacmanSuccessor(action)
        newPos = successorGameState.getPacmanPosition()
        newFood = successorGameState.getFood()
        newGhostStates = successorGameState.getGhostStates()
        newScaredTimes = [
            ghostState.scaredTimer for ghostState in newGhostStates
        ]

        "*** YOUR CODE HERE ***"
        #to calculate the final score
        score = 0
        #current gamestate data
        currentPos = successorGameState.getPacmanPosition()
        ghostStates = currentGameState.getGhostStates()
        currentFood = currentGameState.getFood()
        currentGhostStates = currentGameState.getGhostStates()
        ScaredTimes = [
            ghostState.scaredTimer for ghostState in currentGhostStates
        ]
        newFoodNum = len(newFood.asList())
        curFoodNum = len(currentFood.asList())

        #calculate pos to nearest food
        curFoodDist = []
        for food in currentFood.asList():
            curFoodDist.append(manhattanDistance(currentPos, food))
        #select the min
        minFoodDist = min(curFoodDist)

        #do the same for newPos
        newFoodDist = []
        for food in newFood.asList():
            newFoodDist.append(manhattanDistance(newPos, food))
        #select the min
        minNewFoodDist = min(curFoodDist)

        #if is gonna eat add the score
        if (newFoodNum < curFoodNum):
            score += 200
        #if you get closer to a food add score
        else:
            if (minNewFoodDist < minFoodDist):
                score += minNewFoodDist * 10
            else:
                score -= minNewFoodDist * 30

        #calculate current disctance from the nearest ghost
        curGhostDist = []
        for ghost in currentGhostStates:
            curGhostDist.append(
                manhattanDistance(currentPos, ghost.getPosition()))

        minDist = min(curGhostDist)

        #do it again for newpos
        newGhostDist = []
        for ghost in newGhostStates:
            newGhostDist.append(manhattanDistance(newPos, ghost.getPosition()))

        minNewDist = min(curGhostDist)

        #if the ghosts are scared in the current position
        #prefer the closest distance
        if (sum(ScaredTimes) > 0):
            if (minNewDist < minDist):
                score += (minDist - minNewDist) * 20
        #if you are going to get closer remove score
        else:
            #this is a lose state so return very low score
            if (minNewDist <= 1):
                score = -100000
            #if the new dist is very close to a ghost remove points
            elif (minNewDist <= 10):
                score -= minNewDist * (minDist - minNewDist)

        #penalty for stop
        if action == Directions.STOP:
            score -= 100

        #add score if you are gonna eat a capsule
        if (newPos in successorGameState.getCapsules()):
            score += 200

        return score
def betterEvaluationFunction(currentGameState):
    """
    Your extreme ghost-hunting, pellet-nabbing, food-gobbling, unstoppable
    evaluation function (question 5).

    DESCRIPTION: <return a score for each state based on some factors>
    
    factors:
        distance to closest food    (40 %)
        distance to closest ghost   (30 %)
        distance to pelet           (30 %)

    """
    "*** YOUR CODE HERE ***"
    #to calculate the final score
    score = 0.0
    foodScore = 0
    ghostScore = 0
    peletScore = 0
    #current gamestate data
    currentPos = currentGameState.getPacmanPosition()
    ghostStates = currentGameState.getGhostStates()
    currentFood = currentGameState.getFood()
    currentGhostStates = currentGameState.getGhostStates()
    ScaredTimes = [ghostState.scaredTimer for ghostState in currentGhostStates]
    curFoodNum = len(currentFood.asList())
    currentPelets = currentGameState.getCapsules()

    if (currentGameState.isWin()):
        return 1000000
    elif (currentGameState.isLose()):
        return -1000000

    #assign score basted on food distance (the closer the better)

    #calculate pos to nearest food
    curFoodDist = []
    for food in currentFood.asList():
        curFoodDist.append(manhattanDistance(currentPos, food))
    #select the min
    minFoodDist = float(min(curFoodDist))

    #multiplier
    mult = 1.0 / minFoodDist * 100
    #add score
    foodScore = (mult * minFoodDist)

    #assign score basted on ghost distance (the closer the worse)

    #calculate current disctance from the nearest ghost
    curGhostDist = []
    for ghost in currentGhostStates:
        curGhostDist.append(manhattanDistance(currentPos, ghost.getPosition()))
    #select the min
    minDist = float(min(curGhostDist))
    #if the ghosts are scared in the current position
    #prefer the closest distance
    if (sum(ScaredTimes) > 0):
        #fix multiplier
        mult = 1.0 / minDist * 100
        ghostScore = (mult * minDist)
        #sign is 1 cause we want to add it to the score
        sign = 1
    else:
        #fix multiplier
        mult = 0.5
        ghostScore = (mult * minDist)
        #sign is -1 cause we want to substract it from the score
        sign = -1

    #calculate pos to nearest pellet
    if (len(currentPelets) >= 1):
        curPeletDist = []
        for pel in currentPelets:
            curPeletDist.append(manhattanDistance(currentPos, pel))
        #select the min
        minPeletDist = float(min(curPeletDist))
        #multiplier
        mult = 1.0 / minPeletDist * 100
        #add score
        peletScore = (mult * minPeletDist)
    else:
        peletScore = 0

    #calculate the total score
    score = foodScore * 60 / 100 + peletScore * 30 / 100 + sign * ghostScore * 30 / 100
    return score
 def getFurthestCorner(self, pacPos):
     poses = [(1, 1), (1, self.height - 2), (self.width - 2, 1), (self.width - 2, self.height - 2)]
     dist, pos = max([(manhattanDistance(p, pacPos), p) for p in poses])
     return pos
Example #35
0
    def evaluationFunction(self, currentGameState, action):
        """
        Design a better evaluation function here.

        The evaluation function takes in the current and proposed successor
        GameStates (pacman.py) and returns a number, where higher numbers are better.

        The code below extracts some useful information from the state, like the
        remaining food (newFood) and Pacman position after moving (newPos).
        newScaredTimes holds the number of moves that each ghost will remain
        scared because of Pacman having eaten a power pellet.

        Print out these variables to see what you're getting, then combine them
        to create a masterful evaluation function.
        """
        # Useful information you can extract from a GameState (pacman.py)
        successorGameState = currentGameState.generatePacmanSuccessor(action)
        newPos = successorGameState.getPacmanPosition(
        )  #This tells you the position that pacman will be in
        newFood = successorGameState.getFood()  #What does this do?
        newGhostStates = successorGameState.getGhostStates()
        newScaredTimes = [
            ghostState.scaredTimer for ghostState in newGhostStates
        ]
        newScore = successorGameState.getScore()
        newGhostPositions = successorGameState.getGhostPositions()

        print(currentGameState.getNumAgents())

        ghostDistanceArray = []
        hitghost = 0

        for pos in newGhostPositions:

            distance = util.manhattanDistance(pos, newPos)
            ghostDistanceArray.append(distance)

            if distance == 1:
                hitghost += 1

        ghostDistanceMax = min(ghostDistanceArray)

        if ghostDistanceMax == 0:
            ghostDistanceMax = 1

        foodList = newFood.asList()

        arrayofFood = [10000000]

        for food in foodList:
            foodDistance = util.manhattanDistance(food, newPos)
            arrayofFood.append(foodDistance)

        foodMin = min(arrayofFood)

        if foodMin == 0:
            foodMin = 1

        total = 1 / float(foodMin) - 1 / float(
            ghostDistanceMax) - hitghost + newScore
        return total
Example #36
0
    def observeState(self, gameState):
        """
        Resamples the set of particles using the likelihood of the noisy
        observations.

        To loop over the ghosts, use:

          for i in range(self.numGhosts):
            ...

        A correct implementation will handle two special cases:
          1) When a ghost is captured by Pacman, all particles should be updated
             so that the ghost appears in its prison cell, position
             self.getJailPosition(i) where `i` is the index of the ghost.

             As before, you can check if a ghost has been captured by Pacman by
             checking if it has a noisyDistance of None.

          2) When all particles receive 0 weight, they should be recreated from
             the prior distribution by calling initializeParticles. After all
             particles are generated randomly, any ghosts that are eaten (have
             noisyDistance of None) must be changed to the jail Position. This
             will involve changing each particle if a ghost has been eaten.

        self.getParticleWithGhostInJail is a helper method to edit a specific
        particle. Since we store particles as tuples, they must be converted to
        a list, edited, and then converted back to a tuple. This is a common
        operation when placing a ghost in jail.
        """
        pacmanPosition = gameState.getPacmanPosition()
        noisyDistances = gameState.getNoisyGhostDistances()
        if len(noisyDistances) < self.numGhosts:
            return
        emissionModels = [
            busters.getObservationDistribution(dist) for dist in noisyDistances
        ]

        "*** YOUR CODE HERE ***"
        '''
        tempParticles = util.Counter()
        if noisyDistance == None:
            self.allParticles = [self.getJailPosition()]*self.numParticles
        else:
            for particlePosition in self.allParticles:
                trueDistance = util.manhattanDistance(particlePosition,pacmanPosition)
                tempParticles[particlePosition] += emissionModel[trueDistance]

            if tempParticles.values() == [0]*len(tempParticles.values()):
                self.initializeUniformly(gameState)
            else:
                tempParticles.normalize()

                for i in range(self.numParticles):
                    self.allParticles[i] = util.sample(tempParticles)
                    '''
        tempParticles = util.Counter()

        for j, particle in enumerate(self.allParticles):
            multiDistribute = 1.0
            tempPar = particle
            for i, dis in enumerate(noisyDistances):
                if dis == None:
                    tempPar = self.getParticleWithGhostInJail(particle, i)
                    self.allParticles[j] = tempPar
                else:
                    trueDistance = util.manhattanDistance(
                        particle[i], pacmanPosition)
                    multiDistribute *= emissionModels[i][trueDistance]
            tempParticles[tempPar] += multiDistribute

        if (tempParticles.values() == [0] * len(tempParticles.values())):
            self.initializeParticles()
        else:
            tempParticles.normalize()
            for i in range(self.numParticles):
                self.allParticles[i] = util.sample(tempParticles)
Example #37
0
 def canKill(pacmanPosition, ghostPosition):
     return manhattanDistance(ghostPosition,
                              pacmanPosition) <= COLLISION_TOLERANCE
Example #38
0
def noisyDistance(pos1, pos2):
    return int(
        util.manhattanDistance(pos1, pos2) + random.choice(SONAR_NOISE_VALUES))
    def observeState(self, gameState):
        """
        Resamples the set of particles using the likelihood of the noisy observations.

        To loop over the ghosts, use:

          for i in range(self.numGhosts):
            ...

        A correct implementation will handle two special cases:
          1) When a ghost is captured by Pacman, all particles should be updated so
             that the ghost appears in its prison cell, position self.getJailPosition(i)
             where "i" is the index of the ghost.

             You can check if a ghost has been captured by Pacman by
             checking if it has a noisyDistance of None (a noisy distance
             of None will be returned if, and only if, the ghost is
             captured).

          2) When all particles receive 0 weight, they should be recreated from the
              prior distribution by calling initializeParticles. After all particles
              are generated randomly, any ghosts that are eaten (have noisyDistance of None)
              must be changed to the jail Position. This will involve changing each
              particle if a ghost has been eaten.

        ** Remember ** We store particles as tuples, but to edit a specific particle,
        it must be converted to a list, edited, and then converted back to a tuple. Since
        this is a common operation when placing a ghost in the jail for a particle, we have
        provided a helper method named self.getParticleWithGhostInJail(particle, ghostIndex)
        that performs these three operations for you.

        """
        pacmanPosition = gameState.getPacmanPosition()
        noisyDistances = gameState.getNoisyGhostDistances()
        if len(noisyDistances) < self.numGhosts: return
        emissionModels = [
            busters.getObservationDistribution(dist) for dist in noisyDistances
        ]

        "*** YOUR CODE HERE ***"

        count = 0
        possible = util.Counter()
        while count < len(self.particles):
            w = 1
            second_count = 0
            while second_count < self.numGhosts:
                if noisyDistances[second_count] is not None:
                    w *= emissionModels[second_count][util.manhattanDistance(
                        self.particles[count][second_count], pacmanPosition)]
                else:
                    self.particles[count] = self.getParticleWithGhostInJail(
                        self.particles[count], second_count)
                second_count += 1
            possible[self.particles[count]] += w
            count += 1

        if possible.totalCount() != 0:
            part_list = []
            possible.normalize()
            count = 0
            while count < self.numParticles:
                data = util.sample(possible)
                part_list.append(data)
                count += 1
            self.particles = part_list
        else:
            self.initializeParticles()
            count = 0
            while count < len(self.particles):
                second_count = 0
                while second_count < self.numGhosts:
                    if noisyDistances is None:
                        self.particles[
                            count] = self.getParticleWithGhostInJail(
                                self.particles[count], second_count)
                    second_count += 1
                count += 1
Example #40
0
 def evaluate(self, gameState, action):
     width, height = gameState.data.layout.width, gameState.data.layout.height
     features = {
         'nearestFood':
         1.0 / min(
             self.getMazeDistance(gameState.getAgentPosition(self.index), p)
             for p in self.getFood(gameState).asList()),
         'nearestPellet':
         100.0 if len(self.getCapsules(gameState)) == 0 else 1.0 / min(
             self.getMazeDistance(gameState.getAgentPosition(self.index), p)
             for p in self.getCapsules(gameState)),
         'opponent':
         (1.0 / (10 * self.powerTimer) if self.isPowered() else 1.0) *
         self.sideEval(
             gameState,
             min([
                 self.inferenceMods[i].getMostLikelyPosition()
                 for i in self.inferenceMods
             ],
                 key=lambda x: self.getMazeDistance(
                     gameState.getAgentPosition(self.index), x))) * 1.0 /
         (1 + min([
             self.getMazeDistance(
                 gameState.getAgentPosition(self.index),
                 self.inferenceMods[i].getMostLikelyPosition())
             for i in self.inferenceMods
         ])),
         'score':
         gameState.getScore(),
         'ally': (1.0 - self.sideEval(
             gameState,
             gameState.getAgentPosition(
                 [i
                  for i in self.getTeam(gameState) if i != self.index][0])))
         * 1.0 / (1 + self.getMazeDistance(
             gameState.getAgentPosition([
                 i for i in self.getTeam(gameState) if i != self.index
             ][0]), gameState.getAgentPosition(self.index))),
         'immediateOpponent': (0.0 if self.isPowered() else 1.0) *
         self.side(gameState) * (1.0 if 1.0 == util.manhattanDistance(
             min([
                 self.inferenceMods[i].getMostLikelyPosition()
                 for i in self.inferenceMods
             ],
                 key=lambda x: self.getMazeDistance(
                     gameState.getAgentPosition(self.index), x)),
             gameState.getAgentPosition(self.index)) else 0.0),
         'isPowered':
         1.0 if self.isPowered() else 0.0,
         'isDeadEnd':
         1.0 if len(gameState.getLegalActions(self.index)) <= 2 else 0.0,
         'holdFood':
         self.foodNum * (min([
             self.distancer.getDistance(
                 gameState.getAgentPosition(self.index), p)
             for p in [(width / 2, i) for i in range(1, height)
                       if not gameState.hasWall(width / 2, i)]
         ])) * self.side(gameState),
         'dropFood':
         self.foodNum * (1.0 - self.side(gameState)),
         'isStop':
         1.0 if action == Directions.STOP else 0.0
     }
     for i in self.inferenceMods:
         self.inferenceMods[i].step(gameState)
     return sum([self.weights[i] * features[i] for i in features])
Example #41
0
    def evaluationFunction(self, currentGameState, action):
        """
        Design a better evaluation function here.

        The evaluation function takes in the current and proposed successor
        GameStates (pacman.py) and returns a number, where higher numbers are better.

        The code below extracts some useful information from the state, like the
        remaining food (newFood) and Pacman position after moving (newPos).
        newScaredTimes holds the number of moves that each ghost will remain
        scared because of Pacman having eaten a power pellet.

        Print out these variables to see what you're getting, then combine them
        to create a masterful evaluation function.
        """
        # Useful information you can extract from a GameState (pacman.py)
        successorGameState = currentGameState.generatePacmanSuccessor(action)
        newPos = successorGameState.getPacmanPosition()
        newFood = successorGameState.getFood()
        newGhostStates = successorGameState.getGhostStates()
        newScaredTimes = [
            ghostState.scaredTimer for ghostState in newGhostStates
        ]

        #====Get the closest food to pacman using manhattan distance====
        our_food_list = newFood.asList()
        #Initialize the closest food manhattan distance
        first_food = True
        closest_food = 0
        #Find the closest food by iterating through the new food list
        for food in our_food_list:
            if first_food is True:
                closest_food = manhattanDistance(food, newPos)
                first_food = False
            else:
                distance_to_food = manhattanDistance(food, newPos)
                if distance_to_food < closest_food:
                    closest_food = distance_to_food
        #closest_food now contains the food closest to pacman

        #====Get the closest ghost to pacman using manhattan distance====
        first_ghost = True
        closest_ghost = 0
        #Find the closest ghost by iterating through the new ghost list
        for ghost in newGhostStates:
            if first_ghost is True:
                closest_ghost = manhattanDistance(ghost.getPosition(), newPos)
                first_ghost = False
            else:
                distance_to_ghost = manhattanDistance(ghost.getPosition(),
                                                      newPos)
                if distance_to_ghost < closest_ghost:
                    closest_ghost = distance_to_ghost
        #closest_ghost now contains the food closest to pacman

        #====Determine the score====
        #If the new position of pacman is not in the current state's food list, then we must make the score the
        #"reciprocal" (negative) of the closest food so far (as recommended)
        if newPos not in currentGameState.getFood().asList():
            score = -closest_food
        #If it is, just zero it out because we just moved on top of the new food in newPos
        else:
            score = 0

        #Check if any of the ghosts are scared because pacman has eaten a power pellet
        not_scared = True
        for scaredTimes in newScaredTimes:
            #This means there is at 1 scared ghost
            if scaredTimes != 0:
                not_scared = False
        #If none of the ghosts are scared, they can potentially kill pacman because pacman has not eaten a power pellet
        if not_scared and closest_ghost <= 1:
            #If the closest ghost is within 1 of pacman, this state is potentially doomed so return the reciprocal of the
            #largest possible number on the machine (negative infinity)
            score = -float("inf")
        return score
Example #42
0
    def checkDeath(state, agentIndex):
        agentState = state.data.agentStates[agentIndex]
        if state.isOnRedTeam(agentIndex):
            otherTeam = state.getBlueTeamIndices()
        else:
            otherTeam = state.getRedTeamIndices()
        if agentState.isPacman:
            for index in otherTeam:
                otherAgentState = state.data.agentStates[index]
                if otherAgentState.isPacman: continue
                ghostPosition = otherAgentState.getPosition()
                if ghostPosition == None: continue
                if manhattanDistance(
                        ghostPosition,
                        agentState.getPosition()) <= COLLISION_TOLERANCE:
                    # award points to the other team for killing Pacmen
                    if otherAgentState.scaredTimer <= 0:
                        AgentRules.dumpFoodFromDeath(state, agentState,
                                                     agentIndex)

                        score = KILL_POINTS
                        if state.isOnRedTeam(agentIndex):
                            score = -score
                        state.data.scoreChange += score
                        agentState.isPacman = False
                        agentState.configuration = agentState.start
                        agentState.scaredTimer = 0
                    else:
                        score = KILL_POINTS
                        if state.isOnRedTeam(agentIndex):
                            score = -score
                        state.data.scoreChange += score
                        otherAgentState.isPacman = False
                        otherAgentState.configuration = otherAgentState.start
                        otherAgentState.scaredTimer = 0
        else:  # Agent is a ghost
            for index in otherTeam:
                otherAgentState = state.data.agentStates[index]
                if not otherAgentState.isPacman: continue
                pacPos = otherAgentState.getPosition()
                if pacPos == None: continue
                if manhattanDistance(
                        pacPos,
                        agentState.getPosition()) <= COLLISION_TOLERANCE:
                    #award points to the other team for killing Pacmen
                    if agentState.scaredTimer <= 0:
                        AgentRules.dumpFoodFromDeath(state, otherAgentState,
                                                     agentIndex)

                        score = KILL_POINTS
                        if not state.isOnRedTeam(agentIndex):
                            score = -score
                        state.data.scoreChange += score
                        otherAgentState.isPacman = False
                        otherAgentState.configuration = otherAgentState.start
                        otherAgentState.scaredTimer = 0
                    else:
                        score = KILL_POINTS
                        if state.isOnRedTeam(agentIndex):
                            score = -score
                        state.data.scoreChange += score
                        agentState.isPacman = False
                        agentState.configuration = agentState.start
                        agentState.scaredTimer = 0
    def getFeatures(self, state, action, agentIndex):
        if (agentIndex == 2):
            features = util.Counter()
            ghostPos1 = state.getGhostPosition(1)
            ghostPos2 = state.getGhostPosition(2)
            pacmanPos = state.getPacmanPosition()
            ghostState2 = state.getGhostState(2)
            pacmanState = state.getPacmanState()
            walls = state.getWalls()
            scaredTimer = ghostState2.scaredTimer

            dx, dy = Actions.directionToVector(action)
            if scaredTimer > 0:
                dx /= 2
                dy /= 2

            ghost2x = ghostPos2[0]+dx
            ghost2y = ghostPos2[1]+dy
            ghostPos2 = (ghost2x, ghost2y)
            ghostDistance2 = util.manhattanDistance(pacmanPos, ghostPos2)

            # print(state)
            # print(self.shortestDistAStar(walls, pacmanPos, ghostPos2))

            features["bias"] = 1.0
            features["stepsToOtherGhost"] = util.manhattanDistance(ghostPos1, ghostPos2)  / (walls.width + walls.height)

            if scaredTimer > 0:
                features["stepsFromScaredGhostToPacman"] = ghostDistance2 /  (walls.width + walls.height)
            else:
                # minDistanceToCapsule = 999999999
                # closestCapsuleLoc = []
                # for capsuleLoc in state.getCapsules():
                    # distance = util.manhattanDistance(pacmanPos, capsuleLoc)
                    # if(distance < minDistanceToCapsule):
                        # closestCapsuleLoc =  capsuleLoc
                        # minDistanceToCapsule =  distance

                # features["minDistanceBetweenGhostPacman"] = (11 - minDistanceToCapsule) / (walls.width + walls.height)

                min_dist = ghostDistance2
                features["stepsFromGhostToPacman"] =  min_dist / (walls.width + walls.height)
                features["danger"] = 0
                if (len(state.getCapsules()) > 0 and ghostDistance2 > 0):
                    closestCapsuleLoc = []
                    distances = []
                    for capsuleLoc in state.getCapsules():
                        distance = util.manhattanDistance(pacmanPos, capsuleLoc)
                        distances.append(distance)

                    distances.sort()
                    minDistanceOfPacmanToCapsule = distances[0]
                    if (minDistanceOfPacmanToCapsule > 0):
                        if min_dist < 11:
                            features["danger"] = 1 - min_dist/11

                if min_dist > 12 :
                    features["keepwithinrange"] = 1.0
                else:
                    features["keepwithinrange"] = 0

                if ((features["danger"] == 0) and (min_dist <= 12)):
                    features["trap"] = 1 - min_dist/99
                else:
                    features["trap"] = 0

            return features
        else:
            features = util.Counter()
            ghostPos1 = state.getGhostPosition(2)
            ghostPos2 = state.getGhostPosition(1)
            pacmanPos = state.getPacmanPosition()
            ghostState2 = state.getGhostState(2)
            pacmanState = state.getPacmanState()
            walls = state.getWalls()
            scaredTimer = ghostState2.scaredTimer

            dx, dy = Actions.directionToVector(action)
            if scaredTimer > 0:
                dx /= 2
                dy /= 2

            ghost2x = ghostPos2[0]+dx
            ghost2y = ghostPos2[1]+dy
            ghostPos2 = (ghost2x, ghost2y)
            ghostDistance2 = util.manhattanDistance(pacmanPos, ghostPos2)

            # print(state)
            # print(self.shortestDistAStar(walls, pacmanPos, ghostPos2))

            features["bias"] = 1.0
            features["stepsToOtherGhost"] = util.manhattanDistance(ghostPos1, ghostPos2)  / (walls.width + walls.height)

            if scaredTimer > 0:
                features["stepsFromScaredGhostToPacman"] = ghostDistance2 /  (walls.width + walls.height)
            else:
                # minDistanceToCapsule = 999999999
                # closestCapsuleLoc = []
                # for capsuleLoc in state.getCapsules():
                    # distance = util.manhattanDistance(pacmanPos, capsuleLoc)
                    # if(distance < minDistanceToCapsule):
                        # closestCapsuleLoc =  capsuleLoc
                        # minDistanceToCapsule =  distance

                # features["minDistanceBetweenGhostPacman"] = (11 - minDistanceToCapsule) / (walls.width + walls.height)

                min_dist = ghostDistance2
                features["stepsFromGhostToPacman"] =  min_dist / (walls.width + walls.height)
                features["danger"] = 0
                if (len(state.getCapsules()) > 0 and ghostDistance2 > 0):
                    closestCapsuleLoc = []
                    distances = []
                    for capsuleLoc in state.getCapsules():
                        distance = util.manhattanDistance(pacmanPos, capsuleLoc)
                        distances.append(distance)

                    distances.sort()
                    minDistanceOfPacmanToCapsule = distances[0]
                    if (minDistanceOfPacmanToCapsule > 0):
                        if min_dist < 11:
                            features["danger"] = 1 - min_dist/11

                if min_dist > 12 :
                    features["keepwithinrange"] = 1.0
                else:
                    features["keepwithinrange"] = 0

                if ((features["danger"] == 0) and (min_dist <= 12)):
                    features["trap"] = 1 - min_dist/99
                else:
                    features["trap"] = 0

            return features
Example #44
0
def enhancedPacmanFeatures(state, action):
    """
    For each state, this function is called with each legal action.
    It should return a counter with { <feature name> : <feature value>, ... }

    python dataClassifier.py -c perceptron -d pacman -f -g ContestAgent 


    #sets 1 for the position of pacman and 0 otherwise
    for x in range(20):
        for y in range(20):
            if (x,y) == state.getPacmanPosition():
                
                features[(x,y)] = 1
            else:
                
                features[(x,y)] = 0
    """
    features = util.Counter()

    successor = state.generateSuccessor(0, action)
    agent_pos = successor.getPacmanPosition()
    ghosts = successor.getGhostPositions()
    ghost_state = successor.getGhostStates()
    capsules = successor.getCapsules()
    state_food = state.getFood()
    food = [(x, y) for x, row in enumerate(state_food)
            for y, food in enumerate(row) if food]

    nearest_ghosts = sorted(
        [util.manhattanDistance(agent_pos, i) for i in ghosts])
    features["nearest_ghost"] = nearest_ghosts[0]

    #print(ghost_state)

    #if state.data.agentStates[nearest_ghosts[0]].scaredTimer > 0:
    #    features[("ghost_scared", ghost_state)] = 1
    #else: features[("ghost_scared", ghost_state)] = 0

    #for i in xrange(min(len(nearest_ghosts), 1)):
    #features[("ghost", i)] = 5 / (0.1 + nearest_ghosts[i])

    nearest_caps = sorted(
        [util.manhattanDistance(agent_pos, i) for i in capsules])

    for i in xrange(min(len(nearest_caps), 1)):
        features[("capsule", i)] = 15 / (1 + nearest_caps[i])

    nearest_food = sorted([util.manhattanDistance(agent_pos, i) for i in food])
    for i, weight in zip(xrange(min(len(nearest_food), 5)),
                         [1.3, 0.8] + [0.9] * 3):
        features[("food", i)] = weight * nearest_food[i]

    #features["capsule count"] = len(capsules) * 10
    features["iswin"] = state.isWin()
    features["islose"] = state.isLose()
    features["score"] = state.getScore()  #* 10

    #features["pacman"]= agent_pos implemnteren werkt niet!

    return features
Example #45
0
    def observeState(self, gameState):
        """
Resamples the set of particles using the likelihood of the noisy observations.

As in elapseTime, to loop over the ghosts, use:

  for i in range(self.numGhosts):
    ...

A correct implementation will handle two special cases:
  1) When a ghost is captured by Pacman, all particles should be updated so
     that the ghost appears in its prison cell, position self.getJailPosition(i)
     where "i" is the index of the ghost.

     You can check if a ghost has been captured by Pacman by
     checking if it has a noisyDistance of None (a noisy distance
     of None will be returned if, and only if, the ghost is
     captured).

  2) When all particles receive 0 weight, they should be recreated from the
      prior distribution by calling initializeParticles. Remember to
      change ghosts' positions to jail if called for.
"""
        pacmanPosition = gameState.getPacmanPosition()
        noisyDistances = gameState.getNoisyGhostDistances()
        if len(noisyDistances) < self.numGhosts: return
        emissionModels = [
            busters.getObservationDistribution(dist) for dist in noisyDistances
        ]

        "*** YOUR CODE HERE ***"
        ## make sure yo ghosts in jail bro
        for i in range(self.numGhosts):
            if noisyDistances[i] == None:
                for j in range(self.numParticles):
                    thisGhostParticle = list(self.particles[j])
                    thisGhostParticle[i] = self.getJailPosition(i)
                    self.particles[j] = tuple(thisGhostParticle)

        ## check yo weights bro
        updatedWeights = util.Counter()
        for i in range(self.numParticles):
            # 1.0 not 1 haha I love ints and never make that mistake
            currentWeight = 1.0
            thisParticle = list(self.particles[i])
            for j in range(self.numGhosts):
                # if they are in jail
                if (noisyDistances[j] != None):
                    manDist = util.manhattanDistance(thisParticle[j],
                                                     pacmanPosition)
                    currentWeight *= emissionModels[j][manDist]
            # new weights bro! getting nice and strong I love it
            updatedWeights[tuple(thisParticle)] += currentWeight

        zeroParticleCheck = True
        for i in range(self.numParticles):
            thisParticle = self.particles[i]
            # if this one isnt zero, how can all of them be zero?
            if (updatedWeights[thisParticle] > 0):
                zeroParticleCheck = False
                break

        # if they all zero take a step back and restart
        if zeroParticleCheck:
            self.initializeParticles()

        # otherwise keep chuggin
        else:
            for i in range(self.numParticles):
                self.particles[i] = util.sampleFromCounter(updatedWeights)
Example #46
0
def betterEvaluationFunction(currentGameState):
    """
      Your extreme ghost-hunting, pellet-nabbing, food-gobbling, unstoppable
      evaluation function (question 5).

      DESCRIPTION: As recommended, a linear combination of crucial pacman states was taken
      in order to determine our final score.  Based on what was learned in question 1, I found the
      closest food, and closest ghosts to pacman to determine score.  If the game is over, return
      a corresponding infinity depending on what ended the game.  Number of food was given a weighting of 70 by default.
      We also add the closest food to the score.  For the closest ghost, since it is very significant, we will multiply
      it by itself.  We do this to quickly amplify the danger of a close ghost.
      If a ghost is within two of pacman, we need to eat a power pellet ASAP to kill it so we give a
      weighting of 50 when a ghost is near, else just a weight of 10.  Finally, we return
      the negative reciprocal as we did in question 1.  Note: we subtract the current score because it is score
      that has already been counted in previous turns.
    """
    #First, check if the game is over by win or loss. If so, return the appropriate infinity
    #Negative infinity for an instant lose state
    # First, check if the game is over by win or loss. If so, return the appropriate infinity
    # Negative infinity for an instant lose state
    if currentGameState.isLose():
        return -float("inf")
    # Positive infinity for a instant win state
    elif currentGameState.isWin():
        return float("inf")

    # Based on question 1
    # Current pacman position
    pacman_pos = currentGameState.getPacmanPosition()
    # Current food list
    food_list = currentGameState.getFood()
    # Current ghost states
    ghost_states = currentGameState.getGhostStates()
    # Current scared times
    scared_times = [ghostState.scaredTimer for ghostState in ghost_states]

    #Our final score
    final_score = 0

    our_food_list = food_list.asList()
    # Initialize the closest food manhattan distance
    first_food = True
    closest_food = 0
    # Find the closest food by iterating through the new food list
    for food in our_food_list:
        if first_food is True:
            closest_food = manhattanDistance(food, pacman_pos)
            first_food = False
        else:
            distance_to_food = manhattanDistance(food, pacman_pos)
            if distance_to_food < closest_food:
                closest_food = distance_to_food
                # closest_food now contains the food closest to pacman

    # ====Get the closest ghost to pacman using manhattan distance====
    first_ghost = True
    closest_ghost = 0
    # Find the closest ghost by iterating through the new ghost list
    for ghost in ghost_states:
        if first_ghost is True:
            closest_ghost = manhattanDistance(ghost.getPosition(), pacman_pos)
            first_ghost = False
        else:
            distance_to_ghost = manhattanDistance(ghost.getPosition(),
                                                  pacman_pos)
            if distance_to_ghost < closest_ghost:
                closest_ghost = distance_to_ghost
    # Check if any of the ghosts are scared because pacman has eaten a power pellet
    not_scared = True
    for scaredTimes in scared_times:
        # This means there is at 1 scared ghost
        if scaredTimes != 0:
            not_scared = False
            # If none of the ghosts are scared, they can potentially kill pacman because pacman has not eaten a power pellet
    # If there is a scared ghost within 2 of pacman, we need to eat a power pellet ASAP
    if not_scared and closest_ghost <= 2:
        # If the closest ghost is within 1 of pacman, this state is potentially doomed so return the reciprocal of the
        # largest possible number on the machine (negative infinity)
        # Add the number of power pellets according to a custom weight
        power_pellet_weight = 50
    # If not, not much weight should be put on power pellets
    else:
        # Add the number of power pellets according to a custom weight
        power_pellet_weight = 10

    #Linear combination of all our values
    final_score += closest_food + \
                   closest_ghost ** 2 + \
                   70 * currentGameState.getNumFood() + \
                   power_pellet_weight * len(currentGameState.getCapsules()) - \
                   currentGameState.getScore()
    # Return the negative reciprocol of the linear combination of all of our score determiners like in question 1
    return -final_score
Example #47
0
    def evaluationFunction(self, currentGameState, action):
        """
        Design a better evaluation function here.

        The evaluation function takes in the current and proposed successor
        GameStates (pacman.py) and returns a number, where higher numbers are better.

        The code below extracts some useful information from the state, like the
        remaining food (newFood) and Pacman position after moving (newPos).
        newScaredTimes holds the number of moves that each ghost will remain
        scared because of Pacman having eaten a power pellet.

        Print out these variables to see what you're getting, then combine them
        to create a masterful evaluation function.
        """
        # Useful information you can extract from a GameState (pacman.py)
        Pos = currentGameState.getPacmanPosition()
        successorGameState = currentGameState.generatePacmanSuccessor(action)
        newPos = successorGameState.getPacmanPosition()
        newFood = successorGameState.getFood()
        newGhostStates = successorGameState.getGhostStates()
        newScaredTimes = [
            ghostState.scaredTimer for ghostState in newGhostStates
        ]
        walls = successorGameState.getWalls()
        m, n = walls.height, walls.width

        "*** YOUR CODE HERE ***"
        foodList = currentGameState.getFood().asList()
        alpha = (m - 2) * (n - 2)
        value = 0.0
        if (action == 'Stop'):
            value -= 1.1
        nearestFood = (-1, -1)
        foodDis = m * n
        for food in foodList:
            tmpdis = manhattanDistance(Pos, food)
            if (tmpdis < foodDis or nearestFood == (-1, -1)):
                foodDis = tmpdis
                nearestFood = food

        #print "nearest food: ", nearestFood
        #if nearestFood != (-1,-1):
        dis = manhattanDistance(newPos, nearestFood)
        #print "next distance: ", dis

        for ghost in newGhostStates:
            ghostDis = manhattanDistance(newPos, ghost.getPosition())
            scared = ghost.scaredTimer
            if scared == 0:
                if ghostDis <= 3:
                    value += -(4 - ghostDis)**2
                else:
                    if currentGameState.hasFood(newPos[0], newPos[1]):
                        value += 1.5
            else:
                value += scared / (ghostDis + 1)

        value = value - dis
        #print"value", value
        return value
Example #48
0
    def observeState(self, gameState):
        """
        Resamples the set of particles using the likelihood of the noisy
        observations.

        To loop over the ghosts, use:

          for i in range(self.numGhosts):
            ...

        A correct implementation will handle two special cases:
          1) When a ghost is captured by Pacman, all particles should be updated
             so that the ghost appears in its prison cell, position
             self.getJailPosition(i) where `i` is the index of the ghost.

             As before, you can check if a ghost has been captured by Pacman by
             checking if it has a noisyDistance of None.

          2) When all particles receive 0 weight, they should be recreated from
             the prior distribution by calling initializeParticles. After all
             particles are generated randomly, any ghosts that are eaten (have
             noisyDistance of None) must be changed to the jail Position. This
             will involve changing each particle if a ghost has been eaten.

        self.getParticleWithGhostInJail is a helper method to edit a specific
        particle. Since we store particles as tuples, they must be converted to
        a list, edited, and then converted back to a tuple. This is a common
        operation when placing a ghost in jail.
        """
        pacmanPosition = gameState.getPacmanPosition()
        noisyDistances = gameState.getNoisyGhostDistances()
        if len(noisyDistances) < self.numGhosts:
            return
        emissionModels = [
            busters.getObservationDistribution(dist) for dist in noisyDistances
        ]
        beliefs = self.getBeliefDistribution()

        possibles = []
        ghostInJail = []
        ghostJailPositions = []
        for i in range(self.numGhosts):
            allPossible = util.Counter()
            if noisyDistances[i] is None:
                jailPos = self.getJailPosition(i)
                allPossible[jailPos] = 1.0
                ghostInJail.append(True)
                ghostJailPositions.append(jailPos)
            else:
                ghostInJail.append(False)
                #P(x_t|e_1:t) = P(e_t|x_t) * sum_x_t-1 (P(x_t|x_t-1) * P(x_t-1,e_t:t-1))
                for p in self.legalPositions:
                    trueDistance = util.manhattanDistance(p, pacmanPosition)
                    cond_prob_ev_t = emissionModels[i][
                        trueDistance]  #p(e_t|x_t)
                    # assume ghost is standing still?
                    allPossible[p] = cond_prob_ev_t * self.computeMarginal(
                        beliefs, i, p)

            allPossible.normalize()
            possibles.append(allPossible)

        # First handle the case where all particles get zero weight

        currentPositions = list(
            set(self.legalPositions).union(ghostJailPositions))
        permutations = list(
            itertools.product(currentPositions, repeat=self.numGhosts))
        #probs = [self.computeJoint(p, possibles) for p in permutations]
        #print "probs = ", probs
        nonZero = [
            p for p in permutations if self.computeJoint(p, possibles) > 0.0
        ]
        if len(nonZero) == 0:
            print "Ru roh, need to re-initialize."
            #print "Marginals=", possibles
            self.initializeParticles()
            # Now we need to update the marginals of any ghosts that are in jail.
            for i in range(self.numGhosts):
                if ghostInJail[i]:
                    print "ghost ", i, " is in jail - adjusting."
                    probs = [(p, self.computeJoint(p, possibles))
                             for p in permutations]
                    print "Marginal=", possibles
                    print "Joint=", probs
                    for j in range(self.numParticles):
                        self.particles[j] = self.getParticleWithGhostInJail(
                            self.particles[j], i)
        else:
            weights = [self.computeJoint(p, possibles) for p in permutations]
            positions = [p for p in permutations]
            self.particles = util.nSample(weights, positions,
                                          self.numParticles)
Example #49
0
    def observeState(self, gameState):
        """
        Resamples the set of particles using the likelihood of the noisy
        observations.

        To loop over the ghosts, use:

          for i in range(self.numGhosts):
            ...

        A correct implementation will handle two special cases:
          1) When a ghost is captured by Pacman, all particles should be updated
             so that the ghost appears in its prison cell, position
             self.getJailPosition(i) where `i` is the index of the ghost.

             As before, you can check if a ghost has been captured by Pacman by
             checking if it has a noisyDistance of None.

          2) When all particles receive 0 weight, they should be recreated from
             the prior distribution by calling initializeParticles. After all
             particles are generated randomly, any ghosts that are eaten (have
             noisyDistance of None) must be changed to the jail Position. This
             will involve changing each particle if a ghost has been eaten.

        self.getParticleWithGhostInJail is a helper method to edit a specific
        particle. Since we store particles as tuples, they must be converted to
        a list, edited, and then converted back to a tuple. This is a common
        operation when placing a ghost in jail.
        """
        pacmanPosition = gameState.getPacmanPosition()
        noisyDistances = gameState.getNoisyGhostDistances()
        if len(noisyDistances) < self.numGhosts:
            return
        emissionModels = [
            busters.getObservationDistribution(dist) for dist in noisyDistances
        ]
        currentBeliefs = util.Counter()  #temp list of beliefs (weights)
        "*** YOUR CODE HERE ***"
        #Local Declarations
        count = 0
        count2 = 0
        count3 = 0
        finalTemp = 1.0
        sad = 0
        total = 0
        #loop through particles
        while (count < len(self.particleList)):
            temp = 1.0
            particle = self.particleList[count]  #get particle
            #loop to go through
            for i in range(self.numGhosts):
                emissionModel = emissionModels[i]  #emission array
                noisyDistance = noisyDistances[i]  #noisy array
                #if not noisy then compute the weights, also called "currentBeliefs"
                if not (noisyDistance == None):
                    trueDistance = util.manhattanDistance(
                        particle[i], pacmanPosition)
                    temp *= emissionModel[trueDistance]
            currentBeliefs[
                particle] += temp  #update currentBeliefs with the weights
            total += temp
            count += 1  #increment loop
        #if sum of weights == 0 then handle case two, where weights could be 0
        if (total == 0):
            self.handleCaseTwoJP(currentBeliefs, gameState, noisyDistances)
        else:
            #loop through particles and resample them
            count = 0
            while (count < len(self.particleList)):
                self.particleList[count] = util.sample(
                    currentBeliefs
                )  #set particle to jail position and return it
                count += 1  #increment loop
        #go through each ghosts in range, check for noisyDistance truth, then place jail position into particles
        for i in range(self.numGhosts):
            if (noisyDistances[i] == None):
                count = 0
                #loop through the particle list and update the particle with ghosts in their jail position(s)
                while (count < len(self.particleList)):
                    self.particleList[count] = self.getParticleWithGhostInJail(
                        self.particleList[count],
                        i)  #set particle to jail position and return it
                    count += 1  #increment loop
    def evaluationFunction(self, currentGameState, action):
        """
        Design a better evaluation function here.

        The evaluation function takes in the current and proposed successor
        GameStates (pacman.py) and returns a number, where higher numbers are better.

        The code below extracts some useful information from the state, like the
        remaining food (newFood) and Pacman position after moving (newPos).
        newScaredTimes holds the number of moves that each ghost will remain
        scared because of Pacman having eaten a power pellet.

        Print out these variables to see what you're getting, then combine them
        to create a masterful evaluation function.
        """
        # Useful information you can extract from a GameState (pacman.py)
        successorGameState = currentGameState.generatePacmanSuccessor(action)
        newPos = successorGameState.getPacmanPosition()
        newFood = successorGameState.getFood()
        currentCapsules = currentGameState.getCapsules()
        newCapsules = successorGameState.getCapsules()
        newCapsuleDists = [manhattanDistance(capsule, newPos) for capsule in newCapsules]
        newFoodDists = [manhattanDistance(food, newPos) for food in newFood.asList()]
        currentGhostStates = currentGameState.getGhostStates()
        newGhostStates = successorGameState.getGhostStates()
        newGhostDists = [manhattanDistance(ghostState.getPosition(), newPos) for ghostState in newGhostStates]
        newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]
        "*** YOUR CODE HERE ***"

        # find the closest ghost
        closestGhost = min(newGhostDists)
        # if we've eaten a power pellet go after it
        if newScaredTimes[0] != 0:
            if closestGhost != 0:
                ghostTerm = 1./closestGhost
            else:
                ghostTerm = 1./0.0001
        # otherwise don't worry about it unless it's within
        # 4 steps of us, then take evasive action
        else:
            ghostTerm = min(4, closestGhost)

        # try to go after power pellets
        # add in a big bonuse for eating one
        if len(currentCapsules) > len(newCapsules):
            capsuleTerm = 50
        elif len(newCapsuleDists):
            closestCapsule = min(newCapsuleDists)
            if closestCapsule > 1:
                capsuleTerm = 1./closestCapsule
            else:
                capsuleTerm = 20
        else:
            capsuleTerm = 20

        # try to get closer to food
        if len(newFoodDists):
            foodTerm = 1./(sum(newFoodDists)/len(newFoodDists))
        else:
            foodTerm = 0

        return 1.5*successorGameState.getScore() + ghostTerm + foodTerm + capsuleTerm
Example #51
0
def cornersHeuristic(state, problem):
    """
    Q2.2
    A heuristic for the CornersProblem that you defined.

      state:   The current search state
               (a data structure you chose in your search problem)

      problem: The CornersProblem instance for this layout.

    This function should always return a number that is a lower bound on the
    shortest path from the state to a goal of the problem; i.e.  it should be
    admissible (as well as consistent).
    """
    corners = problem.corners  # These are the corner coordinates
    walls = problem.walls  # These are the walls of the maze, as a Grid (game.py)

    "*** YOUR CODE HERE ***"

    startPos = state[0]
    cornersState = state[1]

    top, right = walls.height - 2, walls.width - 2  # top and right bounds - storing these values to speed up runtime
    exploredCorner = []

    # print ("corners[0]: ", corners[0])
    # print ("corners[1]: ", corners[1])
    # print ("corners[2]: ", corners[2])
    # print ("corners[3]: ", corners[3])

    # go through each item in corners to ensure if False, that it's appended to exploredCorner for use in manhattan distance heuristic
    for item in corners:
        print("items: ", item)
        if item == (right, 1):
            if cornersState[0] == False:
                exploredCorner.append(item)
        elif item == (right, top):
            if cornersState[1] == False:
                exploredCorner.append(item)
        elif item == (1, top):
            if cornersState[2] == False:
                exploredCorner.append(item)
        elif item == (1, 1):
            if cornersState[3] == False:
                exploredCorner.append(item)

    # Keep a list of Unvisited Corners - exploredCorner
    # Return the Manhattan distance of corner that's
    # closest to you by doing a min() over all the Manhattan distances.

    totalCost = 0
    currPosition = startPos

    # check while exploredCorner still had corners to calculate manhattan distance to
    while len(exploredCorner) > 0:
        manDistArr = [
        ]  # list to keep track of manhattan distance from currPosition to corner
        i = 0
        for items in range(len(exploredCorner)):
            corner = exploredCorner[items]
            i += 1
            manDistance = util.manhattanDistance(currPosition, corner)
            manDistArr.append(manDistance)
        minManDistance = min(
            manDistArr
        )  # taking the min of manhattan distance list to find closest corner to currPosition
        totalCost += minManDistance

        # grab index of minimum in manhattan distance array so that we can
        # remove the corner that corresponds to that distance from our list
        # of explored corners from above

        minManDistancePos = manDistArr.index(minManDistance)
        currPosition = exploredCorner[minManDistancePos]
        del exploredCorner[
            minManDistancePos]  # remove the corner from array in order to ensure that while loop ends

    return totalCost
Example #52
0
def foodHeuristic(state, problem):
    """
    Your heuristic for the FoodSearchProblem goes here.

    This heuristic must be consistent to ensure correctness.  First, try to come up
    with an admissible heuristic; almost all admissible heuristics will be consistent
    as well.

    If using A* ever finds a solution that is worse uniform cost search finds,
    your heuristic is *not* consistent, and probably not admissible!  On the other hand,
    inadmissible or inconsistent heuristics may find optimal solutions, so be careful.

    The state is a tuple ( pacmanPosition, foodGrid ) where foodGrid is a
    Grid (see game.py) of either True or False. You can call foodGrid.asList()
    to get a list of food coordinates instead.

    If you want access to info like walls, capsules, etc., you can query the problem.
    For example, problem.walls gives you a Grid of where the walls are.

    If you want to *store* information to be reused in other calls to the heuristic,
    there is a dictionary called problem.heuristicInfo that you can use. For example,
    if you only want to count the walls once and store that value, try:
      problem.heuristicInfo['wallCount'] = problem.walls.count()
    Subsequent calls to this heuristic can access problem.heuristicInfo['wallCount']
    """
    position, foodGrid = state

    "*** YOUR CODE HERE ***"
    if (problem.isGoalState(state)):
        return 0
    verticesINMST = set()
    verticesNOTMST = set()

    for i, item in enumerate(foodGrid):
        for j, foodItem in enumerate(item):
            if (foodItem):
                verticesNOTMST.add((i, j))
    closest_dist = min(
        [util.manhattanDistance(position, item) for item in verticesNOTMST])

    # verticesNOTMST.add(position)
    edges = util.PriorityQueue()

    cost = 0
    # edges.push((verticesNOTMST[i], verticesNOTMST[j]), util.manhattanDistance(verticesNOTMST[i], verticesNOTMST[j]))
    poppedEdge = None
    inV, outV = 0, 0
    spanCost = closest_dist
    spanEdges = []

    currentVert = verticesNOTMST.pop()
    verticesINMST.add(currentVert)

    while len(verticesNOTMST) != 0:
        for vert in verticesNOTMST:
            cost = util.manhattanDistance(currentVert, vert)
            edges.push(((currentVert, vert), cost), cost)
        while (True):
            poppedEdge, cost = edges.pop()
            if (poppedEdge[1] in verticesNOTMST):
                inV, outV = poppedEdge
                break
        spanCost += cost
        verticesNOTMST.remove(outV)
        verticesINMST.add(outV)
        spanEdges.append((poppedEdge, cost))
        currentVert = outV
    # print "pos:", position, " h:", spanCost
    return spanCost
Example #53
0
    def evaluationFunction(self, currentGameState, action):
        """
        Design a better evaluation function here.
        The evaluation function takes in the current and proposed successor
        GameStates (pacman.py) and returns a number, where higher numbers are better.
        The code below extracts some useful information from the state, like the
        remaining food (newFood) and Pacman position after moving (newPos).
        newScaredTimes holds the number of moves that each ghost will remain
        scared because of Pacman having eaten a power pellet.
        Print out these variables to see what you're getting, then combine them
        to create a masterful evaluation function.
        """
        # Useful information you can extract from a GameState (pacman.py)
        successorGameState = currentGameState.generatePacmanSuccessor(action)
        newPos = successorGameState.getPacmanPosition()
        newFood = successorGameState.getFood()
        newGhostStates = successorGameState.getGhostStates()
        newScaredTimes = [
            ghostState.scaredTimer for ghostState in newGhostStates
        ]

        "*** YOUR CODE HERE ***"
        #Local Declarations
        newWalls = successorGameState.getWalls()
        # foodList = list()
        foodDist = 0.0
        foodCoord = (0, 0)
        ghostPositions = successorGameState.getGhostPositions()
        ghostDist = 0.0
        ghostCoord = (0, 0)
        dom = 0
        rng = 0
        resultScore = 0
        targetDistance = 0
        oldDistance = 999999

        #Game win/lose evaluation
        if (successorGameState.isLose()):
            return -999999
        if (successorGameState.isWin()):
            return 999999

        first = False

        foodCount = 0

        for i in range(0, newFood.width):
            for j in range(0, newFood.height):
                if newFood[i][j]:
                    foodCount += 1

        #loop through food list to find lowest min value (closest to food by pacman)
        for i in range(0, newFood.width):
            for j in range(0, newFood.height):
                if not (newWalls[i][j]):

                    if not first:
                        temp1 = util.manhattanDistance(newPos, (i, j))
                        # print ("Food_Man_Dist: ", temp1)
                        if temp1 == 1:
                            first = True
                            foodDist -= 1000000

                    #foodDist += util.manhattanDistance(newPos, (i, j))
                    if util.manhattanDistance(newPos, (i, j)) <= 100:
                        foodDist += 1000000 - util.manhattanDistance(
                            newPos, (i, j)) * 10000
                    if newFood[i][j]:
                        #update to smallest variable if true
                        if (foodDist < oldDistance):
                            oldDistance = foodDist
                            foodDist = 0

        foodDist = oldDistance
        # print "FoodDist: ", foodDist

        for i in range(0, len(ghostPositions)):
            temp2 = util.manhattanDistance(newPos, ghostPositions[i])

            if (temp2 <= 1):
                ghostDist -= 999999
            if (temp2 > 1 and temp2 < 8):
                ghostDist -= temp2 + 10000
            ghostDist -= temp2 + 100
            #update to smallest variable if true
            if (ghostDist <= oldDistance):
                oldDistance = ghostDist
                ghostDist = 0

        ghostDist = oldDistance

        resultScore += (ghostDist / foodDist) + successorGameState.getScore()
        return resultScore
Example #54
0
    def observeState(self, gameState):
        """
        Resamples the set of particles using the likelihood of the noisy observations.
        To loop over the ghosts, use:
          for i in range(self.numGhosts):
            ...
        A correct implementation will handle two special cases:
          1) When a ghost is captured by Pacman, all particles should be updated so
             that the ghost appears in its prison cell, position self.getJailPosition(i)
             where "i" is the index of the ghost.
             You can check if a ghost has been captured by Pacman by
             checking if it has a noisyDistance of None (a noisy distance
             of None will be returned if, and only if, the ghost is
             captured).
          2) When all particles receive 0 weight, they should be recreated from the
              prior distribution by calling initializeParticles. After all particles
              are generated randomly, any ghosts that are eaten (have noisyDistance of 0)
              must be changed to the jail Position. This will involve changing each
              particle if a ghost has been eaten.
        ** Remember ** We store particles as tuples, but to edit a specific particle,
        it must be converted to a list, edited, and then converted back to a tuple. Since
        this is a common operation when placing a ghost in the jail for a particle, we have
        provided a helper method named self.getParticleWithGhostInJail(particle, ghostIndex)
        that performs these three operations for you.
        """
        pacmanPosition = gameState.getPacmanPosition()
        noisyDistances = gameState.getNoisyGhostDistances()
        if len(noisyDistances) < self.numGhosts: return
        emissionModels = [
            busters.getObservationDistribution(dist) for dist in noisyDistances
        ]

        # find the indices of ghosts in jail
        injail = []
        for i in range(self.numGhosts):
            if noisyDistances[i] == None:
                injail.append(i)

        tempCounter = util.Counter()
        #weight every particle
        for p in self.particles:
            #weight a specific particle

            # fix the particle to put the ghosts in jail
            for ghostIndex in injail:
                x = list(p)
                x[ghostIndex] = self.getJailPosition(ghostIndex)
                p = tuple(x)

            #create a probability variable for this particle
            prob = 1
            # check the truedistance of a particle ghost with its respective
            # emission model
            for i in range(self.numGhosts):
                # we know that our ghost is in jail, so there's no probability factor
                if i not in injail:
                    trueDistance = util.manhattanDistance(p[i], pacmanPosition)
                    prob = prob * emissionModels[i][trueDistance]

            # add this probability to the overall particle table
            tempCounter[p] += prob

        # assign beliefs to this counter
        self.beliefs = tempCounter

        # resample
        if tempCounter.totalCount() == 0:
            self.initializeParticles()
        else:
            self.beliefs.normalize()
            for i in range(len(self.particles)):
                newPos = util.sample(self.beliefs)
                self.particles[i] = newPos
Example #55
0
    def uctSimulation(self):
        # simulate the moves from the current game state
        # and updates self.plays and self.wins
        stateCopy = self.states[:]
        state = stateCopy[-1]
        statesPath = [state]

        # get the ghost and invaders the agent can see at the current game state
        enemies = [state.getAgentState(i) for i in self.enemies if state.getAgentState(i).scaredTimer < 6]
        ghosts = [enemy for enemy in enemies if enemy.getPosition() and not enemy.isPacman]
        invaders = [enemy for enemy in enemies if enemy.isPacman]

        c, d = state.getAgentState(self.index).getPosition()
        currentScore = state.getScore()

        expand = True
        for i in xrange(1, self.maxMoves + 1):
            state = stateCopy[-1]
            # make i evaluates lazily
            actions = state.getLegalActions(self.index)
            actions.remove(Directions.STOP)

            # Bail out early if there is no real choice to be made.
            if not actions:
                return

            moveStates = [(action, state.generateSuccessor(self.index, action)) for action in actions]

            # check if all the results in the actions are in the plays dictionary
            # if they are, use UBT1 to make choice
            if all(self.plays.get(S.getAgentState(self.index).getPosition()) for a, S in moveStates):

                # the number of times state has been visited.
                if self.plays[state.getAgentState(self.index).getPosition()] == 0.0:
                    logTotal = 0.5

                else:
                    logTotal = float(
                        2.0 * log(self.plays[state.getAgentState(self.index).getPosition()]))

                value, move, nstate = max(
                    ((float(self.wins[S.getAgentState(self.index).getPosition()]) / float(
                        self.plays[S.getAgentState(self.index).getPosition()])) +
                     2 * self.C * sqrt(
                        logTotal / float(self.plays[S.getAgentState(self.index).getPosition()])), a, S)
                    for a, S in moveStates
                )
            else:
                # if not, make a random choice
                move, nstate = choice(moveStates)

            stateCopy.append(nstate)
            statesPath.append(nstate)

            if expand and nstate.getAgentState(self.index).getPosition() not in self.plays:
                # expand the tree
                expand = False
                self.plays[nstate.getAgentState(self.index).getPosition()] = 0.0
                self.wins[nstate.getAgentState(self.index).getPosition()] = 0.0

            '''
      if len(invaders) != 0:
          # if see a invader and ate it, win +1
          ate = False
          for a in invaders:
              if nstate.getAgentState(self.index).getPosition() == a.getPosition():
                  ate = True
                  break
          if ate:
              # record number of wins
              for s in statesPath:
                  if s.getAgentState(self.index).getPosition() not in self.plays:
                      continue
                  self.wins[s.getAgentState(self.index).getPosition()] += 1.0
                  # print self.index, "EAT GHOST +1"
              break
      '''

            x, y = nstate.getAgentState(self.index).getPosition()

            if len(ghosts) > 0:
                currentDistanceToGhost, a = min([(self.getMazeDistance((c, d), g.getPosition()), g) for g in ghosts])
                if util.manhattanDistance((c, d), a.getPosition()) < 6:
                    nextDistanceToGhost = min((self.getMazeDistance((x, y), g.getPosition()) for g in ghosts))

                    if nextDistanceToGhost < currentDistanceToGhost:
                        break

                    if nextDistanceToGhost - currentDistanceToGhost > 3 and abs(nstate.getScore() - currentScore) > 0:
                        # record number of wins
                        for s in statesPath:
                            if s.getAgentState(self.index).getPosition() not in self.plays:
                                continue
                            self.wins[s.getAgentState(self.index).getPosition()] += 1.0
                        break

                    if nextDistanceToGhost - currentDistanceToGhost > 4:
                        # record number of wins
                        for s in statesPath:
                            if s.getAgentState(self.index).getPosition() not in self.plays:
                                continue
                            self.wins[s.getAgentState(self.index).getPosition()] += 0.7
                        break

            if len(self.capsule) != 0:
                distanceToCapsule, cap = min([(self.getMazeDistance((x, y), cap), cap) for cap in self.capsule])

                if nstate.getAgentState(self.index).getPosition() == cap:
                    # record number of wins
                    for s in statesPath:
                        if s.getAgentState(self.index).getPosition() not in self.plays:
                            continue
                        self.wins[s.getAgentState(self.index).getPosition()] += 0.002
                    break

            if abs(nstate.getScore() - currentScore) > 3:
                # record number of wins
                for s in statesPath:
                    if s.getAgentState(self.index).getPosition() not in self.plays:
                        continue
                    self.wins[s.getAgentState(self.index).getPosition()] += 0.4
                break

        for s in statesPath:
            # record number of plays
            if s.getAgentState(self.index).getPosition() not in self.plays:
                continue
            self.plays[s.getAgentState(self.index).getPosition()] += 1.0
Example #56
0
def positionLogicPlan(problem):
    """
    Given an instance of a PositionSearchProblem, return a list of actions that lead to the goal.
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    "*** YOUR CODE HERE ***"
    startState = problem.getStartState()
    goalState = problem.getGoalState()
    Directions = ['North', 'South', 'East', 'West']
    width = problem.getWidth()
    height = problem.getHeight()

    allStates = []
    for x in xrange(width + 1):
        for y in xrange(height + 1):
            if not problem.isWall((x, y)):
                allStates.append((x, y))

    for count in xrange(util.manhattanDistance(startState, goalState), 51):
        cnfList = []

        for time in xrange(count + 1):
            for state in allStates:
                actions = problem.actions(state)
                for action in actions:
                    nextState = problem.result(state, action)[0]
                    # state + action > new state
                    expr_and = logic.PropSymbolExpr(
                        'P', state[0], state[1], time) & logic.PropSymbolExpr(
                            action, time)
                    expression = expr_and >> logic.PropSymbolExpr(
                        'P', nextState[0], nextState[1], time + 1)
                    cnfList.append(logic.to_cnf(expression))

        # not in two places at once
        for time in xrange(count + 1):
            cnfList.append(
                exactlyOne([
                    logic.PropSymbolExpr('P', state[0], state[1], time)
                    for state in allStates
                ]))

        # must make one move each turn
        for time in xrange(count):
            cnfList.append(
                exactlyOne([
                    logic.PropSymbolExpr(action, time) for action in Directions
                ]))

        # no going back on path
        for state in allStates:
            cnfList.append(
                atMostOne([
                    logic.PropSymbolExpr('P', state[0], state[1], time)
                    for time in xrange(count + 1)
                ]))

        # start at startState
        cnfList.append(
            logic.PropSymbolExpr('P', startState[0], startState[1], 0))

        # goal state
        cnfList.append(
            logic.PropSymbolExpr('P', goalState[0], goalState[1], count))

        # no illegal moves
        for state in allStates:
            for action in list(set(Directions) - set(problem.actions(state))):
                for time in xrange(count + 1):
                    # state > not action
                    cnfList.append(
                        logic.to_cnf(
                            logic.PropSymbolExpr('P', state[0], state[1], time)
                            >> ~logic.PropSymbolExpr(action, time)))

        model = logic.pycoSAT(cnfList)

        if model:
            path = extractActionSequence(model, Directions)
            return path
def getNoisyDistance(pos1, pos2):
    if pos2[1] == 1: return None
    distance = util.manhattanDistance(pos1, pos2)
    # return max(0, distance + util.sample(SONAR_NOISE_PROBS, SONAR_NOISE_VALUES))
    return distance
Example #58
0
def betterEvaluationFunction(currentGameState):
    """
      Your extreme ghost-hunting, pellet-nabbing, food-gobbling, unstoppable
      evaluation function (question 5).
      DESCRIPTION: For all successors of the given state:
                   PacMan scans the field for food while evaluating how far the ghost is from it.
                   It places heavy emphasis on food that is near it, and heavy emphasis when the ghost is near the agent.
                   The distance modifier of the ghost is then divided by the food distance to influence pacman's state choice.
                   return average result per successor state. The dist to the ghost becomes irrelevant if the ghost is scared so any choice is good.
                   We also want to avoid stopping in the direction needlessly and try urge pacman to try a different path.
    """
    "*** YOUR CODE HERE ***"
    #Local Declarations
    actionList = currentGameState.getLegalActions(0)
    resultList = list()
    count = 0
    avgResult = 0.0

    #Game win/lose evaluation
    if (currentGameState.isLose()):
        return -9999999
    if (currentGameState.isWin()):
        return 9999999

    for action in actionList:
        count = count + 1
        successorGameState = currentGameState.generatePacmanSuccessor(action)
        newPos = successorGameState.getPacmanPosition()
        newFood = successorGameState.getFood()
        newGhostStates = successorGameState.getGhostStates()
        newScaredTimes = [
            ghostState.scaredTimer for ghostState in newGhostStates
        ]
        newWalls = successorGameState.getWalls()
        foodDist = 0.0
        ghostPositions = successorGameState.getGhostPositions()
        ghostDist = 0.0
        dom = 0
        rng = 0
        resultScore = 0
        oldDistance = 9999999
        oldFoodDist = 9999999
        first = False
        foodCount = 0

        #Get food left on the grid?
        for i in range(0, newFood.width):
            for j in range(0, newFood.height):
                if newFood[i][j]:
                    foodCount = foodCount + 1

        #loop through food list to find lowest min value (closest to food by pacman)
        for i in range(0, newFood.width):
            for j in range(0, newFood.height):
                #check if wall is there or not
                if not (newWalls[i][j]):
                    if not first:
                        foodDistTemp = util.manhattanDistance(newPos, (i, j))
                        if foodDistTemp <= 1:
                            first = True
                            foodDist += 1000
                    if util.manhattanDistance(newPos, (i, j)) <= 100:
                        foodDist += 1000 - util.manhattanDistance(
                            newPos, (i, j)) * 10
                    if newFood[i][j]:
                        #update to smallest variable if true (closest to food)
                        if (foodDist < oldDistance):
                            oldDistance = foodDist
        foodDist = oldDistance

        #Get ghost position and evaluate the distance from ghost
        for i in range(0, len(ghostPositions)):
            ghostDistTemp = util.manhattanDistance(newPos, ghostPositions[i])
            #different positions evaluate to different output choices for pacman
            if (ghostDistTemp <= 1):
                ghostDist -= 1000
            elif (ghostDistTemp > 1 and ghostDistTemp < 9):
                ghostDist -= ghostDistTemp + 10
            else:
                ghostDist = ghostDist * 2.25
            ghostDist -= ghostDistTemp
            #update to smallest variable if true
            if (ghostDist <= oldDistance):
                oldDistance = ghostDist
        ghostDist = abs(oldDistance)

        #consider Stop condition, bad if pacman stops, must keep moving!
        if action == Directions.STOP:
            foodDist = foodDist + 1
            ghostDist = ghostDist + 2

        #consider scared condition
        if newScaredTimes < 5:
            ghostDist = 1
        else:
            ghostDist = ghostDist + 2
        #get the result score and append it to the list
        resultScore += (ghostDist / foodDist) + successorGameState.getScore()
        resultList.append(resultScore)

    #avg the results and return the value
    if len(resultList) != 0:
        avgResult = sum(resultList) / len(resultList)
    return avgResult
    util.raiseNotDefined()
Example #59
0
def manhattan_priority(sequence):
    end_node = sequence[-1]
    state, cost = end_node[0], end_node[2]
    f = cost + util.manhattanDistance(state, problem.goal)
 def heuristic(p1, p2):  # 曼哈顿距离
     return util.manhattanDistance(p1, p2)