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

1. CEOPS++ Integração entre Objetos e Regras de Produção em C++ Aluno:Pablo de Santana Barbosa Orientador: Geber Lisboa Ramalho

2. 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

3. 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

4. Roteiro • Motores de código aberto • CEOPS++ • Conclusões

5. 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?

6. Motores existentes • Tabela de comparação

7. Base de Objetos Base Interna de Regras Knowledge Conjunto de Conflito Base - - - - ---- - - - - ---- - - - - - -- - - - - ---- - - - - - - Motor de referência: Jeops Agente insert run objects flush JEOPS Rete Gera entradas Consulta Base de Conhecimentos

8. CEOPS++

9. Fatos • Podem ser qualquer objeto ou estrutura em C++ • O CEOPS++ armazena ponteiros para objetos (void*)

10. 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)

11. 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);

12. 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; } };

13. 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 A subclasses.push_back(typeid(A).name()); } if(typeB.check(type)) { //verifica se eh subclasse de B subclasses.push_back(typeid(B).name()); } if(typeC.check(type)) { //verifica se eh subclasse de C subclasses.push_back(typeid(C).name()); } }

14. 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

15. 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); }

16. 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

17. Pré-compilação

18. Rete(rete::Rete) • Possui apenas a funcionalidade de memorização das avaliações realizadas

19. 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 } Rete(rete::Rete)

20. 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)

21. 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()

22. 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)

23. Resultados Fibonacci Oito rainhas

24. 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

25. 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.