class ControloDeliberativo:
def __init__(self, mec_rac):
self.modelo = ModeloMundo()
self.plano = None
self.planeador = mec_rac
def processar(self, per):
estado = self.assimilar(per)
objectivos = self.gerar_objectivos()
## if self.plano is None:
self.plano = self.planear(estado, objectivos)
return self.executar_plano(self.plano)
def executar_plano(self, plano):
#como executar_plano é chamada à vez fazemos pop do plano e movemos o actuador com esse valor
if plano:
#print 'Plano: [%s]' % ', '.join(map(str, plano))
ang = plano.pop(0)
#print 'Angulo: {}'.format(ang)
accao = psa.actuador.MOVER(ang)
return accao
#o assimilar gera os estados com eles os elementos e no fim actualiza os elementos
def assimilar(self, per):
elementos = per.imagem
self.modelo.actualizar(elementos) # criar os estados
agente_pos = per.posicao
return agente_pos
def gerar_objectivos(self):
objectivos = []
estados = self.modelo.obter_estados()
if estados:
for s in estados:
elemento = self.modelo.obter_elemento(s)
if elemento is ALVO:
objectivos.append(s)
return objectivos
def planear(self, estado, objectivos):
return self.planeador.planear(self.modelo, estado, objectivos)
class ControloDelib(Controlo):
def __init__(self):
self._desejos = []
self._crencas = ModeloMundo()
self._intencoes = []
def _processar(self, percepcao):
self._actualizar_crencas(percepcao)
if self._reconsiderar():
self._deliberar()
self._planear()
return self._executar()
def _actualizar_crencas(self, percepcao):
self._crencas._actualizar(percepcao)
def reconsiderar(self):
Abstract
def _deliberar(self):
self._desejos = self._geraropcoes()
if self._desejos:
self._intencoes = self._seleccionaropcoes()
else:
self._intencoes = []
def planear(self):
Abstract
def executar(self):
Abstract
def _geraropcoes(self):
self._desejos = self._crencas._pos_alvos()
return self._desejos
def _seleccionaropcoes(self):
return self._desejos
class ControloDelib(object):
def __init__(self, planeador):
self._planeador = planeador
self._objectivos = []
self._modelo_mundo = ModeloMundo()
def _reconsiderar(self):
return (not self._objectivos or not self._planeador.plano_pendente()
or self._modelo_mundo.alterado)
def _deliberar(self):
self._objectivos = [
estado for estado in self._modelo_mundo.estados()
if self._modelo_mundo.obter_elem(estado) == "alvo"
]
def _planear(self):
if self._objectivos:
self._planeador.planear(self._modelo_mundo,
self._modelo_mundo.estado,
self._objectivos)
else:
self._planeador.terminar_plano()
def _executar(self):
operador = self._planeador.obter_accao(self._modelo_mundo.estado)
if operador is not None:
return operador.accao
def processar(self, percepcao):
self._assimilar(percepcao)
if self._reconsiderar():
self._deliberar()
self._planear()
self.mostrar()
return self._executar()
def _assimilar(self, per):
self._modelo_mundo.actualizar(per)
def mostrar(self):
vis = psa.vis(1)
vis.limpar()
self._modelo_mundo.mostrar(vis)
self._planeador.mostrar(vis, self._modelo_mundo.estado)
def __init__(self, planeador):
self._planeador = planeador
self._modelo_mundo = ModeloMundo()
self._objectivos = None
def __init__(self):
self._desejos = []
self._crencas = ModeloMundo()
self._intencoes = []
def __init__(self, mec_rac):
self.modelo = ModeloMundo()
self.plano = None
self.planeador = mec_rac