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