def obterisens(self, rot):
self.imagem_sens = []
posper = posag = self.elemag.pos
dpasso = 1
incpos = util.incpos(dpasso, self.elemag.dir + rot)
isens = None
while isens is None:
self.posperant = posint(posper)
posper = util.movpos(posper, incpos)
if self.posval(posint(posper)):
elem = self.obterelempos(posper)
if elem is not None:
dist = util.dist(posag, posint(posper))
isens = (
elem, dist, rot)
break
else:
self.imagem_sens.append((posint(posper), elementos.VAZIO))
else:
dist = util.dist(posag, posint(posper))
elem = elementos.Obstaculo(posper)
isens = (elem, dist, rot)
break
if isens:
self.isens.append(isens)
self.imagem_sens.append((posint(posper), isens[0].tipo))
self.posper = posper
return isens
def detectar_colisao(self, novapos):
elem, _, _ = self.obterisens(0)
if elem.tipo == 'obst':
dist_posperant = util.dist(self.elemag.pos, self.posperant)
dist_novapos = util.dist(self.elemag.pos, novapos)
if dist_posperant < dist_novapos:
return dist_posperant
def reforco(self, percepcao, s, sn):
ref = -dist(s, sn)
if percepcao.alvo:
ref += self._r_max
if percepcao.colisao:
ref -= self._r_max
return ref # double
def _reforco(self, percepcao, s, sn):
r = -dist(s,sn)
if percepcao.colisao:
r += -self._r_max
elif percepcao.carga:
r += self._r_max
return r
def gerar_reforco(self, percepcao, s,sn):
r = -dist( s, sn) #calcula a distancia entre 2 pontos: distancia diagonal <> distancia quadrado contiguo
if percepcao.colisao:
r -= MAX_REF
elif percepcao.carga:
r += MAX_REF
return r
def custo(self, estado, novo_estado):
'''
@param estado: Estado
@param novo_estado: Estado
@return: double
'''
return max(dist(estado, novo_estado), 1)
def __deliberar(self):
'''
Verifica todos os objetivos percepcionados, e procura o melhor, tendo em conta a distancia
'''
self.__objetivos = [estado for estado in self.__modelo_mundo.estados()
if self.__modelo_mundo.obter_elem(estado) == ALVO]
estado_agente = self.__modelo_mundo.estado
self.__objetivos.sort(key=lambda estado : dist(estado, estado_agente))
def heuristica(self, estado):
"""
Retorna o valor da heurística, ou seja, a distância entre o estado passado como parâmetro, e o estado final
Parameters
----------
estado : Estado
Returns
-------
float
"""
return dist(estado, self.__estado_final)
def gerar_valor(self, objectivos, modelo, gama, valor_max):
V = {}
frente_onda = []
for s in objectivos:
V[s] = valor_max
frente_onda.append(s)
while frente_onda:
s = frente_onda.pop(0)
for sn in self.adjacentes(s, modelo):
# v = V[s] * gama**dist(s, sn)
v = V[s] * pow(gama, dist(s, sn))
if v > V.get(sn, float("-inf")):
V[sn] = v
frente_onda.append(sn)
return V
def planear(self, modelo, estado_inicial, objectivos):
V= {}
frente_de_onda = []
for s in objectivos:
V[s] = self.VALOR_MAX
frente_de_onda.append(s)
while frente_de_onda:
s = frente_de_onda.pop(0)
# lista de todos os estados 'sn' adjacentes de s
for a, sn in modelo.transicoes( s):
if sn != s:
d = dist(s, sn)
vs = V.get(s,0) * math.pow(self.GAMA, d )
vsn = V.get( sn, 0)
if vsn == 0 or vs > vsn:
#ainda nao foi explorado o caminho ou precisa de ser reavaliado
V[sn] = vs
frente_de_onda.append(sn)
return self.gerar_plano( estado_inicial, modelo, V )
def esquema(self, crencas):
if self._pre_condicoes(crencas):
# vai esccolher uma casa vazia junto do grupo de bases
bases = crencas.obter_chaves('base')
entrada_bases= []
for base in bases:
for movimento in dirmov():
nova_posicao = mover(base, movimento)
if not crencas.obter_valor(nova_posicao) and nova_posicao not in entrada_bases:
# e uma casa livre
entrada_bases.append(nova_posicao)
base_entrada = entrada_bases[0] # escolhe uma casa livre junto das bases
#vai ordenar as bases com base no uso de frente de onda
V= {}
frente_de_onda = []
maximo = 100
gama = 0.9
s = base_entrada
# vai usar a frente de onda para descobrir a base vazia mais distante
V[s] = maximo
frente_de_onda.append(s)
while frente_de_onda:
s = frente_de_onda.pop(0)
# lista de todos os estados 'sn' adjacentes de s
for sn in self._transicoes(s, crencas):
if sn != s:
d = dist(s, sn)
vs = V.get(s,0) * math.pow(gama, d )
vsn = V.get( sn, 0)
if vsn == 0 or vs > vsn:
#ainda nao foi explorado o caminho ou precisa de ser reavaliado
V[sn] = vs
frente_de_onda.append(sn)
#actualiza as crencas com o "potencial de cada base" e a posicao da entrada
crencas.definir_entrada_bases(base_entrada)
crencas.inicializar_bases(V)
def evoluir(self, passosevol):
self.elemag.evoluir()
elemrem = {}
elemins = {}
if self.dinamb > 0:
for elem in self.elementos.values():
elem.evoluir(passosevol)
if elem.tvida == 0:
self.elemgest.append(elem)
self.remelemex(elem, elemrem)
if self.elemgest:
for ielem, elem in enumerate(self.elemgest):
elem.evoluir(passosevol)
if elem.tvida > 0:
x = random() * (self.dimx - 1)
y = random() * (self.dimy - 1)
novapos = posint((x, y))
if not self.elementos.get(novapos):
if elemins.get(novapos):
for posalt in self.area:
if not self.elementos.get(posalt):
novapos = elemins.get(novapos) or posalt
break
if self.elementos.get(novapos) or elemins.get(novapos) or util.dist(self.elemag.pos, novapos) > 1:
elem.pos = novapos
elem.alterado = True
self.inselemex(elem, elemins)
self.elemgest.pop(ielem)
self.actelem(elemrem, elemins)
self.alterado = True
alvos = [e for _, e in self.elementos.items() if e.tipo == 'alvo']
res = self.alterado
self.alterado = False
return res
def heuristica(self, estado):
return dist(estado, self._estado_final)
def _seleccionaropcoes(self):
intencao = argmin(self._desejos, lambda d : dist(self._crencas.estado(), d))
return [intencao]
def custo_accao(self, s, a, sn):
return dist(s, sn)
def custo(self, state, new_state):
return max(dist(state, new_state), 1)
def heuristica(self, estado):
'''
@param estado: Estado
@return: double
'''
return dist(estado, self.__estado_final)
def heuristic(self, state):
return dist(state, self._final_state)
def heuristica(self, estado):
return dist(estado, self._estado_final)
def heuristica(self, estado):
return dist(estado, self._estado_final) #distancia ao alvo
def _selecionar_opcoes(self):
pos_agente = self._crencas.pos_agente()
f_avaliacao = lambda pos_desejo: dist(pos_desejo, pos_agente)
self._intencoes = sorted(self._desejos, key=f_avaliacao)
def custo(self, estado, novo_estado):
return max(dist(estado, novo_estado), 1)
def escolher_alvo(self, crencas):
posicao_actual = crencas.obter_valor('posicao_agente')
posicoes = crencas.obter_chaves(self.descriptor)
if posicoes:
criterio_avaliacao = lambda posicao: dist(posicao_actual, posicao)
return argmin(posicoes, criterio_avaliacao) #escolhe o alvo "mais perto" do agente
