def __init__(self, state, start, goals):
PositionSearchProblem.__init__(self,
state,
start=start,
warn=False,
visualize=False)
self.goals = {key: True for key in goals}
self.count = len(goals)
def getAction(self, state):
problem = PositionSearchProblem(state) #Mapeia todos os estados do jogo
problem.startState = state.getPacmanPosition() #Mapeia o estado atual do objeto do pacman
allFoods = list(state.getFood().asList()) #Insere uma lista com todas as comidas
x, food = min([(util.manhattanDistance(problem.getStartState(), food), food) for food in
allFoods]) #Heuristica da comida
problem.goal = food #Objetivo
pqueue = util.PriorityQueue() #Cria uma heap
current_state = [problem.getStartState(), [], 0] #Estado atual
successors = None #Cria um estado sucessor vazio
explored = set() #cria ums lista de nos expandidos
item = None #Cria uma variavel para armazenar os dados de um estado
explored.add(problem.getStartState()) #Insere o novo estado
#Aqui e o algoritmo a star
while not problem.isGoalState(current_state[0]):
(current_pos, directions, cost) = current_state #Tupla do No atual
successors = problem.getSuccessors(current_pos) #Usa a funcao getSucessors para gerar todos os estados sucessores
for item in successors:
if not item[0] in state.getGhostPositions(): #Se existir fantasma no caminho do pacman, ele nao expande
pqueue.push((item[0], directions + [item[1]], cost + item[2]),
cost + item[2] + util.manhattanDistance(item[0], problem.goal))
while(True):
if (pqueue.isEmpty()): #Se a fila estiver vazia, termina
return None
item = pqueue.pop() #Retira o item com maior prioridade da lista
if item[0] not in explored: #Se o no nao existir na lista de estados visitados, ele sai
break
current_state = (item[0], item[1], item[2]) #Adiciona um novo estado caso contrario
explored.add(item[0]) #adiciona a tupla com a posicao do no ja visitado
return current_state[1][0] #retorna a acao
def getAction(self, state):
problem = PositionSearchProblem(
state) #Mapeia todos os estados do jogo
problem.goal = state.getPacmanPosition(
) #Mapeia o estado atual do pacman
problem.startState = state.getGhostPosition(
self.index) #Mapeia o estado atual do objeto do fantasma
frontier = util.PriorityQueue() #Cria uma fila de prioridade
frontier.push(
problem.getStartState(),
manhattanHeuristic(problem.getStartState(),
problem)) #coloca na heap o primeiro estado
explored = [] #Nos expandidos
paths = {} #Todos os estados que foram percorridos
totalCost = {} #Custo total
paths[problem.getStartState()] = list()
totalCost[problem.getStartState()] = 0
def isBestCostforState(cost, state):
for n in frontier.heap:
if n[1] == state:
if (n[1] in totalCost.keys()) and (totalCost[n[1]] > cost):
frontier.heap.remove(n)
return True
else:
return False
return True
while not frontier.isEmpty():
s = frontier.pop()
if problem.isGoalState(s):
return paths.popitem()[1][0]
explored.append(s)
successors = problem.getSuccessors(s)
for successor in successors:
successorState = successor[0]
move = successor[1]
cost = successor[2]
if (successorState not in explored and isBestCostforState(
totalCost[s] + cost, successorState)):
paths[successorState] = list(paths[s]) + [move]
totalCost[successorState] = totalCost[s] + cost
frontier.push(
successorState,
manhattanHeuristic(successorState, problem) +
totalCost[successorState])
return []
def chooseAction(self,gameState):
currObs = self.getCurrentObservation()
self.position = currObs.getAgentPosition(self.index)
opponents = self.getOpponents(currObs)
defendedFood = self.getFoodYouAreDefending(currObs).asList(True)
# if not enemies around go around
# for i in opponents:
# if not currObs.getAgentPosition(i):
# continue
for i in opponents:
self.visibleAgents += [currObs.getAgentPosition(i)]
if self.visibleAgents[0] == None and self.visibleAgents[1] == None:
# wander around
# closestFood = self.closest(defendedFood,self.position)
randomFood = random.choice(defendedFood)
# defendingProblem = searchAgents.AnyFoodSearchProblem(currObs, self.index , defendedFood, closestFood,self.visibleAgents,opponents)
# posProb = PositionSearchProblem(currObs, costFn = lambda x: 1, closestFood, start=None, warn=True, visualize=True)
print "mypos, closestFood", currObs.getAgentPosition(self.index)," "
defendingProblem = PositionSearchProblem(currObs, self.index, closestFood)
# goal is to kill pacman
else:
# opponentsDist=[]
# for i in self.visibleAgents:
# if i is None:
# continue
print "lito ",self.visibleAgents, self.position
closestOpponent = self.closest(self.visibleAgents, self.position)
# self.manhattanDist(self.position, i)
# print "adfas", self.position, i
# closestOpponent =
# defendingProblem = searchAgents.AnyFoodSearchProblem(currObs, self.index , defendedFood, closestOpponent, self.visibleAgents,opponents)
# defendingProblem = DefendingProblem(currObs, guardIndex, defendedFood)
# posProb = PositionSearchProblem(currObs, closestOpponent)
defendingProblem = PositionSearchProblem(currObs, self.index, closestOpponent)
actions = search.aStarSearch(defendingProblem,searchAgents.manhattanHeuristic)
return actions[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 ***"
#xGhost = [newGhostStates[i].getPosition()[0] for i in range(len(newGhostStates))]
#[yGhost = newGhostStates[i].getPosition()[1] for i in range(len(newGhostStates))]
val = 0
oldFood = currentGameState.getFood().asList()
newFood = newFood.asList()
for gTuple in newGhostStates:
if manhattanDistance(gTuple.getPosition(), newPos) < 3:
val -= 30
if len(oldFood) > len(newFood):
val += 11
minDist = float("infinity")
closeFood = None
for food in newFood:
md = manhattanDistance(food, newPos)
if md < minDist:
minDist = md
closeFood = food
# testing breadth first search
problem = PositionSearchProblem(successorGameState,
goal=closeFood,
start=newPos,
warn=False)
realDist = len(breadthFirstSearch(problem))
if closeFood != None:
val += 10 / realDist
return val
def getAction(self, state):
problem = PositionSearchProblem(
state) #Mapeia todos os estados do jogo
problem.goal = state.getPacmanPosition(
) #Mapeia o estado atual do pacman
problem.startState = state.getGhostPosition(
self.index) #Mapeia o estado atual do objeto do fantasma
pqueue = util.PriorityQueue() #Cria uma fila de prioridades
current_state = [problem.getStartState(), [],
0] #Cria o estado inicial
successors = None #Cria um estado sucessor vazio
explored = set() #cria ums lista de nos expandidos
item = None #Cria uma variavel para armazenar os dados de um estado
explored.add(problem.getStartState()) #Insere o novo estado
#Aqui e o algoritmo a star
while not problem.isGoalState(current_state[0]):
(current_pos, directions, cost) = current_state #Tupla do No atual
successors = problem.getSuccessors(
current_pos
) #Usa a funcao getSucessors para gerar todos os estados sucessores
for item in successors:
ghostsPos = state.getGhostPositions(
) #Pega a posicao de todos os fantasmas
ghostsPos.remove(
state.getGhostPosition(self.index)
) #Remove si mesmo pois somente o outro fantasma q nao pode
if not item[
0] in ghostsPos: #Se nao houver fantasmas no caminho, ele insere o no na fila
pqueue.push(
(item[0], directions + [item[1]], cost + item[2]),
cost + item[2] +
util.manhattanDistance(item[0], problem.goal))
while (True):
if (pqueue.isEmpty()): #Se a fila estiver vazia, termina
return None
item = pqueue.pop(
) #Retira o item com maior prioridade da lista
if item[0] not in explored: #Se o no nao existir na lista de estados visitados, ele sai
break
current_state = (item[0], item[1], item[2]
) #Adiciona um novo estado caso contrario
explored.add(
item[0]) #adiciona a tupla com a posicao do no ja visitado
return current_state[1][0] #retorna a acao
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 ***"
scoreWeight = 1
foodCountWeight = -10
capsuleCountWeight = -30
minFoodDistanceWeight = -1
minGhostDistanceInvWeight = -10
minGhostDistanceInv2Weight = -50
evaluation = 0
pacmanPosition = currentGameState.getPacmanPosition()
foodList = currentGameState.getFood().asList()
capsuleList = currentGameState.getCapsules()
score = currentGameState.getScore()
evaluation += scoreWeight * score
foodCount = len(foodList)
evaluation += foodCountWeight * foodCount
capsuleCount = len(capsuleList)
evaluation += capsuleCountWeight * capsuleCount
if not foodList:
minFoodDistance = 0
else:
foodDistances = [manhattanDistance(food, pacmanPosition)
for food in foodList]
closestFoodIndex = foodDistances.index(min(foodDistances))
closestFood = foodList[closestFoodIndex]
sys.stdout = open(os.devnull, "w") # silence
prob = PositionSearchProblem(currentGameState, start=pacmanPosition,
goal=closestFood)
actions = SearchAgent(fn='aStarSearch', prob='PositionSearchProblem',
heuristic='manhattanHeuristic').searchFunction(prob)
sys.stdout = sys.__stdout__ # end silence
minFoodDistance = len(actions)
evaluation += minFoodDistanceWeight * minFoodDistance
minGhostDistance = 99999
for ghostState in currentGameState.getGhostStates():
ghostPosition = ghostState.configuration.getPosition()
ghostDistance = util.manhattanDistance(ghostPosition, pacmanPosition)
minGhostDistance = min(ghostDistance, minGhostDistance)
if minGhostDistance == ghostDistance:
minGhostScaredTimer = ghostState.scaredTimer
minGhostDistanceInv = 1.0/(minGhostDistance + 0.01)
minGhostDistanceInv2 = 1.0/((minGhostDistance ** 2) + 0.01)
if minGhostScaredTimer > minGhostDistance:
evaluation -= minGhostDistanceInvWeight * minGhostDistanceInv
evaluation -= minGhostDistanceInv2Weight * minGhostDistanceInv2
else:
evaluation += minGhostDistanceInvWeight * minGhostDistanceInv
evaluation += minGhostDistanceInv2Weight * minGhostDistanceInv2
return evaluation
def getAction(self, state):
acoes = state.getLegalActions(self.index)
fantasmas = state.getGhostState(self.index)
medo = fantasmas.scaredTimer > 0 #Diz se o fantasma esta com medo
problema = PositionSearchProblem(state) #O problema atual
problema.startState = state.getGhostPosition(
self.index) #Estado Inicial
problema.goal = state.getPacmanPosition(
) #Objetivo e a posicao do pacman
inicio = problema.getStartState(
) #O inicio e o estado inicial do problema
heap = util.PriorityQueue()
origemEstado = {}
custos = {inicio: 0}
custosFinais = {inicio: util.manhattanDistance(inicio, problema.goal)}
visitados = set()
heap.push(inicio, custosFinais[inicio])
estadoEscolhido = None
#Busca comeca aqui
while not heap.isEmpty():
estadoAtual = heap.pop()
visitados.add(estadoAtual)
if problema.isGoalState(estadoAtual): #Encontrou o objetivo
caminhoArvore = [estadoAtual]
while estadoAtual in origemEstado.keys(
): #Verifica se o estadoAtual nao eh o inicial, senao for continua subindo na arvore
estadoAtual = origemEstado[estadoAtual]
caminhoArvore.append(estadoAtual)
estadoEscolhido = caminhoArvore[
-2] #A penultima posicao corresponde ao estado apos o inicial
break
#Gerando sucessores
for sucessor in problema.getSuccessors(estadoAtual):
posicaoFantasmas = state.getGhostPositions()
posicaoFantasmas.remove(state.getGhostPosition(self.index))
if not sucessor[0] in posicaoFantasmas:
if sucessor[0] in visitados:
continue
origemEstado[sucessor[0]] = estadoAtual
custos[sucessor[0]] = custos[estadoAtual] + sucessor[2]
custosFinais[sucessor[0]] = custos[
sucessor[0]] + util.manhattanDistance(
sucessor[0], problema.goal
) #Soma custo com a heuristica (f(x) = g(x) + h(x))
if not heap.contains(sucessor[0]):
heap.push(sucessor[0], custosFinais[sucessor[0]])
acaoEscolhida = None
#Retorna a melhor acao legal
for sucessor in problema.getSuccessors(inicio):
if estadoEscolhido == sucessor[0]:
if sucessor[1] in acoes:
acaoEscolhida = sucessor[1]
#Fantasmas assustados vao pra qualquer direcao.
if medo and acaoEscolhida != None and len(acoes) > 1:
acoes.remove(acaoEscolhida)
acaoEscolhida = random.choice(acoes)
elif acaoEscolhida == None:
acaoEscolhida = random.choice(acoes)
return acaoEscolhida
def getAction( self, state ):
acoes = state.getLegalActions()
posicaoFantasmas = state.getGhostPositions()
problema = PositionSearchProblem(state)
problema.startState = state.getPacmanPosition()
inicio = problema.getStartState()
problema.goal = min([(util.manhattanDistance(inicio, comida) + calculoRaio(posicaoFantasmas, comida, state), comida) for comida in state.getFood().asList()])[1] #Objetivo
heap = util.PriorityQueue()
origemEstado = {} #Tabela de origem do estado
custos = {inicio: 0}
custosFinais = {inicio: util.manhattanDistance(inicio, problema.goal)}
visitados = set()
heap.push(inicio, custosFinais[inicio]) #Insere o estado inicial na heap
estadoEscolhido = None
while not heap.isEmpty():
estadoAtual = heap.pop()
visitados.add(estadoAtual)
#Se chegarmos ao estado final, recriamos um caminho de estados ate o inicio da busca, tirando o estado inicial
if problema.isGoalState(estadoAtual):
caminhoArvore = [estadoAtual]
while estadoAtual in origemEstado.keys(): #Verifica se o estadoAtual nao eh o inicial, senao for continua subindo na arvore
estadoAtual = origemEstado[estadoAtual]
caminhoArvore.append(estadoAtual)
estadoEscolhido = caminhoArvore[-2] #A penultima posicao corresponde ao estado apos o inicial
break
for sucessor in problema.getSuccessors(estadoAtual): #Gerando novos estados
medo = False
# sucessor[0] eh o elemento 0 da tri-pla retornada por PositionSearchProblem.getSucessors que eh o estado
if sucessor[0] in posicaoFantasmas:
for index in xrange(1, state.getNumAgents()):
if state.getGhostState(index).scaredTimer > 0 and state.getGhostPosition(index) == sucessor[0]:
medo = True
if (sucessor[0] in posicaoFantasmas and medo) or sucessor[0] not in posicaoFantasmas:
if sucessor[0] in visitados:
continue
origemEstado[sucessor[0]] = estadoAtual
custos[sucessor[0]] = custos[estadoAtual] + sucessor[2] #Soma custo atual com os anteriores
custosFinais[sucessor[0]] = custos[sucessor[0]] + util.manhattanDistance(sucessor[0], problema.goal) #Soma custo com a heuristica (f(x) = g(x) + h(x))
if not heap.contains(sucessor[0]):
heap.push(sucessor[0], custosFinais[sucessor[0]])
acaoEscolhida = None #Ainda nao se sabe a acao que leva ao estado escolhido
# sucessor[1] eh o elemento 1 da tri-pla retornada por PositionSearchProblem.getSucessors que eh a acao
#Retorna a melhor acao legal
for sucessor in problema.getSuccessors(inicio):
if estadoEscolhido == sucessor[0]:
if sucessor[1] in acoes:
acaoEscolhida = sucessor[1]
if acaoEscolhida == None:
acaoEscolhida = random.choice(acoes)
return acaoEscolhida