Esempio n. 1
0
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)
Esempio n. 2
0
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
Esempio n. 3
0
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)
Esempio n. 4
0
    def __init__(self, planeador):

        self._planeador = planeador
        self._modelo_mundo = ModeloMundo()
        self._objectivos = None
Esempio n. 5
0
 def __init__(self):
     self._desejos = []
     self._crencas = ModeloMundo()
     self._intencoes = []
Esempio n. 6
0
 def __init__(self, mec_rac):
     self.modelo = ModeloMundo()
     self.plano = None
     
     self.planeador = mec_rac