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.

Todos os interessados estão convidados para estarem presentes na ocasião.

Atenciosamente,

A Coordenação

É amigos, agora finalmente estarei dando mais um passo para a conclusão da minha primeira pós graduação, quem tiver o interesse de participar fique a vontade, as restrições que existem são devido a formalidades tradicionais, como por exemplo duração máxima de 30 minutos de apresentação, o que de fato creio ser um tempo muito curto para falar de um trabalho bem extenso, ainda mais que são 5 padrões de projeto a serem apresentados, espero em breve poder oferecer o tema para alguma palestra do GDJCE.

O  resumo do trabalho:

Com o amadurecimento da produção de software, percebemos cada vez mais a aplicação das diretrizes da Engenharia de Software, o que traz reconhecidamente melhores resultados do que os software montados de forma caótica. No universo de desenvolvimento de jogos, podemos perceber, ainda um certo grau de amadorismo em relação a produção de software convencionais, pois poucos são os profissionais e empresas, que conhecem ou aplicam as diretrizes utilizadas no desenvolvimento de softwares, onde termos como metodologia, processo, disciplinas, qualidade, conformidade e boas práticas, fazem parte do dia-a-dia do desenvolvimento, geralmente demonstrando um certo grau de maturidade, permitindo assim um controle maior do que é produzido, como produzido-lo e como averiguar sua conformidade com o esperado. Focando na etapa de programação, ou seja, nas questões arquiteturais e de implementação, podemos observar mais claramente uma ausência quase total de informações ou referências sobre a utilização de Design Patterns em jogos, indo além do código, observa-se a falta de literatura especializada, de congressos e discussões focando no assunto. Com isso em mente estamos propondo um trabalho focando em Design Patterns para Jogos, ou seja, estamos documentando alguns padrões percebidos durante o desenvolvimento de jogos, com o objetivo de auxiliar na resolução de problemas encontrados durante o desenvolvimento, além de estimular a aplicação e catalogação de padrões de projeto focados especificamente em jogos. Com base nesta idéia, partimos para a catalogação inicial de alguns padrões de software, os quais são: 1.Font Mapping 1.1 Intenção Permitir que aplicações multimídias possam escrever informações(textos) na tela para o usuário. 1.2 Motivação Estamos desenvolvendo uma aplicação multimídia como por exemplo um player de vídeo ou um jogo eletrônico, porém necessitamos exibir informações para o usuário, geralmente essas informações são textos composto por caracteres alfa-numéricos, que representam informações sobre o estado do jogo ou do filme. Nestes casos na maioria das vezes desejamos utilizar textos de fontes estilizadas, quer seja pelo seu formato ou pelo estilo utilizado, como por exemplo o uso de sombras, bordas ou degradê. 2.Resource Manager 2.1 Intenção Permitir que uma aplicação gerencie os recursos multimídia necessários para seu funcionamento. 2.2 Motivação Muitas vezes, estamos desenvolvendo uma aplicação ou um jogo eletrônico, que fará uso de recursos externos ao código fonte, como por exemplo: arquivos de imagens, arquivos de vídeos e arquivos de som. Sendo que diversas vezes uma mesma imagem ou som é utilizado por diversos elementos do jogo, como por exemplo: A animação de uma explosão, que contém 6 quadros(imagens), se em um certo momento do jogo, encontramos 7 aviões na tela, teríamos então que ter em memória o equivalente a 42 imagens, apenas para representar a possível explosão dos aviões. Tendo isso como base, observamos que é necessário um gerenciamento de recursos que além de carregar o que for necessário, quando necessário, possa prover o compartilhamento para que diversos elementos do jogo façam uso. 3.Language Manager 3.1 Intenção Permitir que uma aplicação ou jogo, posso suportar múltiplos idiomas. 3.2 Motivação Ao se desenvolver um jogo, uma das primeiras decisões que se toma é a definição de qual será o idioma de seu público alvo, onde geralmente acaba-se optando para que o jogo esteja apenas em um único idioma. Porém com isso eliminamos a possibilidade do mesmo entrar em contato com outros públicos, simplesmente pela barreira da língua. Sendo assim, um jogo em um mundo globalizado, deve permitir ou se adaptar ao idioma nativo de seus jogadores, sem comprometer sua estrutura interna, não sendo aceitável que seja mantido duas ou três versões do mesmo código para gerar versões em português, inglês ou espanhol. 4.AnimaChronos 4.1 Intenção Permitir a criação de animação para jogos, baseado no uso de imagens estáticas. 4.2 Motivação Quando estamos diante de um jogo eletrônico, nossa primeira percepção recaí sobre os gráficos, em principal sobre o movimento hipinótico exercido por eles, ou seja, nosso foco visual é rapidamente atraído para os objetos que se movem na cena, ou seja, as animações. Desta forma é imprescindível ao desenvolvermos um jogo, elaborarmos a capacidade de dar movimento as imagens, fazendo uso extensivo deste recurso conhecido como animação, o qual é o responsável pela completude da vida do personagem e objetos na cena. Tendo isso em mente, necessitamos da capacidade de unir as diversas imagens estáticas de forma padronizada e ordenada para que possamos efetuar as mudanças de quadro de forma controlada, causando o efeito desejado, ou seja, o movimento fluído do personagem ou objeto. 5.Game Struct 5.1 Intenção Organizar e estruturar o funcionamento interno de um jogo eletrônico. 5.2 Motivação Quando pretendemos criar um jogo eletrônico, devemos ter em mente que um jogo é um software altamente especializado, e por consequência, é bem mais complexo que a maioria dos softwares tradicionais, pois possui um alto grau de interação com seu usuário, ou seja, o jogador, ao mesmo tempo que integra-se com diversos subsistemas e seus componentes, para assim poder executar de forma ordenada, controlada e prevista.

Para mostrar a um amigo, alguns dos jogos/demos que estou desenvolvendo, coloquei no youtube dois videos, mas cuidado!, É uma super produção caseira

Para quem não conhece temos, o Pancada, o famoso jogo de boxing, que um dia vou terminar, pior que só esta faltando coragem pra fazer a pseudo-ia do jogo

E o TechDemo, Caveman (que nome original), o qual é a base de futuros testes para o desenvolvimento de jogos estilo plataforma, existe alguns problemas relacionados a movimentação, regras de saltos, movimento de queda, mas em fim, é o começo

Como melhorias nesta nova versão temos:

• Suporte a internacionalização, agora o jogo está disponível em português e inglês;
• Melhoria na inteligência artificial do computador;
• Aplicação de novos efeitos na bola de acordo com o local da rebatida;
• Modificação das regras do jogo;
• Melhorias no aspecto visual dos textos e janelas de mensagens;

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

Referência
[1]http://cdlivre.wordpress.com
[2]http://pjmoo.wiki.sourceforge.net/FZPong
[3]http://www.libsdl.org
[4]http://pjmoo.wiki.sourceforge.net/GBF
[5]http://davidferreira-fz.blogspot.com/2007/06/fzpong.html

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;

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

O que de fato acontece é que o desenvolvedor utilizando o framework faria apenas isto:

//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();

UserInterfaceVisualImagem *uiVisualImagem = new UserInterfaceVisualImagem();
uiVisualImagem->setTipoBackground(BACKGROUND_LINES);
uiVisualImagem->setCorBorda(255,0,0);

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

void Jogo::menuCredito()
{
rameLayerManager::getInstance()->getFrameLayer("background")->desenhar();

janelaCredito->executar();

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

Para finalizar podemos entender que o que chamamos de janela, basicamente é uma região da tela, a qual podemos fazer alguma manipulação, no caso da GBF e do Pancada tudo que necessitamos é desenhar as bordas da janela, uma imagem de fundo com efeito de “transparência”, que seja capaz de exibir alguma mensagem(texto e título) e que possa responder ao acionamento de algum botão.

Caso tenham interesse em saber mais detalhadamente como funciona ou detalhes da implementação podem entrar em contato

T+!
Vida Longa e Próspera!

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

Referência
[1]http://davidferreira-fz.blogspot.com/2007/09/gbf-interface-grafica-v05.html
[2]http://davidferreira-fz.blogspot.com/2007/09/rascunho-de-interface-grfica.html
[3]http://pjmoo.wiki.sourceforge.net/
[4]http://pjmoo.wiki.sourceforge.net/GBF
[5]http://www.libsdl.org

//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

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!

Experiência

• Como fazer a bolinha rebater na tela;
• Como fazer com que o CPU jogasse sem acertar todas e que não fosse totalmente burro;
• Como delimitar a duração do jogo;

Respondendo as essas perguntas comecei então a procurar minhas saídas:

“Como fazer a bolinha rebater na tela”

Fazem anos que não via física, e cheguei a pensar em algo complexo como mudar a direção da bolinha por meio de ângulos, seno, cosseno e etc. Acabei procurando um livro de física para lembrar conceitos relacionados a mecânica, como movimentos uniformes, e etc, pois não lembrava mais nada disso, e nem sabia ao certo se isso resolveria, o fato é que o livro que recorri não era muito explicativo, na verdade era apenas exercícios (esses livros de hoje, parecem não serem feitos para que as pessoas aprendam sozinhas), comecei a ler, e reler, porém não consegui ver de fato a aplicação para o meu caso especifico, o qual seria apenas fazer a bolinha se desviar ou voltar. Sendo assim comecei a procurar pelo Google na esperança de achar alguns sources e acabei foi de fato achando um tutorial/apostila do Silveira Neto[7] (hehehe logo do Silveira, tão próximo e tão longe, ele também é daqui de Fortaleza, tive que ir na Internet para achar o que precisava), e lá tinha justamente o exemplo de uma bola sendo rebatida, aproveitei isso e adaptei para o pong. O fato é que a solução era super simples e eu procurando complicações físicas, bastava no caso inverter os valores de x e y para o que a bolinha voltasse na direção oposta exemplo:

if (bola.y>480){
velocidade.y = – velocidade.y;
}

bola.y+=velocidade.y;

“Como fazer com que o CPU jogasse sem acertar todas e que não fosse totalmente burro”

• Fazer com que o cpu se “distraia”, ou que “fique confiante demais” e só vá atrás da bola na última hora, o que causaria o efeito de incerteza se ele acertaria ou não
• Fazer com que ele decida onde bater na bola, use as três partes da raquete para provocar efeitos diferentes na bola;
• Fazer com que a visão aumente quando ele perder uma partida, pois assim na será um desafio maior para o jogador;

“Como delimitar a duração do jogo”

FeedBack

E por fim temos o download do FZPong[8]:

Código Fonte: FZPong.1.1.src.zip
Versão Linux: FZPong.1.1.bin.linux.tar.gz
Versão MS-Windows e Linux: FZPong.1.1.bin.all.zip

T+!
Vida Longa e Próspera!

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

Referência

[1] Grupo DoG – http://groups.google.com/group/dog_/
[2] Pong do Charles – http://www.lia.ufc.br/~rockyspirit/pong.tar.bz2
[3] GBF – http://pjmoo.sourceforge.net/wiki/index.php/GBF
[4] PacZero – http://pjmoo.sourceforge.net/wiki/index.php/PacZero
[5] Pancada – http://pjmoo.sourceforge.net/wiki/index.php/Pancada
[6] Tutorial Esfera 3D – http://www.ogimp.com.br/modules/smartsection/item.php?itemid=7
[7] Blog do Silveira – http://www.eupodiatamatando.com
[8] PJMOO Downloads – http://sourceforge.net/project/showfiles.php?group_id=198186

História

Ficha Técnica

• Linguagem
  • C++
• Bibliotecas
  • SDL (SDL_image, SDL_mixer, SDL_net)[6]
  • GBF[5]
• Recursos
  • Audio Stereo
  • Suporte a Joystick
  • Teclado
  • Gráficos 2D
• Idiomas
  • Português
  • Inglês
  • Espanhol
• Sistema Operacional
  • MS-Windows
  • GNU/Linux
• Ferramentas
  • IDE: CodeBlocks[7]
  • UML: BoUML[8]
• Licença
  • GPL

Aprendizado

• MS Visual Studio 6
• DevCPP[9]
• Eclipse CDT (Plugin para C++)[10]
• KDevelop[11]
• CodeBlocks[7]

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

Blz!

Pessoal acabei de lançar a versão (correções) no SpaceShooter agora na versão 1.4 (e creio que última deste projeto) e a versão 0.6 do GBF (Framework C++ para jogos multiplataforma).

–

SpaceShooter, é um jogo clássico no estilo shoot’up, tendo como base a temática de Star Trek.

Para enfrentar tudo isso, 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 ilimitados e de alguns poucos torpedos. Para sua defesa deverá contar com sua habilidade, a velocidade dos motores de warp, além da força dos 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.

Licença:

   SpaceShooter - GPL  GBF - LGPL

Mais informações:

Projeto PJMOO no Código Livre

   http://codigolivre.org.br/projects/pjmoo/

Site do jogo SpaceShooter

   http://pjmoo.codigolivre.org.br/site/spaceshooter/

Wiki do desenvolvimento do SpaceShooter

   http://pjmoo.codigolivre.org.br/wiki/index.php/SpaceShooter