ago 302013
 

Blz?
Hoje após receber mais um email perguntando sobre os padrões para jogos, resolvi publica-los no site.

O artigo tema da minha monografia da especialização de engenharia de software  e apresentado na conferência latinoamericana de padrões de software SugarLoafPlop’2010 e que em teoria também deve ou deveria estar disponibilizada na ACM Digital Library.

Caiu no esquecimento e na desmotivação. Esperei  até o momento para que pudesse ser publicado entre as obras da ACM, como não sei o estado atual e como o desejo inicial sempre foi fornecer acesso ao conteúdo e principalmente o aprendizado  construído durante a confecção do artigos estou disponibilizando o artigo da monografia junto com os slides da defesa e a revisão criada para o congresso.

Inicialmente minha intenção era criar um verdadeiro Catálogo de Padrões, acredito que poderíamos chegar a um número muito próximo do encontrado no GoF, porém desde a última apresentação do mesmo na conferência em 2010 até  o momento atual,  pude observar que o mundo acadêmico é algo que funciona com passos letárgicos. De fato as duas participações no congresso me ajudaram a ver que participar de tal comunidade não era um caminho natural para mim e que o tempo e prioridade da comunidade de padrões  não eram compatíveis com minha ideologia, o que contribuiu ainda mais para me afastar da meta inicial.

Com relação à publicação do artigo, tive algumas conversas de aconselhamento sobre a disponibilização do material, onde foi citado que o caminho “natural”, “ideal”, “melhor” seria esperar que o artigo fosse publicado na ACM para só depois disponibiliza-lo.

Nos foi apresentado que todos os padrões aceitos pela comunidade de padrões de softwares deveriam ser incluídos na ACM como um passo final de aceitação da proposta de padrão, inclusive após todas as etapas do processo de aprovação tivemos que assinar alguns termos para que o mesmo fosse publicado, o resultado disso é que até hoje não sei se o mesmo foi ou não publicado e nem se o catalogo que iniciei é tido como válido, inclusive  poderia ter sido o primeiro catalogo de padrões para jogos aceito pela comunidade internacional de padrões.

Pelo menos sempre foi à ideia passada nos congressos, que um padrão é padrão de “direito” quando o mesmo é submetido ao árduo processo de validação, refinamento, evolução e apreciação de outros escritos de padrões em uma conferência PLOP e nestes quesitos o catalogo de 5 padrões havia atingido todos os níveis de aceitação. Porém até hoje não sei dizer se são padrões oficialmente reconhecidos e nem se foram os primeiros padrões especificamente para jogos. Minhas pesquisas na época apontavam para este rumo.

Infelizmente percebi que a maioria dos padrões discutidos e apresentados nas conferências não são como nós programadores, desenvolvedores e arquitetos conhecemos, não são padrões de implementação como GoF, Posa ou JEE. São em grande maioria padrões de processo, geração de produtos e qualidade…. Poucos são os padrões para implementação de software, ou seja, são coisas muito diferentes dos idealizados pelo GoF.

O pior de tudo é que após todo o árduo trabalho de finalização, aprovação e suposta publicação dos padrões os mesmos não chegam onde deveriam, ou seja, os desenvolvedores dificilmente sabem que tais padrões existes. Não temos catálogos de fácil acesso e em sua maioria são “guardados” para serem publicados e vendidos em livros ou sites especializados, ou seja, quase sempre tem uma motivação $…

Então pergunto:
Qual o motivo de escrever um padrão? Do que adianta o conhecimento adquirido se o mesmo não chega onde deveria? Porque escrever padrões?  Pra quem eles vão servir?

Minha única resposta até o momento é: “para alimentar nosso próprio ego“. Para quando chegarmos em nossas turmas, encher o peito e falar bem alto para os  todos ouvirem frases do tipo: “Sei tudo sobre padrões, até escrevi padrões“.
Só que a realidade é outra, grande parte destas pessoas apresenta uma vida profissional teórica sem escrever softwares, muito menos por em prática os padrões mais básicos como os apresentados no GoF/J2EE.

Saber de coisas como essas apenas pesaram ainda mais na minha desmotivação o que levou a minha decisão de parar de escrever o catalogo.

Talvez até um dia possa mudar de ideia, mas neste momento prefiro gastar meu pouco tempo com outras prioridades, até mais divertidas e menos estressantes. Bora jogar WoW? 😀  Se mudar de ideia me procure no Azralon, gosto de fazer um pouco de pvp.

Voltando….
Como adepto da filosofia do software livre e do copyleft estou disponibilizando o material produzido para este catálogo.
Desculpem o desabafo, mas era algo que gostaria de avisar para aqueles que tem um perfil mais prático como o meu. Para que se entrarem de cabeça na ideia dos padrões fazer sabendo que vão ter muita briga pela frente.

Se por acaso meu trabalho servir de inspiração ou for usado gostaria de saber, sem obrigação, apenas como falamos aqui no ceará “pedido de amigo”.

Downloads:

 

Aproveitando gostaria de agradecer a todos que ajudaram na confecção do catálogo:

ARAUJO et al.,2006: Allan R. S. Araujo, Juliana M. Silva, Artur F. Mittelbach, Scrum: Novas Regras do Jogo, 2006

BARBOSA,2010: Milton Escóssia Barbosa Neto, Currículo Lattes, 2010. Disponível em: <http://buscatextual.cnpq.br/buscatextual/visualizacv.jsp?id=K4739143Y7>, Acesso em:10 ago. 2010

BASTOS,2010: Gustavo Bastos, Linkedin, 2010. Disponível em: <http://br.linkedin.com/pub/gustavo-bastos/7/816/290>, Acesso em:10 ago. 2010

BITTENCOURT F.,2010: Fernando Bittencourt, Linkedin, 2010. Disponível em: <http://br.linkedin.com/in/frbitten>, Acesso em:10 ago. 2010

BITTENCOURT R.,2010: Ricardo Bittencourt, Linkedin, 2010. Disponível em: <http://br.linkedin.com/pub/ricardo-bittencourt/5/392/423>, Acesso em:10 ago. 2010

DARKCOLONY,1997: Strategic Simulations, Dark Colony, 1997. Disponível em: <http://pt.wikipedia.org/wiki/Dark_Colony>, Acesso em:13 mai. 2009

DUKITAN,2007: DukItan Software & Games, Web Site, 2007. Disponível em: <http://www.dukitan.com>, Acesso em:12 jul. 2009

DYNAMIC,2008: Dynamic Games, Web Site, 2008. Disponível em: <http://www.dynamicgames.com.br/jogos.html>, Acesso em:20 dez. 2008

EASY2D,2009: Jonatas de Moraes Junior, Easy2D Game Library, 2009. Disponível em: <http://easy2d.sourceforge.net/>, Acesso em:20 nov. 2009

EVANGELISTA,2010: Bruno Evangelista, Linkedin, 2010. Disponível em: <http://www.linkedin.com/in/brunoevangelista>, Acesso em:10 ago. 2010

F2IBUILDER,2007: DukItan Software & Games, F2IBuilder, Font To Image Builder, 2007. Disponível em: <http://f2ibuilder.sourceforge.net>, Acesso em:05 out. 2009

FZPONG,2007: DukItan Software & Games, FZ Pong, 2007. Disponível em: <http://portal.dukitan.com/fzpong>, Acesso em:13 mai. 2009

GAMEDEV,1999: GameDev.net, Web Site, 1999. Disponível em: <http://www.gamedev.net/>, Acesso em:10 jun. 2009

GBF,2005: DukItan Software & Games, GBFramework, 2005. Disponível em: <http://portal.dukitan.com/gbframework>, Acesso em:10 mai. 2009

GDJBR,2009: GDJBR, Grupo de Desenvolvedores de Jogos, 2009. Disponível em: <http://www.gdjbr.com>, Acesso em:10 ago. 2010

GOF,1995: Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides, Padrão de projeto de software, 1995. Disponível em: <http://pt.wikipedia.org/wiki/Padr%C3%A3o_de_projeto_de_software>, Acesso em:20 nov. 2009

HAWKINGS e ASTLE,2001: Kevin Hawkings, Dave Astle, OpenGL Game Programming, 2001

ICON,2006: ICON Games, Web Site, 2006. Disponível em: <http://www.icongames.com.br/>, Acesso em:10 dez. 2009

J2EE,2002: Oracle / Sun Microsystems, Core J2EE Patterns, 2002. Disponível em: <http://java.sun.com/blueprints/corej2eepatterns/Patterns/index.html>, Acesso em:20 nov. 2009

JOGOSPRO,2002: JogosPro, Lista JogosPro, 2002. Disponível em: <http://tech.groups.yahoo.com/group/jogospro/>, Acesso em:10 ago. 2010

LEITE,2010: Daniel Frederico Leite, Linkedin, 2010. Disponível em: <http://br.linkedin.com/pub/daniel-frederico-lins-leite/23/ab9/173>, Acesso em:11 ago. 2010

LIBWIISPRITE,2008: Wii Brew, libwiisprite is a C++ sprite library written for the Wii , 2008. Disponível em: <http://wiibrew.org/wiki/Libwiisprite>, Acesso em:10 dez. 2009

LIRA,2010: Felipe Lira, Linkedin, 2010. Disponível em: <http://br.linkedin.com/in/feliperlira>, Acesso em:10 ago. 2010

MAHTAB e WALI,2000: Ashic Mahtab; Zinat Wali, A Simple Fast Resource Manager using C++ and STL, 2000. Disponível em: <http://www.gamedev.net/reference/programming/features/resourceMngtCppStl>, Acesso em:10 mai. 2009

MARQUES,2010: Daniel de Albuquerque Marques, Currículo Lattes, 2010. Disponível em: <http://buscatextual.cnpq.br/buscatextual/visualizacv.jsp?id=K4209709D8>, Acesso em:11 ago. 2010

MENDES,2010: Karine Roberta Vieira Mendes, Facebook, 2010. Disponível em: <http://pt-br.facebook.com/profile.php?id=100000819386683>, Acesso em:11 ago. 201

MOREIRA,2010: Mike Moreira, Linkedin, 2010. Disponível em: <http://br.linkedin.com/in/mikemoreira>, Acesso em:10 ago. 2010

MORVICK,2008: Morbid Morvick, Resource Manager Snippet, 2008. Disponível em: <http://gpsnippets.blogspot.com/2008/07/resource-manager-snippet.html>, Acesso em:10 mai. 2009

PDJ,2003: PDJ, Programadores e Desenvolvedores de Jogos, 2003. Disponível em: <http://www.pdj.com.br>, Acesso em:10 ago. 2010

PENGUIN,2004: Icon Games, Penguin Racer, 2004. Disponível em: <http://www.icongames.com.br/pracer>, Acesso em:10 dez. 2009

POSA,1996: Frank Buschmann, Regine Meunier, Hans Rohnert, Peter Sommerlad, Michael Stal , Pattern-Oriented Software Architecture, 1996. Disponível em: <http://www.hillside.net/component/content/article/53-architecture-requirements-patterns-books/178-pattern-oriented-software-architecture-a-system-of-patterns?directory=127>, Acesso em:19 nov. 2009

RIBEIRO,2010: Alexandre Ribeiro de Sá, Perfil Linkedin, 2010. Disponível em: <http://br.linkedin.com/in/ardes>, Acesso em:10 ago. 2010

SANCHES,2009: Bruno Crivelari Sanches, Os softwares de um jogo, 2009. Disponível em: <http://www.pontov.com.br/site/index.php?view=article&id=108>, Acesso em:18 dez. 2009.

SDL,1999: Simple DirectMedia Layer, Web Site, 1999. Disponível em: <http://www.libsdl.org>, Acesso em:12 jun. 2009

SOUZA C.,2010: Cidcley Teixeira de Souza, Currículo Lattes, 2010. Disponível em: <http://buscatextual.cnpq.br/buscatextual/visualizacv.jsp?id=K4795182D7>, Acesso em:10 ago. 2010

SOUZA J.,2010: Jerffeson Teixeira de Souza, Currículo Lattes, 2010. Disponível em: <http://buscatextual.cnpq.br/buscatextual/visualizacv.jsp?id=K4794205D4>, Acesso em:10 ago. 2010

SPACESHOOTER,2005: DukItan Software & Games, SpaceShooter, 2005. Disponível em: <http://spaceshooter.dukitan.com>, Acesso em:12 mai. 2009

TECHFRONT,2009: TechFront – Play it Forward, Web Site, 2009. Disponível em: <http://www.techfront.com.br>, Acesso em:20 mai. 2009

TUGA,2008: DukItan Software & Games, TuGA Game API, 2008. Disponível em: <http://tuga-sdk.googlecode.com>, Acesso em:10 jun. 2009

UNIDEV,2002: Unidev, Programação de Jogos, 2002. Disponível em: <http://www.unidev.com.br>, Acesso em:10 ago. 2010

WIKIPEDIA,2010: Wikipédia, Duas Dimensões e Meia – 2.5D, 2010. Disponível em: <http://pt.wikipedia.org/wiki/2.5D>, Acesso em:04 ago. 2010

XNADC,2009: XNA Developer Center, Tutorial 4: Make a Game in 60 Minutes., 2009. Disponível em: <http://msdn.microsoft.com/en-us/library/bb975644.aspx>, Acesso em:10 out. 2009

 

set 292010
 

Durante o SugarLoafPlop2010[1] houve a palestra do prof. Jerffeson (UECE) falando sobre a iniciativa de criação de um repositório[2] de padrões. Em resumo foi apresentada a proposta do repositório de padrões para catalogação dos padrões  publicados nas conferências do SugarLoafPlop,  onde na verdade o repositório funcionará como um grande indexador de conteúdo para localização dos padrões por meio de diversas opções.

Abaixo podemos ver na integra o vídeo da apresentação do repositório ocorrido no dia 25/09/2010 durante o Sugar Loaf Plop 2010. Continue reading »

jun 122010
 
A coordenação do curso de Especialização em Engenharia de Software com Ênfase em Padrões de Software da UECE tem o prazer de convidá-lo para a Defesa de Monografia do aluno David de Almeida Ferreira, intitulada “Catálogo de Padrões para Jogos”. A defesa ocorrerá no dia 14/06/2010 (segunda-feira) a partir das 16:00 no prédio da Pós-graduação e Pesquisa em Computação da UECE. Continue reading »
fev 072009
 

Blz!

Mais uma vez, tentando retornar do mundo offline,  hoje foi adicionada a nova versão do BoUML[1], e como de costume, gerei mais um pacote da mesma para o slackware 12.2, a qual inclusive já encontra-se disponível no site oficial 😉

BoUML é uma ferramenta de Modelagem UML livre (Software Livre) disponibilizada para MacOS, MS-Windows e Linux (em diversas distribuições).

Referências:

  1. http://bouml.free.fr
  2. http://bouml.dukitan.com
  3. http://fztech.dukitan.com/?tag=bouml
jan 122009
 

Blz!

Depois de muito tempo offline, estou retornando (aos poucos), para inicio, ontem foi adicianda a nova versão do BoUML[1], e como de costume, gerei mais um pacote da mesma para o slackware 12.2, a qual inclusive já encontra-se disponivel no site oficial 😉

BoUML é uma ferramenta de Modelagem UML livre (Software Livre) disponibilizada para MacOS, MS-Windows e Linux (em diversas distribuições).

Referências:

  1. http://bouml.free.fr
  2. http://bouml.dukitan.com
  3. http://fztech.dukitan.com/?tag=bouml
nov 162008
 

Blz! To meio off (doente, com dor de cabeça, febre e etc)

Mas consegui terminar de compilar e disponibilizar o BoUML[1] 4.8.3 para Slackware (12.1) na verdade acabou de ser lançado, ontem eu havia compilado a versão 4.8.2 e quando vou coloca-la no ar, sai a 4.8.3 :\, bem pelo menos deu tempo de colocar a mais atual, saindo do forno sendo uma das primeiras distros a ter a nova versão 😉

BoUML é uma ferramenta de Modelagem UML livre (Software Livre) disponibilizada para MacOS, MS-Windows e Linux (em diversas distribuições).

Observação:
Pode levar alguns dias/horas para que apareça no site do projeto 😉

Referências

  1. http://bouml.free.fr
  2. http://bouml.free.fr/download.html
  3. http://fztech.dukitan.com/?tag=bouml
  4. http://bouml.free.fr/download.html#Slackware
  5. http://downloads.sourceforge.net/pjmoo/bouml-4.8.3-i686-1FZ.tgz
jan 102008
 

Blz!

Estou trabalhando em algumas coisas bem interessantes 😉
Só para dar um gostinho do que pode vim por ai, vejam:

Assim que tiver mais experiência neste novo ambiente, faço alguns relatos 😉

T+!
Vida Longa e Próspera!

———————————————-

Referência
[1]http://www.youtube.com/watch?v=bpaQ0Q_ifs8
[2]http://www.youtube.com/watch?v=By5-NAdvgDI

dez 052007
 
Blz!
Dando continuidade aos post do “GoF[1]”, estou agora publicando o exemplo utilizando o padrão “Abstract Factory[2]”.

Observando o exemplo Abaixo (Veja exemplo anterior[3])

Podemos observar que o modelo proposto tem apenas quatro classes básicas (Verde Claro), e toda a criação do labirinto é feita pela classe “MazeGame”.
O padrão Abstract Factory, permite a criação de uma família de objetos relacionados sem especificar suas classes concretas, ou seja:
Vai definir uma classe base de uma fábrica, que possui os métodos de criação de um conjunto de objetos, os quais são baseados em um ponto genérico(classe base), onde permite assim que tanto a fábrica quanto os objetos a serem construídos sejam de classe que estendam a família de classe raíz.

Observando o diagrama de classe acima, podemos notar que:

  • Foi definida como fábrica base a classe “MazeFactory“, a qual define métodos para criação dos tipos básicos “Room“,”Door“,”Wall“;
  • Foi criada a classe “BombedWall” que estende a classe “Wall“;
  • Foi criada a classe “EnchantedDoor” que estende a classe “Door“;
  • Foram criadas as classe “RoomWithABomb” e “EnchantedRoom” que estendem a classe “Room“;
  • Foram criadas duas fábricas que estendem a classe “MazeFactory“, sendo elas “BombedMazeFactory” e “EnchantedMazeFactory“;
Como podemos observar a classe fábrica base é capaz de construir as peças básicas do labirinto, já a classe fábrica “BombedMazeFactory” é capaz de construir tudo que a classe “MazeFactory” faz, além de pela sobrecarga produzir objetos do tipo “RoomWithABomb” (subclasse de “Room“) e “BombedWall” (subclasse de “Wall“).
Onde para que o usuário desta classe consiga construir labirintos de um dos três tipos “Básicos”, “ComBomba” ou “Encantado” basta ele passar para a classe “MazeGame” um objeto do tipo de fábrica desejado, como podemos ver no exemplo abaixo:

// MazeFactory factory;
// EnchantedMazeFactory factory;
BombedMazeFactory factory;

Maze * aMaze = mazeGame.create(factory);

“Mudando apenas a instância da factory produzimos o que desejamos.”
Por final o resultado produzido é o apresentado na figura abaixo:


A melhor forma de entender os padrões é conhecendo sua finalidade e motivação, além de ver sua implementação, então não se esqueça de baixar o código deste exemplo e consultar os links de referência no final deste post.

Download[4]: http://downloads.sourceforge.net/pjmoo/GoF_AbstractFactory.zip

T+!
Vida Longa e Próspera!

———————————————-

Referência
[1]http://pt.wikipedia.org/wiki/Design_Patterns
[2]http://pt.wikipedia.org/wiki/Abstract_Factory
[3]http://davidferreira-fz.blogspot.com/2007/11/gof-exemplos.html
[4]http://downloads.sourceforge.net/pjmoo/GoF_AbstractFactory.zip
[5]http://pjmoo.wiki.sourceforge.net/GoF

nov 232007
 

Blz!

Na especialização estou começando a disciplina de padrões, e como ficou acertado que para prova o livro base é nada mais nada menos que o do GoF(Padrões de Projeto)[1], então resolvi estudar de uma forma diferente.
Irei implementar os padrões tendo como base o primeiro exemplo apresentado (o labirinto), para isso tive que fazer algumas adaptações nas classes básicas e incluir alguns recursos do framework GBF[2], sendo assim além de apresentar para vocês a implementação dos padrões de quebra ainda vai a utilização do framework GBF[2].
Antes de começar a publicar os padrões, resolvi montar um exemplo base, para termos idéia de como era a implementação inicial e como ela irá evoluir com o uso dos padrões.

Sendo assim pretendo na medida do possível publicar padrão por padrão.

Lembre-se para poder melhor aproveitar o exemplo você necessita:

  1. IDE:
    1. CodeBlocks[3] (Linux e MS-Windows)
  2. Compilador
    1. Linux: GCC
    2. MS-Windows: MinGW[4]
  3. Modelagem UML
    1. BoUML[5]
  4. Bibliotecas:
    1. SDL (SDL_Image, SDL_Mixer)[6];
    2. GBF;
  5. Programar em C++
  6. Exemplo:
    1. Baixe no SourceForge[7]

Podemos observar abaixo o diagrama de classes do exemplo

  • Classes Cinzas: São do Framework GBF[2];
  • Classes Verdes: É o núcleo principal do exemplo, são as classes que dão suporte para implementação de salas, paredes e portas;
  • Classe Vermelha: É a enumeração usada para definir os lados da sala;
  • Classe Laranja: É a responsável por armazenar o labirinto;
  • Classe Amarela: É a classe que monta o labirinto;
A seguir podemos ver as classe da visão de dependência, ou seja, como é o relacionamento de fato com relação aos includes (headers) e a classe que vai executar nosso exemplo:
Essas classes seguem o mesmo código da legenda anterior, a única modificação é a inclusão da Classe Rosa, que contém o método “int main” para executar nosso exemplo.
Pois é, podemos criar uma classe que irá gerar o método main ;), digamos assim quase imitando o principio do método main da linguagem em java 😉

Abaixo podemos ver o resultado da execução do nosso exemplo:

T+!
Vida Longa e Próspera!

———————————————-

Referência
[1]http://pt.wikipedia.org/wiki/Padr%C3%B5es_de_projeto_de_software
[2]http://pjmoo.wiki.sourceforge.net/GBF
[3]http://www.codeblocks.org
[4]http://www.mingw.org/
[5]http://bouml.free.fr
[6]http://www.libsdl.org
[7]http://downloads.sourceforge.net/pjmoo/GoF.zip

nov 172007
 

Blz!

Estava estes dias revisando alguns conceitos no framework GBF[1], quando lembrei que no SpaceShooter[2] tive a necessidade de determinar em runtime de que tipo de classe pertencia um dado objeto, na época resolvi com algo muito simples, criei um método chamado “getType()” que retornava um valor de uma enum (enumeração). Porém esta solução não é genérica o bastante para poder ser reutilizada, e com alguns recursos que estou planejando implementar no framework GBF, começo a ter a necessidade de poder fazer questionamentos em runtime.
Para isso o c++ tem o que chamamos de RTTI (Run-Time Type Identification) que fornece algumas poucas opções – não se compara as capacidades reflexivas que o Java possui, nessa hora que sinto falta do java – uma delas eh por meio do dynamic_cast onde ele funciona da seguinte forma:

TipoClasse * tc = dynamic_cast(objeto)

Onde em caso de erro, ou seja do objeto não pertencer a hierarquia da classe “TipoClasse” ele retorna NULL, caso contrario um ponteiro válido para o objeto do “TipoClasse”.
Resolvi então encapsular o dynamic_cast em um recurso como o “instanceOf” do Java, para isso tive que utilizar templates(generics).

Antes de vermos o código, observemos o diagrama de classes abaixo:

Observemos a classe “ObjetoBase” ela implementa as possibilidades de uso do método “isInstance”, ou seja, funcionará assim, tendo uma instância de uma classe perguntaremos a ela se pertence a um certo tipo de classe ou se é do mesmo tipo de um outro objeto.

Abaixo podemos ver a utilização do código:

Podemos destacar alguns pontos interessantes:

Se você possui um objeto e quer saber se ele pertence a uma dada classe e não possui nenhuma instância da mesma você pode fazer como na linha 30 do código.

Exemplo 1:
sprite.isInstance <Sprite> ();

Essa construção pode parecer estranha mas é comum devido o uso de templates, outras opções são caso você possua uma instância qualquer da classe ou queira cria-la, como nas linhas 42 e 46 respectivamente.

Exemplo 2:
spritePersonagem2->isInstance(new SpritePersonagem());

spriteManager->isInstance(ObjetoManager());

Porém lembramos que estes casos necessitam de um construtor público e que uma nova instância da classe será criada, o que nem sempre é possível ou de bom agrado, por isso quando não for possível instanciar ou ter um objeto da classe utilize o primeiro exemplo.

Agora poderemos ver como de fato é feita esta implementação, observemos a figura/código abaixo:


Podemos observar que a solução é bastante simples e que o código apresentado atende a:

  1. Questionar se um objeto pertence a uma determinada classe;
  2. Questionar se um objeto pertence a mesma classe de um outro objeto;
  3. Questionar se um objeto pertence a mesma classe de um outro objeto por meio de referências;

Espero que quem tenha essas necessidades possa fazer bom uso dessas informações, e lembro que ainda é possível outras implementações, dentre as quais uma que me agradou bastante foi implementar template de funções, aparentemente ficou mais legível, porém não estaria encapsulada em uma hierarquia de classes.

Não esqueça de baixar o souce[3].

T+!
Vida Longa e Próspera!

———————————————-

Referência
[1]http://pjmoo.wiki.sourceforge.net/GBF
[2]http://pjmoo.wiki.sourceforge.net/SpaceShooter
[3]http://downloads.sourceforge.net/pjmoo/ObjetoBase.zip
[4]http://www.codeblocks.org
[5]http://bouml.free.fr