ceops++ integração entre objetos e regras de produção em c++ aluno:pablo de santana barbosa...
TRANSCRIPT
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.