Use o código e tenha 10% de desconto!

Jogos Android Crie um game do zero usando classes nativas

Felipe Torres
Capa

games-android

Sobre o autor

Desde o momento em que escrevi minha primeira linha de código, em um projetinho Android de estudos, me senti completamente empolgado com as diversas possibilidades de aplicações que poderia desenvolver. Assim, resolvi mergulhar nesse mundo e aprender tudo o que pudesse sobre esse universo.

Naquele momento, cursava meu último ano da graduação no IME-USP e estava pesquisando o que faria no meu projeto de conclusão de curso. Não tive dúvidas: queria fazer algo com Android, pois teria uma chance para me dedicar a aprendê-lo a fundo. No fim das contas, acabamos fazendo em dupla um otimizador de rotas, onde tive meu primeiro contato com algumas tecnologias do Android, como o atual Google Cloud Messaging.

Ao término da graduação, senti a necessidade de participar de algum projeto open source, porém queria algo no qual eu realmente pudesse fazer diferença e que fosse divertido também. Então, comecei a pesquisar como deveria fazer para participar do código-fonte do Android. Algumas noites mal dormidas (e gigabytes de download) depois, e já tinha tudo configurado para o meu primeiro commit no Android Open Source Project.

Paralelamente a isso, lia alguns textos sobre desenvolvimento de jogos e resolvi entrar nessa área, porém muito material que via era focado no uso de algum framework, de modo que até mesmo aquele jogo mais simples precisava de um caminhão de API para ser desenvolvido. Neste momento, resolvi tentar fazer jogos simples graficamente, sem o uso de frameworks, e tive bastante êxito, rendendo um convite para palestrar no Conexão Java e um jogo publicado no Google Play com mais de 100 mil downloads.

Atualmente, sou desenvolvedor e instrutor na Caelum apaixonado pelo mundo mobile. Dedico um tempo ajudando a desenvolver o código-fonte do Android e muito do que aprendi durante esses anos de estudo está compartilhado neste livro.

Por que um jogo mobile?

Somente em um ano, dentro da indústria de jogos mobiles, temos faturamento em dólares como:

  • O jogo Clash of Clans recebeu 800 milhões.
  • A saga Candy Crush faturou 300 milhões.
  • A série Angry Birds ganhou 195 milhões.

A venda de smartphones e tablets vem aumentando cada vez mais, tornando seus usuários um grande público não só para aplicativos, mas também para jogos. Muitas das grandes desenvolvedoras de games, como EA, Gameloft e Ubisoft, já perceberam isso e contam com divisões inteiras destinadas somente ao desenvolvimento de games para plataformas móveis.

Não há como ignorar o tamanho desse mercado. Disponibilizar, ou não, uma versão mobile de um jogo é a diferença entre estar neste mercado bilionário ou ficar de fora.

 

Como será o nosso jogo?

 

Um jogo que se destacou bastante e ganhou notoriedade na mídia foi o Flappy Bird, criado em apenas três dias pelo vietnamita Dong Nguyen, que chegou a faturar 120 mil reais por dia com anúncios. Como o Flappy Bird apresenta os principais elementos de um jogo (e é bem divertido), vamos criar a nossa versão desse game: o Jumper!

Agora que temos uma ideia do jogo que faremos, uma dúvida que aparece é: o que vamos usar para criar nosso game? Uma rápida busca na internet pelo tema “ferramentas para jogos Android” pode revelar inúmeras alternativas e nos deixar confusos: será que devemos usar libGDX ou Unity com Chipmunk? Será que o Cocos2D não seria melhor?

A pergunta que devemos fazer é: sempre teremos que usar algum framework para desenvolvimento de jogos? Muitas vezes, não.

Os frameworks podem nos ajudar em vários aspectos do desenvolvimento de um jogo, porém, para muitos jogos eles não são necessários. No nosso Jumper, não usaremos nenhuma ferramenta específica para jogos, apenas as funcionalidades que a API do Android nos oferece! Dessa forma, podemos aprender os conceitos por trás de um jogo, e entender as vantagens e desvantagens de utilizar um framework.

 

Como este livro está organizado?

 

Criar um jogo do zero é sempre algo bastante desafiador e, muitas vezes, nos vemos perdidos sem saber por onde começar, quais problemas atacar, qual a melhor prática etc. Este livro está organizado de uma forma que os desafios vão aparecendo naturalmente durante o desenvolvimento do nosso programa. Cada capítulo está focado na solução de um problema e, ao resolvê-lo, encontramos a motivação para o próximo desafio.

Apesar da teoria por trás de um jogo, a todo momento mostramos os trechos de código, dando uma atenção à programação e boas práticas!

Depois das apresentações sobre o autor e o projeto, no capítulo * criaremos o começo do jogo e discutiremos por onde devemos começá-lo. Com isso, teremos o loop principal, que será onde as principais funcionalidades do jogo serão gerenciadas. Porém, um jogo sem nada para mostrar é bastante chato, então criaremos nosso primeiro elemento: o pássaro, e já aproveitamos para definir seu comportamento. Ao fim desse capítulo, teremos um jogo com um pássaro caindo!

No capítulo *, colocaremos uma imagem para servir como plano de fundo e veremos como redimensioná-lo para caber em qualquer tela. Com isso, teremos um pássaro caindo, mas com um fundo bonito. Para melhorar isso, faremos o controle do jogador: ao tocar na tela, o pássaro pula.

Finalizado o pássaro, nosso jogo não está nada desafiador para o jogador. Resolveremos isso no capítulo *, onde criaremos o outro elemento do jogo: o cano inferior! Ao exibi-lo na tela, veremos que ele estará imóvel. Ao término deste capítulo, faremos esse cano se mover na direção do pássaro.

Nosso jogo já está ficando mais interessante, mas ainda conta com apenas um cano inferior solitário. No capítulo *, nosso objetivo será criar vários canos inferiores!

Já no capítulo *, criaremos os canos superiores! Além disso, tornaremos esses canos “infinitos” para o jogador. Mas, no nosso código, teremos apenas um número fixo deles.

Terminada a criação dos elementos do nosso jogo, vamos focar na jogabilidade. Até aqui, quando passamos por algum cano, nada acontece. Este será o momento de criarmos a pontuação! No capítulo , veremos como será contabilizada a pontuação do jogador e mais a fundo a classe Paint do Android, para exibirmos esse valor na tela!

No capítulo *, percebemos que o jogo ficou muito fácil, pois em nenhum momento dissemos o que vai acontecer quando o pássaro bater em um cano. Focaremos, então, em definir o que será a colisão entre o pássaro e o cano. Por fim, discutiremos o que fazer caso haja uma colisão e criaremos o game over. Com isso, concluiremos a mecânica do jogo, com todos os detalhes para termos algo jogável em mãos.

Até aqui, nosso jogo está feio, pois sempre trabalhamos com formas geométricas simples, como círculos (para o pássaro) e retângulos (para os canos). Para melhorarmos sua estética, veremos no capítulo * como substituir essas formas por imagens sem que tenhamos de refazer toda a lógica da nossa aplicação.

No capítulo *, nossa atenção será dedicada a um outro aspecto bastante importante em um jogo: os sons! Veremos como podemos usar a classe SoundPool para tocar um som para os principais momentos do jogo: pulo do pássaro, colisão e aumento na pontuação.

O capítulo * possui um conteúdo um pouco mais matemático para tornar nosso jogo um pouco mais realista. Neste momento, você verá que, com um pouco de conhecimento em física, já é possível tornar a jogabilidade mais interessante.

Após isso, no capítulo * completamos o Jumper criando uma nova tela para servir como menu principal.

Todos os arquivos usados no Jumper estão disponíveis no GitHub, em https://github.com/felipetorres/jumper-arquivos.

Além disso, caso apareça alguma dúvida ou queira compartilhar alguma ideia, não deixe de participar do grupo de discussões deste livro, em https://groups.google.com/forum/#!forum/jogos-android-cdc.

Sumário

  • 1 - Começando o Jumper
    • 1.1 - Criando o projeto e a tela principal
    • 1.2 - O loop principal do Jumper
    • 1.3 - Como desenhar elementos no SurfaceView?
    • 1.4 - Nosso primeiro elemento: a classe Passaro
    • 1.5 - Comportamento padrão do pássaro: o método cai
  • 2 - Colocando uma imagem de fundo
    • 2.1 - Como será o background?
    • 2.2 - Redimensionando o plano de fundo
    • 2.3 - Controle do jogador: o pulo do pássaro
  • 3 - Cano inferior
    • 3.1 - Criando a classe Cano
    • 3.2 - A movimentação do cano
  • 4 - Criando vários canos
    • 4.1 - Melhorias para gerenciar vários canos
    • 4.2 - Limites para pulo: o chão e teto
  • 5 - Canos superiores
    • 5.1 - Calculando os canos superiores
    • 5.2 - Gerenciando infinitos canos
    • 5.3 - Iterator para modificar a lista de canos
    • 5.4 - Descartando canos anteriores
  • 6 - Pontuação
    • 6.1 - Contagem dos canos vencidos
    • 6.2 - Exibição na tela
    • 6.3 - Configurações da fonte: a classe Paint
    • 6.4 - Organizando as camadas de desenho
  • 7 - Colisões
    • 7.1 - Verificando colisão entre o pássaro e o cano
    • 7.2 - Criando a tela de game over
    • 7.3 - Centralizando um texto horizontalmente na tela
  • 8 - Aprimorando o layout do jogo
    • 8.1 - Substituição do círculo vermelho do pássaro
    • 8.2 - Reposicionando o bitmap
    • 8.3 - Substituindo os retângulos inferiores por bitmaps
    • 8.4 - Substituindo os retângulos superiores por bitmaps
  • 9 - Som
    • 9.1 - A classe SoundPool
    • 9.2 - Tocando um som no pulo do pássaro
    • 9.3 - Som da pontuação
    • 9.4 - Som da colisão
  • 10 - Física
    • 10.1 - Modelando a física da queda
    • 10.2 - A classe Tempo
    • 10.3 - Passando o tempo
    • 10.4 - Física no pulo do pássaro
    • 10.5 - Refatoração do método cai
  • 11 - Menu principal
    • 11.1 - Uma nova tela ao jogo
    • 11.2 - Layout do menu principal
  • 12 - Considerações finais

    Dados do produto

    Número de páginas:
    127
    ISBN:
    978-85-5519-013-1
    Data publicação:
    06/2015

    Compartilhe!

    Compartilhe no Facebook Compartilhe no Twitter