CEOPS++
Integração entre Objetos e Regras de Produção em C++
Aluno:Pablo de Santana Barbosa
Orientador: 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
Tabela de comparação
Linguag.
Uniformid.
Desempenho
Res.
Conflitos
Facilidade
Integração
Soar
C
-
+/-
-
+/-
Jeops
Java
+
+/-
+
+
Clips
C
-
-
+/-
-
Motor de referência: Jeops
Agente
insert
run
objects
flush
JEOPS
Knowledge
Base
-- - - ----- - - ---- - - - ---- - - ----- - - --
ClassFilter
Decl 1
ClassFilter
Decl 2
ClassFilter
Decl 3
FilterNode
Decl 1
FilterNode
Decl 2
FilterNode
Decl 3
JoinNode
Decl 1
JoinNode
Decls 1 a 2
JoinNode
Decls 1 a 3
Rete
Gera
entradas
Conjunto de Conflito
FinalNode
Regra n
Consulta
Base Interna
de Regras
Base de
Objetos
Base de
Conhecimentos
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 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());
}
}
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ção
Arquivo de
Regras
(.rules)
Pré-compilador
CEOPS++
Base de Regras
Regras
(*_rules.h)
(*_rule_*.h)
Compilador C++
Código Objeto
Rete
(rete::Rete)
Possui apenas a funcionalidade de
memorização das avaliações
realizadas
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)
ClassFilter
d1
ClassFilter
d2, d3
}
FilterNode
true
FilterNode
c5
FilterNode
true
JoinNode
true
JoinNode
c1
JoinNode
c2,c3,c4
FinalNode
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
Fibonacci
Oito rainhas
CEOPS++
Jeops
Fibonacci(20):
6765
6765
Nº disparos:
32836
32836
Criação da KB
> 1 ms
15 ms
565ms
2,5min
Tempo de
Execução
CEOPS++
Jeops
Nº disparos:
92
92
Criação da KB
10 ms
45ms
Tempo de
Execução
15 ms
15 ms
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/b
pg.pdf
Soar 8 Manual.
http://ai.eecs.umich.edu/soar/sitemaker/docs/manual
s/Soar8Manual.pdf.
Vollmann, Detlef. Metaclasses and Reflection in C++.
http://vollmann.ch/en/pubs/meta/meta/meta.html.
Download
