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 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 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