ceops++ integração entre objetos e regras de produção em c++ aluno:pablo de santana barbosa...

CEOPS++ Integração entre Objetos e Regras de Produção em C++

Aluno:Pablo de Santana BarbosaOrientador: Geber Lisboa Ramalho

Jogos e RBS’s Jogos

Exigência de uma IA cada vez mais sofisticada

Realismo e oponentes competitivos RBS

São muito utilizados em jogos Poucos motores código aberto no

mercado O caso SmartSim

Jogos e RBS’s

Poucos Motores de código aberto no Mercado

Princípios importante para o uso de RBS’s em jogos Uniformidade de integração Bom desempenho

Roteiro

Motores de código aberto CEOPS++ Conclusões

Sistemas de Produção e Orientação a Objetos

EOOPS Vantagens

Facilidade de uso

Engenharia de Software: reutilização, modularidade, extensibilidade...

Desvantagens O problema da modificação dos objetos Quando usar regras ou objetos?

Motores existentes

Linguag. Uniformid. Desempenho Res. Conflitos

Facilidade Integração

Soar C - +/- - +/-

Jeops Java + +/- + +

Clips C - - +/- -

Tabela de comparação

Motor de referência: Jeops

Geraentradas

Agente

Base deConhecimentos

Base deObjetos

Rete

Base Internade Regras

Conjunto de Conflito

Consulta

JoinNodeDecls 1 a 2

FilterNodeDecl 1

ClassFilterDecl 1

FilterNodeDecl 2

ClassFilterDecl 2

JoinNodeDecls 1 a 3

FilterNodeDecl 3

ClassFilterDecl 3

FinalNodeRegra n

JoinNodeDecl 1

JEOPS

flushinsert run objects

-- - - ------ - - ----- - - - ----- - - ------ - - --

Knowledge Base

CEOPS++

Fatos

Podem ser qualquer objeto ou estrutura em C++

O CEOPS++ armazena ponteiros para objetos (void*)

Base de Objetos(ceops::ObjectBase)

Guarda referências para todos os objetos da memória de trabalho

Evita duplicação de fatos Armazena informações de herança de

classes Principais Métodos

bool Insert<T>(T* obj) bool Retract<T>(T* obj) void GetObjects<T>(vector<T*>& objs) GetSubclasses<T>(vector<string>&

subclasses)

Checagem de subtipos(1)(util::TypeCheckFunction)

C++ não suporta reflexão Suporte limitado a RTTI(Runtime Type

Information) Algumas API’s código aberto tentam prover

reflexão Escolha de uma solução própria

Usado em conjunto com a classe TypeCheck template<typename T>

inline void TypeCheckFunction(T* type,

vector<string>& subclasses);

Checagem de subtipos(2)(util::TypeCheckFunction)

template<typename T>class TypeCheck {public:

TypeCheck() {}

bool check(T* t) {return true;

}bool check(T& t) {

return true;}bool check(void* v) {

return false;}

};

Checagem de subtipos(3)(util::TypeCheckFunction)

template<typename T>inline void TypeCheckFunction(T* type, vector<string>& subclasses) {

TypeCheck<A> typeA;TypeCheck<B> typeB;TypeCheck<C> typeC;

if(typeA.check(type)) { //verifica se eh subclasse de Asubclasses.push_back(typeid(A).name());

}

if(typeB.check(type)) { //verifica se eh subclasse de Bsubclasses.push_back(typeid(B).name());

}

if(typeC.check(type)) { //verifica se eh subclasse de Csubclasses.push_back(typeid(C).name());

}}

Regras(ceops::AbstractRule)

Sintaxe próxima de C++ Possui três campos distintos:

Declarations Declaração de ponteiros para classes ou

estruturas Conditions

Qualquer expressão booleana válida em C++ Actions

Qualquer comando válido em C++ Insert, Modify, Retract

Exemplo de regra CEOPS++

rule GoDown { declarations Fibonacci* f0; conditions f0->getN() > 1; f0->getValue() == -1; f0->getSon1() == NULL; actions int n = f0->getN(); Fibonacci* s1 = new Fibonacci(n - 1); Fibonacci* s2 = new Fibonacci(n - 2); f0->setSon1(s1); f0->setSon2(s2); Insert(s1); Insert(s2); Modified(f0);}

Base de Regras(ceops::AbstractRuleBase)

Funciona apenas como um repositório de regras

Representa o conjunto das regras definidas pelo usuário

Gerada automaticamente pelo pré-compilador

Pré-compilaçãoArquivo de

Regras(.rules)

Pré-compilador CEOPS++

Regras(*_rule_*.h)

Base de Regras(*_rules.h)

Código ObjetoCompilador C++

Rete(rete::Rete)

Possui apenas a funcionalidade de memorização das avaliações realizadas

Rete(rete::Rete)

ClassFilterd1

ClassFilterd2, d3

FilterNodetrue

FilterNodec5

FilterNodetrue

JoinNodetrue

JoinNodec1

JoinNodec2,c3,c4

FinalNode

rule atacar { declarations AgenteJogador agente; //d1 Unidade unidade1; //d2 Unidade unidade2; //d3 Conditions agente.ehDono(unidade1); //c1 agente.ehInimigo(unidade2); //c2 unidade2.getPosicao().distancia( unidade1.getPosicao() ) <= unidade1.getAlcanceAtaque(); //c3 unidade1.getAtaque() > unidade2.getAtaque(); //c4 unidade1.tirosRestantes > 0; //c5 actions unidade1.atacar(unidade2); //a1

}

Conjunto de conflitos(conflict::ConflictSet)

Conjunto que armazena as regras ativas e os objetos que as ativaram

É uma interface que deve ser implementada pelo usuário

Principais Métodos virtual void

InsertElement(ConflictSetElement* element) virtual ConflictSetElement* NextElement() void RemoveElementsWith(void* obj)

Elemento do conjunto de conflitos(conflict::ConflictSetElement)

Representa uma regra ativa e os objetos que ativaram a regra

Principais Métodos AbstractRule* GetRule() vector<Fact>& GetFacts() unsigned long GetTime()

Base de Conhecimentos(ceops::KnowledgeBase)

É a interface entre o usuário e o motor de inferência

Deve ser inicializada com um conjunto de regras e um conjunto de conflitos

Principais métodos: bool Insert<T>(T* fact) void Modify<T>(T* fact) void Retract<T>(T* fact)

Resultados

CEOPS++ Jeops

Fibonacci(20): 6765 6765

Nº disparos: 32836 32836

Criação da KB > 1 ms 15 ms

Tempo de Execução

565ms 2,5min

Fibonacci

CEOPS++ Jeops

Nº disparos: 92 92

Criação da KB 10 ms 45ms

Tempo de Execução

15 ms 15 ms

Oito rainhas

Considerações finais

Contribuição Desenvolvimento de um motor original

que concilia as vantagens do Jeops com uma demanda de performance (C++)

Trabalhos futuros Construir um editor de regras Melhorar o pré-compilador Tornar o código portável para outros

compiladores

Principais referências Figueira, Carlos. JEOPS – Integração entre objetos e

Regras de produção em Java. Dissertação de Mestrado, CIn – UFPE, 2000.

CLIPS Basic Programming Guide. http://www.ghg.net/clips/download/documentation/bpg.pdf

Soar 8 Manual. http://ai.eecs.umich.edu/soar/sitemaker/docs/manuals/Soar8Manual.pdf.

Vollmann, Detlef. Metaclasses and Reflection in C++. http://vollmann.ch/en/pubs/meta/meta/meta.html.