out 312007
 

Blz!

Outro dia na especialização[1], disciplina de Análise e Projeto de Software Orientado a Objetos (Prof. Araújo[2]), o professor mostrou um slide que falava de herança múltipla, e apesar de programar em c++ e já ter utilizado este recurso algumas vezes, surgiram dúvidas que eu não sabia responder e nem tinha idéia do que de fato aconteceria.

Para testar as idéias, modelei o diagrama abaixo na ferramenta BoUML[3]:

A idéia, era basicamente:
Tenho uma superclasse(Veiculo), que possui atributo(cor) e métodos, e uma linha de subclasses(Terrestre e Aquatico), que no caso vão implementar um método abstrato (imprimir) onde tal método consulta o atributo cor e vai dizer qual a cor de fato.
E utilizando o recurso da herança múltipla tenho a classe “Anfibio” que herda de “Terrestre” e “Aquatico” nesta ordem, pelo que vi isso influência na chamada do construtor das superclasses.

Logo abaixo temos o projeto na ide CodeBlocks[4]


Onde abaixo teremos o conteúdo da função main:

1-Neste bloco podemos ver que foi instanciado um objeto da classe “Anfibio”, porém ele será tratado como um objeto da classe “Terrestre”.

std::cout << “Terrestre * anfiTerrestre = new Anfibio();” <<std::endl;
Terrestre * anfiTerrestre = new Anfibio();
anfiTerrestre->imprimir();
delete(anfiTerrestre);

2-Neste bloco podemos ver que foi instanciado um objeto da classe “Anfibio”, porém ele será tratado como um objeto da classe “Aquatico”.

std::cout << “Aquatico * anfiAquatico = new Anfibio();” << std::endl;
Aquatico * anfiAquatico = new Anfibio();
anfiAquatico->imprimir();
delete(anfiAquatico);

3-Neste bloco podemos ver que foi instanciado um objeto da classe “Anfibio”, porém ele será tratado como um objeto da classe “Anfibio”.

std::cout << “Anfibio * anfibio = new Anfibio();” << std::endl;
Anfibio * anfibio = new Anfibio();
anfibio->Terrestre::imprimir();
delete(anfibio);

Como resultado da execução podemos observa a imagem abaixo:

Agora os fatos:

No caso “1”, a classe foi tratada pelo compilador como se houvesse herança apenas da classe “Terrestre”, onde inclusive pegou o valor que foi configurado no construtor da classe “Terrestre”.
No caso “2”, houve o mesmo tratamento do item “1”, porém foi para a classe “Aquatico”.
No caso “3”, parece existir na memoria da classe de forma separada os dois atributos “cor” um da superclasse “Terrestre” e o outro da “Aquatico”, e para que seja compilado deve-se informar em tempo de desenvolvimento qual atributo deve ser referenciado, para isso temos que usar a resolução de escopo, por exemplo:

Terrestre::cor

Quer dizer que quero usar o atributo cor definido no espaço de memória da classe “Terrestre”, o mesmo é válido no caso de métodos, que foi o caso do “imprimir” onde a classe “Anfibio” criou o método “imprimirNovo()”, apenas para validar a idéia, sua implementação pode ser vista abaixo:

void Anfibio::imprimirNovo()
{
std::cout << “\timprimirNovo()” << std::endl;
Aquatico::imprimir();
Terrestre::imprimir();
}

O que posso observar é que se tivermos que trabalhar com herança múltipla de uma mesma familia de classe podemos ter alguns problemas, mas que são facilmente contornados utilizando a resolução global, pelo menos no caso do compilador GCC, ele não permite compilarmos se houver algum problema de resolução, como no seguinte caso:

Anfibio * anfibio = new Anfibio();
anfibio->imprimir();

Qual imprimir deve ser chamado? afinal a classe “Anfibio” não implementou o método imprimir, o qual existe nas suas duas superclasses.

O compilador nos obriga a fazer essa construção, que pode parecer “feia” ou “estranha”, mas resolve o problema 😉

Anfibio * anfibio = new Anfibio();
anfibio->Terrestre::imprimir();

Ou seja, novamente o nosso amigo “::” (operador de resolução) entra em cena para facilitar a vida do compilador e a nossa.
Com isso eu tenho em mente que pode dá trabalho programar com herança múltipla, porém não é esse bicho de sete cabeças que ouvimos dos nossos amigos(que trabalham com linguagens que não suportam este recurso).

Trabalho com Java e já me acostumei com o uso de “Interface”, apesar de achar que algumas vezes um herança múltipla seria de grande ajuda 😉

T+!
Vida Longa e Próspera!

Observação:
Quem se interessar pode entrar em contato que mando os arquivos de projeto (bouml e codeblocks) para compilarem e brincarem a vontade. (Infelizmente não da pra fazer upload pro blog.)

Observação2:
Passei! Valeu pelo apoio dos amigos que me incentivaram a fazer a prova final da disciplina (no lugar do trabalho) 😉
Melhor nota impossível “10”, agora realmente tem nem como fazer o trabalho pra melhorar a média 😉

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

Referência
[1] http://www.pgcomp.uece.br/index.php?option=com_content&task=section&id=6
[2] http://www.secrel.com.br/araujo
[3] http://bouml.free.fr
[4] http://www.codeblocks.org

out 242007
 

Blz!

Como lancei outro dia o pacote do BoUML para slackware e sempre que vou gerar um novo pacote apanho feito doido, resolvi documentar de forma bem simples os passos que utilizei para o empacotamento.

Sendo assim eles são:

  1. Ir no site do BoUML em http://bouml.free.fr
  2. Baixe o código fonte para linux, algo como “bouml_3.1.tar.gz”
  3. Descompacte o arquivo:

    • tar xvzf bouml_3.1.tar.gz
  4. Entre no diretório criado:
    • cd bouml_3.1
  5. Obtenha acesso como “root”:
    • su
  6. Execute o comando:
    • make
  7. Após a compilação, execute o comando:
    • checkinstall
  8. Preencha com as informações solicitadas. (Ver Figura 1)
  9. Copie o arquivo para um outro diretório:
    • cp bouml-3.1-i386-1FZ.tgz /opt/raiz
  10. Entre no diretório para o qual o arquivo foi copiado:
    • cd /opt/raiz
  11. Execute o comando:
    • explodepkg bouml-3.1-i386-1FZ.tgz
  12. Delete o pacote:
    • rm bouml-3.1-i386-1FZ.tgz
  13. Entre no diretório install:
    • cd /opt/raiz/install
  14. Edite o arquivo “slack-desc”:
    • vim slack-desc (Veja Figura 2)
  15. Retorne para o diretório anterior:
    • cd ..
  16. Execute o comando para empacotar:
    • makepkg bouml-3.1-i386-1FZ.tgz
  17. Responsa “Sim” para a pergunta feita: y
  18. Pronto, um novo arquivo “bouml-3.1-i386-1FZ.tgz”, será criado e estará pronto para o uso em seu slack.
Figuras Anexas

Figura 1: Tela do checkinstall.

Figura 2: Vim com edição da descrição do pacote.

T+!
Vida Longa e Próspera!

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

Referência
[1] http://davidferreira-fz.blogspot.com/2007/10/bouml-31-para-slackware.html
[2] http://bouml.free.fr
[3] http://pjmoo.wiki.sourceforge.net/BoUML

out 212007
 

Blz!

Faz tempo que não posto nada, então aproveitando a atualização que comecei a fazer no meu ambiente de desenvolvimento, começando pela ferramenta de modelagem UML, chamada “BoUML”, resolvi: compilar, empacotar e disponibilizar mais uma versão da ferramenta de modelagem UML “BoUML”.

O Download está agora disponível no meu novo endereço do projeto PJMOO, em:

Para aqueles que não conhecem o BoUML, irei rápidamente fazer alguns apontamentos:

  • é uma ferramenta livre (Software Livre)
  • disponível para MS-Windows, GNU/Linux(Binários para várias distribuições), Mac.
  • suporta diversas linguagens como: Java, C++, Php
  • customização na geração do código fonte;
  • engenharia reversa (código fonte para o modelo);
  • é possível fazer os principais diagramas da UML
    • Diagrama de Classe;
    • Diagrama de Seqüencia;
    • Diagrama de Caso de Uso com especificação;
    • Diagrama de Colaboração;
    • Diagrama de Objetos;
    • Diagrama de Atividade;
    • Diagrama de Estado;
  • geração de documentação;

E outras características, um ponto que me chamou bastante atenção e fez com que o uso foi o grande suporte a linguagem C++, suportando toda(ou quase toda) suas particularidades como “enum”, “typedefs”, “struct”, “friend” e os tipos STL.

Outro recurso é que você é capaz de controlar a geração do que você modela, por exemplo diversas classes podem ser geradas no mesmo arquivo de header ou você pode informar que não deve ser gerado nenhum arquivo e sim apenas executar o include de algo já definido, como por exemplo quando você usa bibliotecas de terceiros, como no meu caso a SDL.

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

Referência
[1]http://bouml.free.fr
[2]http://pjmoo.wiki.sourceforge.net
[3]http://bouml.free.fr/screenshots.html
[4]http://sourceforge.net/project/showfiles.php?group_id=198186&package_id=249669&release_id=548582

set 172007
 

Blz!

Dando continuidade ao desenvolvimento da interface gráfica para as mensagens no Pancada[1], consegui um novo rascunho de classes as quais possuem uma abstração mediana, visto que resolvi especializar conforme a demanda, para não adicionar tantas classes no framework GBF[2] que acabem não sendo uteis, apresento abaixo o resultado das novas classes de interface gráfica e um pequeno exemplo do que mudou na forma de se fazer as “caixas de mensagens”, as quais são bem simples porém era chato de fazer.
//Criando um padrão visual com janela transparente - segue o pattern Prototype (GoF)
UserInterfaceVisualImagem *uiVisualImagem = new UserInterfaceVisualImagem();
uiVisualImagem->setCorBorda(255,0,0);

//ou caso seja o desejo utilizar uma janela de cor solida (fundo de uma única cor)
//sendo necessário apenas passar para o método "setVisual".
UserInterfaceVisualSolido * uiVisualSolido = new UserInterfaceVisualSolido();
uiVisualSolido->setCorBorda(255,0,0);
uiVisualSolido->setCorFundo(100,200,100);

UserInterfaceWindowTitulo *janelaAjuda;
janelaAjuda = new UserInterfaceWindowTitulo();
janelaAjuda->setPosicao(40,50);
janelaAjuda->setDimensao(560,400);
janelaAjuda->texto.setFonte("texto");
janelaAjuda->texto.setChaveTexto("tela_ajuda_%02d");
janelaAjuda->titulo.setFonte("menu");
janelaAjuda->titulo.setChaveTexto("titulo_ajuda");
janelaAjuda->setVisual(uiVisualImagem->clone());
janelaAjuda->adicionarBotao(new UserInterfaceBotao("menu","botao_enter",SDLK_RETURN));
janelaAjuda->inicializar();

Onde o uso da janela criada se da da seguinte forma:

void Jogo::menuAjuda()
{
    FrameLayerManager::getInstance()->getFrameLayer("background")->desenhar();

    janelaAjuda->executar();

    if (janelaAjuda->isBotao(UserInterfaceWindow::BOTAO_OK)){
        setMenuPrincipal();
    }
}

Para efeito de comparação logo abaixo um exemplo de como era criada a tela do menu ajuda:

void Jogo::menuAjuda()
{
    char textoFormatado[30];
    FrameLayerManager::getInstance()->getFrameLayer("background")->desenhar();

    for (int i=0; i>;11;i++){
        writeSystem->escreverLocalizado("texto",70,120+(26*i),textoFormatado);
    }

    frameworkGBF->writeSystem->escreverLocalizado("menu", 220, 88,"titulo_ajuda");

    if (desenharBotaoEnter()){
        if ((frameworkGBF->inputSystem->teclado->isKey(SDLK_RETURN))
        || (frameworkGBF->inputSystem->joystick->isButtonA())){
            setMenuPrincipal();
        }
    }
}

Logo abaixo:

  • Janela com fundo transparente
  • Janela com Fundo em cor Sólida

E para matar a curiosidade o novo rascunho do diagrama de classes “ainda não integrante do GBF” pode ser visto abaixo:

T+!
Vida Longa e Próspera!

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

Referência
[1]http://pjmoo.wiki.sourceforge.net/Pancada
[2]http://pjmoo.wiki.sourceforge.net/GBF

set 092007
 

Blz!
Faz um bom tempo que não publico nenhuma novidade sobre meus projetos, porém isso não significa que eles estão parados, muito pelo contrario, é tanta coisa pra fazer que não está sobrando tempo pra ficar atualizando.

Tem algumas semanas que voltei a trabalhar no Pancada (assim que possível publico alguma coisa sobre ele), e comecei a ter a velha dificuldade de montar aquelas telas (créditos, ajuda, sobre, final de fase, gameover e etc), então resolvi criar vergonha na cara e comecei a rascunhar componentes que facilitassem minha vida para montar uma espécie de caixa de texto, que nada mais é do que exibir um texto na tela.

Abaixo é possível ver o modelo uml (rascunho) do que vai se torna parte integrante do GBF, porém, só passa de fato para o framework após validação inicial com um projeto, o que deve acontecer nos próximos dias (ou semanas) ai então irá compor o framework e servir de base para um refatoramento das classes de interface Gráfica ou seja classes da série “UserInterface” do GBF.

T+!
Vida Longa e Próspera!

maio 302007
 

Blz!

Estou novamente voltando as atividades com o projeto PJMOO[1], e o mesmo me gerou duas necessidades especificas, as quais foram preparar as ferramentas para que eu pudesse voltar a programar o GBF[2] e os projetos, no caso o AeroTarget[3], sendo assim vou comentar rapidamente sobre cada uma das ferramentas.

CodeBlocks

CodeBlocks[7], é uma IDE livre (Software Livre) para Linux e Windows, na postagem anterior (CodeBlocks Slackware[4]), comentei no final sobre o pacote não estar instalando a ferramenta no local que deveria ser padrão ou seja, ele instala a ferramenta com base na raíz de diretório “/usr/local”, e pouco depois me avisaram que deveria considerar de fato a raíz do sistema “/”.

Sendo assim, consegui recompilar a IDE passando os parâmetros corretos para que a instalação siga os padrões dos pacotes slackware, abaixo disponibilizo o link para o novo pacote:

http://codigolivre.org.br/frs/download.php/5846/codeblocks-rev_4000-i686-9FZ.tgz

BoUML

BoUML[8], é uma ferramenta livre (Software Livre) para modelagem UML, é multiplataforma e tem uma boa integração com os recursos da Linguagem C++.

Como parece ser de costume, também não tem um pacote oficial para Slackware, e seguindo os moldes do pacote que criei para o CodeBlocks[7], compilei e empacotei dois pacotes sendo eles:
Onde acredito que o primeiro possa ser usado em qualquer sistema linux, pois é apenas um arquivo compacto, e o segundo é de fato um pacote para Slackware, só que desta vez está instalando a ferramenta no local certo 😉

T+!
Vida Longa e Próspera!

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

Referência
[1] http://pjmoo.codigolivre.org.br/wiki/
[2] http://pjmoo.codigolivre.org.br/wiki/index.php/GBF
[3] http://code.google.com/p/pjmoo-aerotarget
[4] http://davidferreira-fz.blogspot.com/2007/05/codeblocks-slackware.html
[5] http://codigolivre.org.br/frs/download.php/5849/bouml-2.27-i686-3FZ.tgz
[6] http://codigolivre.org.br/frs/download.php/5850/bouml-2.27-i686-FZ.tar.gz
[7] http://pjmoo.codigolivre.org.br/wiki/index.php/CodeBlocks
[8] http://pjmoo.codigolivre.org.br/wiki/index.php/BoUML

maio 282007
 

Para quem não sabe CodeBlocks[1] é uma IDE para C e C++ multiplataforma, disponível para MS-Windows e Linux.
Vale a pena uma pequena observação, apesar da IDE estar aparentemente congelada no tempo, pois o último release oficial foi em 2005, isso não quer dizer que a ferramenta esteja estagnada, muito pelo contrario nesse final de semana a revisão no controle de versão do projeto chegou na incrível marca de 4000 (quatro mil), isso mesmo quatro mil revisões num projeto, podemos concluír então que é um projeto que está em pleno vapor.
Quanto aos releases oficiais, estes foram congelados para que a equipe de desenvolvimento pudesse arrumar algumas coisas internas da ferramenta, e acredito que em breve devem lançar não mais a versão 1, e sim provavelmente a versão 2.0 ou maior pois houve muitas mudanças tanto internas quanto externas da ferramenta.
Só pra ressaltar a equipe lança quase que diariamente um build noturno[2], ou seja, todo dia ao final do trabalho, se o código estiver estável (compilavel) eles geram algumas versões do programa para o pessoal poder baixar.
No meu caso utilizo o CodeBlocks para desenvolver meus jogos, e para isso gosto de contar com a versão mais recente possível das ferramentas, sendo assim, acabo tendo que pegar o código do svn e compilar, principalmente para meu linux, pois não há builds noturnos para o Slackware.
E como esse final de semana estive atualizando meu slackware 11.0 para o current (11.1) e tive que recompilar algumas coisas, e mexendo na Internet acabei aprendendo a criar pacotes para o Slack, então agora eu disponibilizo para a Comunidade o CodeBlocks-by-FZ[3]

Arquivo Genérico (Acredito que possa ser usado em qualquer GNU/Linux)
http://codigolivre.org.br/frs/download.php/5830/codeblocks-rev_4000-i686-FZ.tar.gz

Pacote para Slackware 11.0
http://codigolivre.org.br/frs/download.php/5829/codeblocks-rev_4000-i686-6FZ.tgz

Nota:

Até o próximo final de semana devo lançar um novo pacote, enquanto isso, fiquem avisados!

O pacote para slackware instala o codeblocks com base em “/usr/local/”, por alguns problemas de tempo, não pude corrigir a instalação para que fique no local correto que seria em “/usr/”, porém não creio que seja algo que deva gerar impedimento para utilizar este pacote, basta um simples “upgradepkg” para que o problema da localização anterior seja corrigido.

T+!
Vida Longa e Próspera!

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

Referência
[1] CodeBlocks – http://www.codeblocks.org
[2] Build Noturno – http://forums.codeblocks.org/index.php?board=20.0
[3] CodeBlocks-by-FZ – http://pjmoo.codigolivre.org.br/wiki/index.php/CodeBlocks

maio 222007
 
Estava conversando com um amigo sobre desenvolvimento de jogos, quando lembrei do bom e velho SpaceShooter, e o quão ficou “abafado” com o lançamento e a oficialização da última versão a 1.4 por causa causa do CDLivre[4] e do evento FLISOL.
Pois bem, aproveito a oportunidade agora para falar um pouco mais da experiência que o SpaceShooter me deu, além da diversão gerada tanto pela programação como pelo jogo em si.

História

Spaceshooter pra quem não conhece, é um divisor de águas para mim, ele inaugurou minha “nova geração” de jogos, agora produzidos com o framework GBF[5]. É um jogo simples e fácil no clássico estilo shoot’up, o qual foi muito venerado na época dos consoles Nes/SNes/Mega, tendo como base a temática de Star Trek.
O jogador tem como objetivo salvar seu planeta da extinção, e para isso deverá destruir a grande ameaça a nave Base Borg (Cubo Borg). Para poder enfrentar este desafio, o jogador contará com 04 naves estrelares, onde cada uma está melhor adaptada para as diversas zonas, além de contar com um arsenal de phaser e de alguns poucos torpedos. Para sua defesa deverá contar com sua habilidade, a velocidade dos motores de warp, além da força de seus escudos.
O jogo possui 07 fases, onde o jogador terá que enfrentar campos de asteróides, naves inimigas de várias raças, minas espaciais, e diversos outros desafios. Sua missão é destruir a ameaça cibernética, evitando assim que a extinção da raça humana.


Ficha Técnica

Aprendizado

O SpaceShooter, acabou sendo pra mim um grande laboratório, foram creio que quase 2 anos de desenvolvido, mas isso não quer dizer que o SpaceShooter é um jogo complexo ou que foi difícil de ser criado, muito pelo contrario, graças a sua simplicidade consegui superar tantas mudanças, sendo elas:
IDE, o inicio do SpaceShooter, se confundi que o inicio do framework GBF, os dois praticamente foram criados juntos, e se auto influenciaram, passei por muitas IDE, desde proprietárias a diversas soluções livres, só para ter uma idéia nesse projeto trabalhei com:
E minha opção em busca da unificação dos mundos foi o CodeBlocks, onde de fato consegui criar um projeto e utiliza-lo tanto no Linux quanto no MS-Windows, pois as outras IDEs, mesmo as que tinham versões para os dois S.O me obrigavam a criar projetos para cada S.O.
Sistema Operacional, o inicio do meu projeto se deu com MS Windows, e o Linux era utilizado apenas para compilação, e conforme fui me envolvendo com o Software Livre, pude conhecer mais a fundo o Linux e as ferramentas que eu poderia utilizar, graças a utilização de uma IDE completa para os dois mundos, pude inverter minha situação e ter como meu ambiente de trabalho e de uso domestico o Linux e ter o MS Windows apenas para compilação e testes, creio que graças as características do projeto consegui fazer essa migração de SO sem muitos problemas, porém tive que me adaptar as diversas rotinas que o Linux começava a me apresentar, pois eu queria de fato retirar o máximo possível das características do meu hardware e isso envolveu tempo e estudo, porém hoje estou satisfeito utilizando Linux em casa (Slackware 11.0 e comecei a testar o Ubuntu).

Uma coisa que pude constatar, ambiente mais robusto que o Linux e suas ferramentas não creio que tenha, era comum quando tentava depurar alguma coisa no MS Windows ter problemas ou a aplicação abortar, debugar jogos é complicado, e mesmo usando profilers ou qualquer outra ferramenta que tente ajudar a entender como o programa funciona no MS Windows a coisa ficava sempre muito complicada. Sem falar que se consegui compilar e rodar no Linux sem problema a chance de compilar e funcionar no MS Windows é alta, agora o contrario é complicado.

UML, comecei o projeto do GBF com o Power Designer, uma ferramenta proprietária de modelagem UML e de banco de dados, porém era complicado manter o código sincronizado, pois era necessário codificar dentro da ferramenta o corpo dos métodos, e não era fácil e pior que o suporte a estruturas do C++ não era muito bom (enumerações, structs, typedef), fiquei algum tempo utilizando ela, até que ficou inviável manter o projeto codificando e testando e copiando as implementações para a ferramenta, a engenharia reversa não funciona (ou se funcionava era uma porcaria, faz tanto tempo que não lembro), acabou tendo um lacuna muito grande entre os últimos modelos e o código implementado.
Achei que era hora de procurar outras ferramentas, achei uma chamada jumli[12], era uma ferramenta freeware e tinha versões para Linux e Ms Windows, era melhor que o Power Designer, porém possuía alguma limitação que não me recordo muito bem, sei que não me atendia como eu gostaria, creio que tinha algo relacionado com enumerações ou struct, e mais uma vez cai numa lacuna de tempo entre modelo e implementação monstruosa.

Por fim, consegui achar uma ferramenta francesa chamada BoUML, a qual gostei muito, era leve, prática e muito eficiente, atendia quase que perfeitamente minhas necessidades, sem falar que o desenvolver era muito acessível, troquei algumas mensagens no fórum com ele, e minhas dificuldades foram resolvidas, e chegou até ser implementado uma das minha solicitações que era referente aos includes de outras classes ficarem apenas no header(.h) e não no arquivo fonte (cpp), para isso foi criado uma marcação especial que definia isso, ou seja, é uma ferramenta que recomendo, sem falar que com ela é possível mesclar várias coisas comuns em C++ para produzirem a saída conforme eu queria, no caso jogar vários enums, structs num único arquivo, bastava apenas na parte de deploy informar o “artefato de destino”.

Hoje o modelo do SpaceShooter e do GBF estão mais próximos da implementação porém não posso garantir a fidelidade do modelo do SpaceShooter, porém pretendo nas próximas semanas atualizar e finalizar de vez o projeto.

Técnicas, além de tudo isso tive oportunidades de criar novos mecanismos pro framework GBF, além de desenvolver e aprender novas técnicas, das quais posso destacar:

  • Classes para gerenciadores de recursos: Audio, Imagens, Teclado, Joystick;
  • Classes para interface: Menus, Teclado Virtual (aqueles usados nos jogos de consoles)
  • Classes para efeitos especiais como sistema de partículas;
  • Classes para Sprite, Layers, Personagens;
  • Utilização de Sockets via SDL_net para envio e recebimento de dados com um servidor (na verdade uma página em php que tem acesso a um banco MySQL)
  • Utilização de designer patterns para criação do GBF e do SpaceShooter;
Após dois anos de intenso trabalho, ou quase, pois tive muitos períodos que não encostava em nenhuma linha de código desses projetos, consegui concluir este ano o SpaceShooter e entrega-lo para a comunidade, liberando seu source e agora, passando um pouco da experiência vivenciada com o seu desenvolvimento. Espero que esse relato possa ajudar ou direcionar os interessados em conhecer um pouco mais sobre desenvolvimento de jogos.

T+!
Vida Longa e Próspera!

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

Referência
[1] PJMOO no Código Livre – http://codigolivre.org.br/projects/pjmoo/
[2] Site SpaceShooter – http://pjmoo.codigolivre.org.br/site/spaceshooter/
[3] Wiki SpaceShooter – http://pjmoo.codigolivre.org.br/wiki/index.php/SpaceShooter
[4] CDLivre – http://cdlivre.codigolivre.org.br
[5] Framework GBF – http://pjmoo.codigolivre.org.br/wiki/index.php/GBF
[6] SDL – http://www.libsdl.org
[7] CodeBlocks – http://www.codeblocks.org
[8] BoUML – http://bouml.free.fr
[9] DevCPP – http://www.bloodshed.net/devcpp.html
[10] Eclipse CDT – http://www.eclipse.org/cdt
[11] KDevelop – http://www.kdevelop.org
[12] Jumli – http://www.jumli.de