Mês passado eu li esta notícia do G1 Games sobre um casal alemão que decidiu fazer um jogo como convite de casamento, onde o objetivo é fazer a noiva salvar o noivo de um gorila (bem estilo Super Mario Bros.). Semana passada foi aniversário da minha namorada Carol e, pensando no que o casal alemão fez, eu decidi fazer um cartão de Feliz Aniversário para ela em forma de um jogo para computador.

Tela de abertura

O jogo foi feito em 2 semanas, programei apenas de noite quando não tinha aulas na pós-graduação, e terminei na madrugada do aniversário dela. Decidi desenvolver utilizando XNA, que eu tenho mais facilidade para desenvolver jogos e também é muito fácil fazer jogos de plataforma em 2D, como o que eu fiz. Os sprites dos personagens (eu e ela) e as animações foram copiadas dos avatares Buddy Poke dos nossos perfis no Orkut, e o resto do cenário são imagens que encontrei na internet. Assim, foquei na programação e na mensagem que eu queria transmitir.

Gameplay

O objetivo do jogo Feliz Aniversário Carol – The Game é atravessar o cenário, pulando pelas plataformas, coletar as letras que formam a palavra PARABENS, e me encontrar no final da fase. É um jogo bem curto e simples, pois não tive muito tempo para desenvolver (comecei uma semana antes do aniversário dela) e também não queria fazer algo longo, já que o objetivo principal era desejar um Feliz Aniversário para ela de uma maneira diferente.

Tela do final

Apesar do jogo ser simples, eu utilizei uma técnica para criar o Level Design que li em um livro de programação de jogos em java que eu tenho. A técnica é simples: a construção do cenário 2D está armazenada em um arquivo .TXT, que é lido pelo jogo e transformado no cenário que jogador vê, através da tradução de caracteres presentes no arquivo em sprites. Por exemplo, o meu arquivo .TXT possui os seguintes parâmetros reconhecidos pelo jogo:

• Número “0″: Lugares no cenário onde não possuem sprites e não existe colisão;
• Número “1″: Traduzido no jogo como sprites com imagem de gramado com colisão;
• Número “2″: Traduzido no jogo como sprites com imagem de tijolo com colisão;
• Número “3″: Traduzido no jogo como um sprite com o meu avatar, onde a colisão reinicia o jogo se o jogador não formou a palavra PARABENS. Se colidir com este sprite e a palavra PARABES estiver formada, é exibido o final do jogo;
• Letras “P”, “A”, “R”, “B”, “E”, “N” e “S”: Traduzido no jogo como sprites que representam esta letra, e o jogador deve coletar todas na ordem para ver o final do jogo.

Arquivo com Level Design

A vantagem de se utilizar esta técnica: qualquer um pode alterar o Level Design do jogo a qualquer momento, sem precisar compilar novamente o projeto, é bem simples e fácil de usar para testar a jogabilidade e complexidade de um jogo, mudando rapidamente o cenário para corrigir erros de game design ou melhorar a experiência do jogador.

A desvantagem de se utilizar esta técnica: dependendo do tamanho do level criado em um arquivo .TXT, o jogo pode ficar muito lento. O carregamento dos dados do arquivo e a transformação em um array de sprites não é a parte mais demorada, o problema real é verificar colisão e movimentar TODOS os sprites a cada loop. Neste jogo, por exemplo, o level design que eu montei contém 1841 sprites que são movimentados e tem a sua colisão verificada a cada loop do jogo. Assim, esta técnica fica inviável em jogos com level muito grande.

A desvantagem pode parecer maior do que a vantagem de se utilizar esta técnica em jogos de plataforma 2D, mas em outros tipos de jogos pode ser bem útil e não pesar tanto, como em puzzles ou jogos de estratégia onde os cenários são menores. Ainda sim, é uma técnica interessante para brincar e estudar, por ser simples de programar e mostrar resultados rapidamente.

Neste link está o executável e o instalador deste jogo. Na raiz do jogo está o arquivo LevelDesign.TXT, que pode ser editado para mudar o cenário de qualquer maneira, lembrando que quanto maior o cenário, mais lento poderá ficar o jogo. Todo o meu trabalhou valeu muito a pena, pois ela adorou este presente diferente. Ah, a trilha sonora é a música Envelheço na Cidade, da banda IRA!, que ficou perfeita no jogo!

O SENAC São Paulo organizou sua primeira competição de jogos digitais, o e-Games, onde os concorrentes deveriam criar um jogo utilizando XNA. Além do jogo feito com XNA, foi necessário entregar um vídeo, documento de game design, apresentação, resumo e guia de instalação. O Download do jogo pode ser feito clicando aqui, ele necessita do .Net Framework 3.5 e Microsoft XNA Framework Redistributable 3.1 instalados para rodar, não é necessário instalar o jogo, apenas executar o SpaceShip4042.exe.

Tela inicial do jogo desenvolvido com XNA

O prazo para entrega foi na última sexta-feira, e eu decidi participar disto uma semana antes e sozinho. Ou seja, tive apenas uma semana para fazer tudo isso, além de ter que trabalhar e ir para a faculdade. Como estava sem tempo, decidi criar uma versão do meu jogo de celular SpaceShip 4042 em XNA, pois já tenho todas as imagens para criar o jogo, além de ter todo o conceito pronto, só foi necessário programar.

Depois de uma semana dormindo menos de 4 horas por dia, virando noites programando, o resultado não foi exatamente o que eu imaginei, mas consegui terminar meu jogo com tudo que a versão de celular tem, com excessão de som, pois tive dificuldades com isto e estava sem tempo. Além disso, no lugar de um High Score, fiz um Ranking top 5.

Embora eu tivesse apenas que programar, tive vários problemas por não conhecer muitas coisas no XNA e não ter tempo suficiente para estudar melhor. O maior problema que tive foi com a detecção de colisão por pixel. No JME existe uma função que verifica a colisião entre dois Sprites, inclusive existe o tipo de dado Sprite. Já no XNA não é tão fácil assim, não existe Sprite e método de detecção de colisão pronto.

O método de colisão que utilizei consiste em verificar se existe a interseção entre a área da imagem dos dois Sprites que estão colidindo. Uma vez que esta interseção existe, vem a parte mais complicada que é verificar se existe a sobreposição dos pixels que não são transparentes na imagem, utilizando um vetor com a cor da cada pixel da imagem. Não é tão complicado quanto parece, mas é bem chatinho de fazer.

Resolvi o problema do Sprite criando uma classe com os atributos que achei necessários para a fazer a nave, os meteoros, os itens e os tiros. Os principais atributos são: um Vector2D para a posição do objeto, uma lista de Texture2D para guardar todos as imagens que compoem a animação do Sprite, um Rectangle para ser utilizado na detecção da colisão, um vetor de Color com as cores da imagem, um bool para a visibilidade, e inteiros para armazenar vida, frame da animação e movimentação do objeto. Criei métodos para desenhar, mover, esconder, causar dano e verificar se o sprite “morreu”.

Outro problema que tive, mas que foi simples de resolver, foi a animação, pois o XNA também não possui algo que facilite isto como o incrível arquivo GameDesign do JME. Utilizando um inteiro, controlei a animação do Sprite em cada quadro. Também tive dificuldades com a criação das telas e sua maniulação. Criei uma interface para telas, e todas as telas implementam os métodos default do XNA: Update, Draw e LoadContent, além de um para controlar a inicilização das variáveis. A classe principal do jogo inicia todas as variáveis que representam as telas e tem responsabilidade de controlar a exibição de cada uma, de acordo com o estado do jogo.

Tela do jogo com os três tipos de Sprite criados

Se eu tivesse tido mais tempo, ou começado bem antes quando fiquei sabendo desde concurso, eu poderia ter feito muitas outras coisas e melhor, mas fiquei satisfeito em fazer um jogo em XNA em tão pouco tempo e sem conhecer tão bem as características desta tecnologia. Fiz muitas coisas básicas para um jogo 2D, e na minha opinião só faltou colocar som no jogo.

Assim como no JME, que tive dificuldades no começo, tive dificuldades com o XNA também, mas meus próximos jogos 2D nessas plataformas ficarão muito melhores, e provavelmente levarei menos tempo para programar, pois aprendi muitas coisas desenvolvendo para plataformas diferentes com tecnologias distintas. Praticamente tudo que utilizei aprendi fuçando nos exemplos do XNA Creators Club e nas dúvidas no forum, são ótimas fontes de informações.

Meu próximo passo agora é começar a estudar programação de jogos em 3D com C++. Este estudo é o primeiro passo para o meu TCC ano que vem, que provavelmente será um jogo em 3D com C++. Tenho algumas idéias para o jogo, mas nada decidido ainda, porém preciso aprender este tipo de programação, que eu tive contanto apenas no XNA para movimentação de modelos 3D simples na tela.

Este é o primeiro jogo que fiz para celulares, e também foi o primeiro projeto que terminei tudo o que eu planejava fazer. Fiz este jogo para a matéria de Jogos para Celular na pós-graduação utilizando Java Mobile (JME com CLDC 1.1/MIDP 2.0) e o Netbeans 6.7.1.

Como eu conheço Java, não tive problemas com a programação. A principal dificuldade inicial era entender como um jogo funciona em um celular, entender suas limitações e arquitetura. Por ser bem limitado, deve-se ter muita paciência e cuidado na programação para celular, para que o código não exija muito processamento e também para que as imagens fiquem “leves”.

O Netbeans ajudou muito no desenvolvimento do jogo, pois ele possui um tipo de arquivo chamado GameDesign, onde você importa imagens e cria sprites, cenários e cenas. Eu utilizei apenas para criar sprites do jogo, não precisei utilizar cenários e cenas.

Este projeto levou cerca de 2 meses para ficar pronto, porém não foram 2 meses de trabalho diário, eu programava um pouco por semana. Tive ajuda do David Felicino com as imagens das naves, tela de abertura, fundo do jogo e itens, e minha da namorada que me ajudou testando o jogo. Obrigado aos dois!

Clique aqui para baixar este jogo!

O objetivo do jogo é simples: permanecer o maior tempo possível e pontuar destruindo os meteoros ou desviando deles. O jogo acaba quando os 3 pontos de vida da nave chegarem ao fim, devido a colisões com os meteoros. Os meteoros também têm 3 pontos de vida.

Existem dois itens: um para ganhar 1 ponto de vida e outro para transformar a nave em “nível 2″. Neste nível 2, o jogo dobra a velocidade e os meteoros são destruídos com apenas um tiro. Se for atingido pelo meteoro, neste modo, o jogador não perde vida, apenas o item e volta a ficar com a nave “nível 1″. A velocidade do jogo também dobra se acontecer uma determinada situação.

A maior pontuação do jogar é sempre armazenada e pode ser vista através do meu “High Score”. Existe também uma opção para ver os controles e os créditos. O menu foi legal de fazer, pois o JME não dá suporte para menus apenas com imagens, então criei o menu com sprites que são trocados ou selecionados através dos botões “para cima” e “para baixo” do celular.

Além dos controles tradicionais (direcionais e botão central do celular), existe um suporte a eventos de toque na tela (apenas o jogo, o menu ainda não). O video abaixo é uma demonstração no meu celular, um Samsung Star S5230:

O jogo também possui uma verificação para talvez funcionar em um maior número de celulares sem precisar ser portado. A verificação é a seguinte: se a resolução da largura (width) da tela do jogo for inferior a 240, são desabilitados o som e a imagem de fundo e a imagem de abertura e os meteoros são imagens com um tamanho menor.

Este vídeo demonstra o jogo no emulador do Netbeans, em uma tela de 240 x 320:

Este vídeo demonstra o jogo no emulador do Netbeans, em uma tela de 176 x 220:

No segundo vídeo é possível ver tudo que foi reduzido da versão normal (primeiro vídeo) . É claro que é ambição demais querer que este jogo realmente funcione em vários celulares diferentes, mas pelo menos tentei fazer com que isto seja possível de alguma forma.

Este jogo funcionou nos seguintes celulares: Samsung Star S5230, Motorola A1200, Motorola V9, Sony Ericsson W380 (reduzido) e Sony Ericsson K550i (reduzido). Não consegui instalar no Motorola V3, ocorre um erro após transferir por bluetooth.

Existem alguns bugs que estou corrigindo e muitas coisas para polir, mas o jogo já está em sua primeira versão jogável. O principal problema é que, as vezes, ao entrar no jogo pela primeira vez em celulares mais simples, aparece uma tela branca. Neste caso basta voltar para o menu e entrar novamente, porém isto não ocorre sempre. Estou trabalhando nesta e em outras coisas para deixar este jogo o mais perfeito possível.

Desenvolver este jogo foi muito interessante, pois aprendi bastante sobre a arquitetura de um celular, programação com JME, algumas técnicas para diminuir o consumo do processamento, aplicação de design patterns no Java, gravar e ler informações no celular, e, principalmente, alguns dos vários problemas que podem acontecer ao testar o jogo fora do simulador.

Espero que gostem do jogo, este é o primeiro de muitos que pretendo fazer! Comentários são bem-vindos, principalmente se forem sobre bugs! Até mais!