Apostila Android Jogos 2 Edicao Completa

2

Aviso sobre esta apostila

Antes de iniciar a leitura deste material, veja esses avisos importantes:

Esse material NO PODER SER DISTRIBUDO, em hiptese alguma, em

outros sites da Internet ou atravs outros processos/meios .

Esse material , em hiptese alguma, NO PODE SER COMERCIALIZADO tanto

pela Internet ou de forma impressa.

Se por acaso voc encontrar este material sendo distribudo em outro site ou

sendo comercializado (sem ser pelo site oficial da apostila), por favor, entre em

contato com o autor (ver e-mail na primeira pgina).

3

Sobre o Autor da Apostila

Luciano Alves da Silva Bacharelado em Cincia da Computao pela UNISUAM

e Ps-Graduado em Docncia do Ensino Superior pelo Instituto A Vez do Mestre

(Universidade Cndido Mendes - UCAM). Possui conhecimento e domnio das

linguagens de programao Pascal, Java, C/C++, C#, Visual Basic, Delphi, PHP e

HTML. J criou Ambientes de Desenvolvimento Integrado (conhecidos como IDE)

como o MakeWare (que trabalha com as linguagens Pascal, C++ e Java) e o

AlgoWare (interpretador de algoritmos).

autor tambm dos seguintes livros, pela editora AGBOOK

- Aprenda Passo a Passo a Programar em Android Guia Essencial para

Desenvolvedores

- Desenvolvendo Jogos com a Plataforma XNA Guia para Desenvolvedores.

- Desenvolvendo Jogos com a Ferramenta RPG Maker VX Guia do Usurio.

4

Apresentao

Este material dedicado para aqueles que desejam desenvolver jogos em 2D

voltados para a plataforma Android, atravs da ferramenta de desenvolvimento

Eclipse com o Android SDK (usando o Android Developer Tools).

Este material completo, no necessrio adquirir nenhuma Apostila de Android

disponvel no site para este aprendizado sobre jogos. O usurio que tenha

interesse em desenvolver jogos para essa plataforma, precisa possuir

conhecimentos bsicos sobre linguagens de programao (de preferncia Java

ou suas derivadas C++/C#) e algoritmos.

5

ndice analtico

Capitulo 1 Introduo ao desenvolvimento de jogos .............................. 7

Capitulo 2 Viso geral sobre o Google Android ....................................... 9

2.1) Sobre o Android ...................................................................................... 9 2.2) Estrutura Geral da plataforma Google Android ..................................... 11 2.2.1) A arquitetura do Android .................................................................... 13 2.2.2) Aplicaes .......................................................................................... 13 2.2.3) Android Runtime ................................................................................ 14 2.2.4) Linux Kernel ....................................................................................... 15 2.3) Para qual verso do Android devemos desenvolver os nossos jogos ? 15

Capitulo 3 Instalando e Configurando o Android Developer Tools ........ 18

3.1) Efetuando o download e configurando o ADT ...................................... 19

Capitulo 4 Instalando e Configurando o emulador BlueStacks .............. 24

Capitulo 5 Comeando a desenvolver jogos para Android .................... 36

5.1) - Conhecendo a estrutura geral do projeto Android para jogos ............. 41 O diretrio src (source) .............................................................................. 41 O diretrio res (resources) ......................................................................... 47 Os diretrios drawable-hdpi, drawable-mdpi , drawable-ldpi e drawable-xhpdi. .......................................................................................................... 47 O diretrio values ....................................................................................... 48 Definindo o nome de um projeto .................................................................. 49 Definindo o cone da aplicao (jogo) .......................................................... 52 Executando o jogo ....................................................................................... 54

Capitulo 6 Visualizando imagens no jogo (A classe Image) .................... 58

Capitulo 7 Movendo elementos do jogo pela tela ................................. 69

Capitulo 8 Trabalhando com animao de sprites (A classe AnimationSprites) ................................................................................. 83

Capitulo 9 Detectando colises entre objetos no jogo .......................... 91

Capitulo 10 Criando elementos durante a execuo do jogo ............... 100

6

Capitulo 11 Trabalhando com a classe Scene ...................................... 110

Capitulo 12 Criando Personagens (A Classe Character) ....................... 125

Capitulo 13 Trabalhando com HUD ..................................................... 146

13.1) Criando uma HUD simples ................................................................ 146 13.2) Criando uma HUD personalizada ..................................................... 150

Capitulo 14 Programao com Inteligncia Artificial (I.A) ................... 157

14.1) Definindo movimentos aleatrios para um elemento de jogo ............ 157 14.1.1) Melhorando o cdigo : No deixar o inimigo sair da tela................ 165 14.1.2) Melhorando o cdigo : Gerando inimigos de cores aleatrias ....... 168 14.2) Algoritmo de I.A para perseguio de personagem ......................... 171 14.3) Algoritmo de I.A para perseguio e ataque ao personagem ........... 176

Capitulo 15 Msicas e sons no jogo .................................................... 192

15.1) A classe MediaPlayer ....................................................................... 192 15.2) A classe SoundPool .......................................................................... 192 15.3) Desenvolvendo o jogo....................................................................... 193

Capitulo 16 Trabalhando com mais de uma tela no jogo ..................... 204

Capitulo 17 Desenvolvendo um jogo completo ................................... 225

17.1) Sobre o jogo Alex Kidd Shinobi World ........................................... 225 17.2) Desenvolvendo nosso jogo ............................................................... 225

Capitulo 18 Publicando seus jogos Android no Google Play ................ 267

Apndice Sites e ferramentas para a criao de sprites e sons .......... 269

Concluso a respeito do material ........................................................ 273

7

Capitulo 1 Introduo ao desenvolvimento de jogos

ntes de comearmos a desenvolver os nossos jogos para a plataforma

Android, precisamos ter em mente o que vem a ser um jogo (de um modo

geral). Um jogo nada mas do que uma aplicao (programa),

desenvolvida e destinada somente para o entretenimento. Atualmente

encontramos jogos dos mais diversos gneros para os mais diversos pblicos.

Vejamos agora alguns ttulos conhecidos de jogos que existem hoje em dia:

Angry Birds (Android)

A

8

Jetpack Joyride (Android)

Benji Bananas (Android)

Para desenvolvermos um jogo, naturalmente, precisamos ter algumas coisas em

mente : seu inicio, meio e fim (histria do jogo de modo geral, no importando seu

gnero) ; as ferramentas que vamos utilizar para desenvolver os jogos e

programadores/artistas que estaro envolvidos no projeto do jogo.

Aqui nesta apostila estaremos utilizando como ferramenta para o

desenvolvimento do nosso jogo, a ferramenta Eclipse juntamente com o Android

SDK (usando o Android Developer Tools) e para executarmos os nossos jogos

estaremos utilizando o emulador BlueStacks.

9

Capitulo 2 Viso geral sobre o Google Android

omo vamos desenvolver jogos para o Android, neste captulo irei falar a

respeito da plataforma e de sua arquitetura de forma geral, pois desta

forma teremos conhecimento e base suficiente para desenvolver jogos

para o Android, avaliando hardware e verses da plataforma.

2.1) Sobre o Android

O Android uma plataforma desenvolvida pela Google voltada para dispositivos

mveis, totalmente aberta livre (Open Source), que foi divulgada em 5 de

novembro de 2007. Inicialmente o sistema Android foi desenvolvido pelo Google

e atualmente essa plataforma mantida pela OHA (Open Handset Alliance. Visite

o link : http://www.openhandsetalliance.com), um grupo constitudo por

aproximadamente 84 empresas as quais se uniram para inovar e acelerar o

desenvolvimento de aplicaes e servios, com o objetivo e trazer aos

consumidores uma experincia mais rica em termos de recursos, menos

dispendiosa em ternos financeiros para o mercado mvel.

Um dos primeiros SmartPhones que ofereceu suporte a esse sistema operacional

foi o G1 da empresa T-Mobile. Confira na imagem seguinte:

C

10

G1 - T-Mobile

Atualmente o sistema Android se encontra hoje disponvel tanto em SmartPhones

quanto nos Tablets. Confira abaixo alguns dos dispositivos encontramos hoje no

mercado com o sistema operacional Android:

SmartPhone Samsung Galaxy S3

11

Tablet Samgung Galaxy Note

2.2) Estrutura Geral da plataforma Google Android

O Android SDK uma ferramenta de desenvolvimento que disponibiliza um

conjunto de APIs necessrias para desenvolver aplicaes para a plataforma

Android, utilizando a linguagem Java.

Vamos conhecer os recursos encontrados nessa plataforma:

- Application framework: Permite a reutilizao e substituio de componentes ;

- Dalvik virtual machine: uma Mquina Virtual Java (JVM) voltada para

dispositivos mveis ;

- Browser Integrado baseado no webkit engine ;

- Grficos Otimizados O Android constitudo por bibliotecas 2D e 3D baseada

na especificao OpenGL ES 1.0 ;

12

- SQLite: Sistema Gerenciador de Banco de Dados (SGBD) j embutido no

Android para guardar dados ;

- Suporte multimdia: A plataforma j oferece para udio, vdeo e formatos de

imagem (MPEG4, H.264, MP3, AAC, AMR, JPG, PNG, GIF) ;

- Telefonia GSM (dependente de hardware) ;

- Bluetooth, EDGE, 3G, e WiFi (dependente de hardware) ;

- Cmera, GPS, compasso, e acelermetro (dependente de hardware) ;

- Rico ambiente de desenvolvimento , incluindo um emulador de dispositivo,

ferramentas de depurao, memria, performance e um plugin para o Eclipse

(ADT) ;

13

2.2.1) A arquitetura do Android

Arquitetura geral da plataforma

2.2.2) Aplicaes

O Android nos fornece um conjunto de aplicaes fundamentais, so elas:

- um cliente de e-mail;

- programa de SMS;

- agenda;

- mapas;

- navegador;

- contatos entre outros.

14

Todos os aplicativos acima presentes no Android foram desenvolvidos na

linguagem de programao Java.

O Android nos fornece um conjunto de bibliotecas C/C++ utilizadas por vrios

componentes do sistema. Veja algumas das bibliotecas abaixo:

- System C library: Consiste em uma implementao derivada da biblioteca C

padro baseado no sistema (libc) do BSD sintonizada para dispositivos rodando

Linux.

- Media Libraries: Baseado no PacketVideos OpenCORE; so as bibliotecas que

suportam os mais diversos formatos de udio e vdeo, incluindo tambm imagens.

- Surface Manager: Responsvel pelo acesso ao subsistema de exibio bem

como as mltiplas camadas de aplicaes 2D e 3D;

- LibWebCore: Consiste em um web browser engine utilizado tanto no Android

Browser quanto para exibies web.

- SGL o engine de grficos 2D

- 3D libraries: Uma implementao baseada no OpenGL ES 1.0 APIs; As

bibliotecas utilizam acelerao 3D via hardware (quando disponvel) ou o software

de renderizao 3D altamente otimizado includo no Android.

- FreeType Biblioteca responsvel pela renderizao de fontes bitmap e vector;

- SQLite Conforme j mencionado, consiste no sistema gerenciador de banco

de dados (SGBD) relacional disponvel para todas as aplicaes.

2.2.3) Android Runtime

O Android constitudo por um conjunto de bibliotecas que fornece a maioria das

funcionalidades disponveis nas principais bibliotecas da linguagem Java.

Toda aplicao Android roda em seu prprio processo, com sua prpria instncia

da mquina virtual Dalvik. O Dalvik foi escrito de forma a executar vrias VMs

eficientemente. Ele executa arquivos .dex, que otimizado para consumo mnimo

de memria. A VM baseada em registros e roda classes compiladas pela

15

linguagem Java que foram transformadas em arquivos .dex, atravs da

ferramenta dx includa no SDK.

O Dalvik VM foi baseado no kernel do Linux para funcionalidades subjacentes

como o encadeamento e a gesto de baixo nvel de memria.

2.2.4) Linux Kernel

O Android foi projetado em cima da verso 2.6 do kernel do Linux para os

servios centrais do sistema, tais como segurana, gesto de memria, gesto de

processos, etc. O kernel tambm atua como uma camada de abstrao entre o

hardware e o resto do software.

2.3) Para qual verso do Android devemos desenvolver os

nossos jogos ?

Quando vamos desenvolver um jogo para um determinado sistema operacional,

normalmente, precisamos fazer a seguinte pergunta : Para qual verso do S.O

devemos desenvolver ?

Considero esse um dos pontos mais importantes que devemos refletir antes de

desenvolvermos um jogo. Como neste material iremos desenvolver jogos voltados

para a plataforma Android, devemos pensar para qual verso da plataforma

precisamos desenvolver.

1.3.1) Qual verso da plataforma Android a mais utilizada no momento ?

Para falar a respeito dessa situao, irei mostrar aqui um grfico que mostra quais

verses do Android so as mais usadas no mundo todo :

16

Grfico de Estatstica a respeito do S.O Android mais usado

O grfico da esttica acima foi feito em outubro de 2013, onde nele podemos

observar que as verses do Android mais utilizadas so o Jelly Bean (verso 4.1

4.3), Gingerbread (verso 2.3) e Ice Cream Sandwich (verso 4.0). As verses

mais antigas do Android como Eclair (verso 2.1) e Donut (verso 1.6) j nem so

mais citadas e faladas hoje em dia, e a verso KitKat ,a nova verso do Android

(Verso 4.4), ainda est comeando a se popularizar.

Hoje em dia se fomos a alguma loja para comprar um aparelho (Smartphone ou

Tablet Android) iremos adquiri-lo, naturalmente, com o S.O Android na verso 4.1

para cima. Se olharmos por esse ponto de vista, devemos pensar em

desenvolvermos nossa aplicao utilizando como base a verso 4.1, mas, em

nosso material iremos utilizar como base a verso do Android 4.0 .

1.3.2) O Publico

Outro fator muito importante , e que destaco aqui , a questo O PUBLICO.

Nesse fator , a questo S.O deveria ser deixada teoricamente de lado, visto que

muitos usurios ainda possuem aparelhos Android com uma verso mais antiga

(como a verso 2.3 e 2.2), logo, devemos pensar tambm nesses usurios para

usufruir dos nossos jogos desenvolvidos.

17

1.3.4) Hardware e Processamento

Outro fator muito importante, que deve ser levado tambm em considerao, alm

da verso do S.O, (quando se trata de desenvolvimento de jogos) a questo

Hardware e Processamento. Existe uma grande diferena entre desenvolver uma

aplicao (para uso de uma forma geral) e desenvolver um jogo.

Naturalmente um jogo, dependendo do seu porte, exige de certa forma de um

bom hardware (envolvendo processamento, GPU e etc.). Quando pensamos em

adquirir um aparelho (como um tablet Android por exemplo), devemos avaliar as

suas especificaes de hardware , que acompanham o produto.

Naturalmente os tablets genricos que encontramos em algumas lojas, que

acompanham uma verso popular do Android, nem sempre possui uma

especificao de hardware adequada para jogos (principalmente para jogos em

3D ou jogos que exijam recursos como acelermetro, multi-toque e etc). Fique

muito atento as especificaes do aparelho.

1.3.3) Qual prioridade devemos dar : Publico ou (Verso do S.O / Hardware)

?

Agora a questo : Como combinar a questo PUBLICO e VERSO do S.O /

Hardware para desenvolvermos um jogo ? Como se trata do desenvolvimento do

jogo, a prioridade que devemos dar em primeira instncia e verso do S.O em

conjunto com Hardware, visto que naturalmente os jogos so mais exigentes em

requisitos de hardware e sistema que a maioria das aplicaes em geral. Como

nessa apostila iremos trabalhar com jogos no estilo 2D, os requisitos exigidos

para um tablet (ou smartphone) Android so os mais essenciais possveis para

rodar games dessa categoria.

18

Capitulo 3 Instalando e Configurando o Android Developer Tools

ara a elaborao desse material eu fiz o uso do Android Developer Tools

(que na verdade a ferramenta Eclipse em conjunto com o Android SDK).

Qualquer verso (de preferncia superior) do programa citado acima

serve. Para que toda essa aplicao funcione necessrio que voc tenha

instalado, antes de tudo, a Mquina Virtual Java (de preferncia a verso 6 ou

posterior). Bom, mos a obra.

Para saber se voc possui uma Maquina virtual Java entre no prompt de comando

de digite a seguinte linha:

java version

Se mostrar algo parecido como demonstra a figura seguinte:

Maquina Virtual Java instalada no computador

Significa que voc possui uma mquina virtual Java instalada no seu computador,

caso contrrio, instale o JRE. Voc pode fazer o download do Java pelo link

abaixo:

http://www.oracle.com/technetwork/java/javase/downloads/index.html

P

19

3.1) Efetuando o download e configurando o ADT

Conforme havia falado, a ferramenta que iremos utilizar aqui para a construo

dos nossos jogos o ADT (Android Developer Tools), que consiste no Eclipse

configurado com o Android SDK. A linguagem que utilizaremos para criar as

aplicaes ser a linguagem Java, na qual a ferramenta d suporte. Para

realizarmos do download desta ferramenta basta visitarmos o seguinte link

abaixo:

http://developer.android.com/sdk/index.html

Depois de visitar o link ser aberta a seguinte pgina, conforme demonstra a

figura seguinte:

Site do Android Download do ADT

Para efetuarmos do download do Android Developer Tools basta clicarmos no

boto Download the SDK. Feito isso ser aberta uma tela de contrato de termos

e condies, onde nela voc vai confirmar os termos de contrato e selecionar a

verso sistema operacional (32 bits ou 64 bits). Depois de escolher o sistema

20

operacional, basta clicar no boto Download the SDK ADT Bundle for Windows

para efetuar o download da ferramenta.

A instalao da ferramenta bastante simples (como no Eclipse), bastando

descompactar o arquivo em um diretrio desejado. O diretrio de instalao do

ADT para esse caso ser o diretrio raiz C:\. Ao descompactar o arquivo da

aplicao, certifique-se de que foi gerado o diretrio C:\ adt-bundle-windows-x86

(ou C:\ adt-bundle-windows-x86_64, caso o sistema escolhido seja de 64 bits) :

Contedo do diretrio adt-bundle-windows-x86

A ferramenta de desenvolvimento se encontra dentro do diretrio eclipse, basta

isso basta acessar o diretrio eclipse. Feito isso, voc ver o seguinte contedo:

21

Contedo do diretrio eclipse

Para executarmos o Android Developer Tools basta clicar no cone (de cor roxa)

escrito eclipse. Quando a ferramenta executada pela primeira vez, ser

solicitado um diretrio de Workspace (diretrio de trabalho), que o local no

qual o Eclipse vai gerar os projetos, conforme voc confere na figura seguinte:

Diretrio do Workspace

Escolha o diretrio desejado para seu Workspace e , caso voc deseje que ela

seja definitivo, marque a opo Use this as the default and do not ask again.

Depois disso clique em OK.

22

Feito isso, o ambiente de programao Eclipse ser carregado, conforme

demonstra a figura seguinte:

Ambiente de programao Eclipse (ADT)

Agora vamos fechar a guia Android IDE para encerrarmos a tela de Welcome! .

Feito isso veremos a seguinte tela abaixo:

23

Ambiente de programao Eclipse (ADT)

A ferramenta Android Developer Tools nos fornece um emulador Android, onde

atravs dele podemos rodar , executar e testar as nossas aplicaes, mas, nessa

apostila NO IREMOS FAZER USO deste emulador que acompanha o Android

Developer Tools.

A razo pela qual no iremos fazer uso do emulador que acompanha o ADT

bem simples : O emulador roda perfeitamente aplicaes comuns para uso de

forma geral, porm, quando vamos executar um jogo, seu desempenho para

executar o mesmo PSSIMO, pois a emulao fica muito lenta e com muitos (e

muitos) lags.

Para testarmos os nossos jogos iremos fazer uso de um emulador separado (e

tambm bastante conhecido por executar jogos Android) chamado BlueStacks.

24

Capitulo 4 Instalando e Configurando o emulador BlueStacks

ara executarmos os nossos jogos desenvolvidos na ferramenta Android

Developer Tools, iremos fazer uso de um chamada BlueStacks, bastante

conhecido por rodar especialmente jogos para Android.

A instalao do emulador BlueStacks requer que seu computador possua

obrigatoriamente os drives de vdeo. (caso contrrio, ele ir exigir que voc

instale atualize os drives).

Para efetuarmos o download da ferramenta BlueStacks basta visitar o seguinte

link abaixo:

http://www.bluestacks.com

Feito isso ser aberta a seguinte pgina abaixo:

P

25

Pgina oficial do emulador BlueStacks

Feito isso basta clicarmos no boto Download situado na pgina e

automaticamente seremos redirecionamos para uma outra pgina e , em seguida,

a caixa de dilogo de download surgir em seguida:

Caixa de dilogo de download

Faa o download da ferramenta e em seguida, aps o termino do download,

vamos executar a instalao da aplicao. Feito veremos a seguitnte tela abaixo:

26

Caixa de dilogo Instalao do BlueStacks

Clique no boto Continue para prosseguirmos com a instalao. Na caixa de

dilogo a seguir:

27


Vamos deixar o caminho do jeito que estar e clique em Next para avanarmos.

Na prxima caixa de dilogo :

28


No ser necessria fazer nenhuma alterao (fique a vontade caso voc deseje

modificar as opes acima). Clique no boto Install para iniciar a instalao.

A instalao depende do uso da Internet, logo, os todos os arquivos de instalao

da ferramenta sero baixados do site (dependendo de sua Internet, esse

processo poder demorar um pouco, tenha pacincia!), conforme voc confere

em seguida:

29

Caixa de dilogo Instalando o BlueStacks

Aps concluir a instalao, automaticamente voc ver que ele j executar o

emulador em tela cheia, conforme voc confere logo em seguida:

30

Emulador em execuo (modo tela cheia)

Para sairmos do modo tela cheia basta clicar no boto Restaurar, situado no

canto superior direito da tela. O resultado voc confere logo em seguida:

Executando o emulador Obtendo dados

31

Mesmo com o emulador em execuo, ele ainda est executando ainda um

download de dados. Aguarde ele terminar esse processo (dependendo de sua

Internet, esse processo poder demorar um pouco, tenha pacincia!).

Depois de todo o processo acima concludo, ser exibida a seguinte tela:

Emulador BlueStacks em execuo

Bom , agora vamos fechar o nosso emulador.

Configurando a resoluo de tela do emulador

O emulador BlueStacks j possui uma resoluo padro (que normalmente

1280x720). Mas, e se eu quisesse alterar a resoluo dele (Para 800x480, que

ser a resoluo que vamos trabalhar na apostila) ? O emulador BlueStacks NO

OFERECE nenhuma configurao para modificar atravs dele sua resoluo,

mas, essas informaes esto guardadas em uma chave de registro do Windows

(que vamos precisar mexer para definirmos a nossa resoluo desejada). Vamos

no menu iniciar do Windows e em seguida chame a opo Executar. Dentro da

caixa de dilogo digite regedit, conforme abaixo:

32

Caixa de dilogo Executar do Windows

Clique em OK para executarmos o editor de registros do Windows, conforme

voc pode conferir na figura seguinte:

Editor de Registro do Windows

33

Agora vamos entrar no seguinte caminho :

HKEY_LOCAL_MACHINE\SOFTWARE\BlueStacks\Guests\Android\FrameBuffer\

0.

Vejamos o resultado abaixo:

Chave de Registro do Windows

Modifique os valores de Width (largura) e Altura (Height) respectivamente para

800 e 480 (em decimal), conforme podemos conferir na figura abaixo:

34

Pronto!!! Feito isso nosso emulador ir executar na resoluo que configuramos.

Porm, para que o emulador execute conforme nossas confuraes, vamos na

barra de tarefas encontrar o cone da aplicao BlueStacks, e em seguida clique

com o boto direito sobre o cone e selecione Restart:

Feito isso nosso emulador ser recarregado e executado conforme nossas

configuraes feitas na chave de registro. Veja o resultado abaixo:

35

Emulador em execuo Na resoluo 800x480

36

Capitulo 5 Comeando a desenvolver jogos para Android

epois de tudo configurado e instalado, conforme foi mostrado nos

captulos anteriores, vamos a partir de agora comear a desenvolver

nossos jogos para a plataforma Android.

Conforme havia falado, para criarmos os nossos jogos aqui no ADT, iremos

utilizar um framework que eu mesmo desenvolvi que vai facilitar muito o processo

de desenvolvimento de jogos (chamado GameUtil2D, em breve o mesmo ganhar

um site : http://www.gameutil2d.org ). O framework j acompanha este material

(que o arquivo GameUtil2DV1_1.zip).

Para usarmos esse framework de projeto precisaremos importar esse modelo

para o ADT, para podermos desenvolver nossos jogos. Para importar o modelo

basta irmos no menu File / Import. Feito isso, dever ser aberta a seguinte tela

conforme mostra a figura seguinte:

D

37

Caixa de dilogo - Import

Se observamos a caixa de dilogo acima, existem vrias pastas onde em cada

uma delas existe um conjunto de opes. Para importarmos um projeto vamos

expandir a pasta General e em seguida iremos selecionar a opo Existing

Projetcs into Workspace, conforme exibido na figura abaixo:

38


Clicando em Next avanamos para a prxima etapa, que consiste na seleo do

projeto que ser utilizado no ADT, conforme mostrada na figura seguinte:

39


Na caixa de dilogo acima vamos selecionar a opo Select archive file, e em

seguida vamos clicar no boto Browse... para selecionarmos o nosso modelo de

projeto (o arquivo GameUtil2DV1_1.zip, que acompanha este material). Depois

de selecionado o arquivo, na lista Projects vai estar sendo exibido o modelo de

projeto que ser utilizado no ADT, conforme voc v na figura seguinte:

40


Para importarmos o nosso projeto basta clicarmos no boto Finish e pronto, j

podemos utiliz-lo para construirmos os nossos jogos. Vejamos o nosso projeto

no ADT, conforme mostra a figura seguinte:

Projeto importado para o ADT

41

5.1) - Conhecendo a estrutura geral do projeto Android para jogos

Ns vamos utilizar para a construo dos nossos jogos para Android, um

framework (que eu mesmo desenvolvi) voltado para o desenvolvimento de

aplicativos desta categoria. Vamos conhecer abaixo toda a estrutura (de arquivos

e pastas) que compem este projeto.

Se visualizarmos o lado esquerdo, existe uma seo chamada Package

Explorer, onde nela existe uma pasta chamada GameUtil2DCanvas (que o

nosso projeto), constitudo por vrios subdiretrios , que por sua vez, possui seus

respectivos arquivos. Se expandirmos a pasta do projeto, veremos uma estrutura

de diretrios e pacotes conforme demonstra a figura seguinte:

Package Explorer

Irei comentar agora toda a estrutura de um projeto Android. Ele composto por

vrias pastas e arquivos, cada um com uma finalidade em especifico.

O diretrio src (source)

Vamos comear conhecendo primeiramente o diretrio src (source). Dentro

desse diretrio temos todos os arquivos de extenso .java que fazem parte de

42

uma aplicao Android. Se ns expandirmos essa pasta encontraremos uma

srie de arquivos, todos eles organizaes em seus respectivos pacotes,

conforme voc pode conferir na figura seguinte:

Package Explorer

Irei explicar agora a finalidade de cada pacote e de seus respectivos arquivos:

O pacote gameutil2d.project

Esse pacote constitudo por um arquivo principal, que ser a classe que iremos

trabalhar daqui por diante:

GameMain.java : Esse o arquivo principal do projeto, nele que entramos

com o cdigo do jogo.

43

Conforme vimos acima, o arquivo no qual iremos mexer para escrever nossos

jogos o arquivo GameMain.java. Se clicarmos duas vezes no arquivo, veremos

o seguinte contedo:

package gameutil2d.project; import gameutil2d.framework.*; import android.content.Context; import android.graphics.Canvas; import android.view.MotionEvent; import gameutil2d.classes.basic.*; import gameutil2d.classes.scene.*; import gameutil2d.classes.character.*; import gameutil2d.classes.text.*; public class GameMain { public GameMain(Context context) { /* Construtor da classe GameMain * Nesse mtodo inicializamos todas as variveis de controle, * objetos e entre outros elementos do jogo (imagens, animaes * e personagens)*/ //Insira seu cdigo aqui } public void onScreenLoading(int w, int h, OrientationMode orientation) { /* Mtodo que executado logo aps o construtor da classe * GameMain aqui carregamos todos os elementos (imagens, * animaes, personagens) que dependam das informaes de * largura (w) e altura (h) da tela do jogo, incluindo tambm * sua orientao (orientation) */ //Insira seu cdigo aqui } public void Update() { //Mtodo responsvel pela execuo da lgica do jogo (movimento, * ao, colises e etc.) */ //Insira seu cdigo aqui }

44

public void Draw(Canvas canvas) { //Mtodo responsvel por desenhar todos os elementos do jogo na * tela (atravs do objeto "canvas") //Insira seu cdigo aqui } public void onTouch(MotionEvent e) { //Mtodo executado quando ocorre algum evento de toque sobre a * superficie da tela */ //Insira seu cdigo aqui } public void onExitGame() { / * Mtodo que executado quando o jogo encerrado * Adequado para a finalizao de threads e msicas de fundo do * jogo*/ //Insira seu cdigo aqui } }

O cdigo acima a estrutura padro da classe GameMain (arquivo

GameMain.java) no qual iremos escrever o cdigo para o desenvolvimento do

nosso jogo. Essa classe constituda pelos seguintes mtodos:

GameMain: Esse o mtodo construtor, executado toda vez que o jogo

executado. So neles que carregamos todos os objetos e iniciamos as variveis

que sero utilizados no jogo. Veja sua sintaxe:

public GameMain(Context context)

onScreenLoadling: Esse sempre logo aps a execuo do mtodo GameMain ,

nele carregamos objetos e entre outros elementos que dependam das

informaes bsicas da tela do dispositivo (como largura, altura e orientao do

mesmo). Veja sua sintaxe:

public void onScreenLoading(int w, int h, OrientationMode orientation)

45

Irei explicar agora a finalidade de cada parmetro acima:

w : Retorna a largura atual da tela, em pixels.

h : Retorna a altura atual da tela, em pixels.

orientation : Retorna a orientao da tela do dispositivo.

Update: Esse mtodo executado sempre durante a execuo do jogo, e

tambm o primeiro a ser executado. Ele responsvel por executar a lgica

de processamento do jogo (movimento,aes e etc.). Vejamos a sua sintaxe:

public void Update()

Draw: Esse mtodo executado sempre durante a execuo do jogo, e

executado alternadamente com o mtodo Update. Ele responsvel por

desenhar a tela do jogo, ou seja, deseja todos os elementos na tela do dispositivo.

Vejas a sua sintaxe:

protected void Draw(Canvas canvas)

Esse mtodo possui um parmetro chamado canvas, que representa a tela do

dispositivo, no qual vamos utilizar para desenhar os elementos do jogo.

onTouch: Esse mtodo disparado toda vez quando ocorre um touch screen,

ou seja, quando tocamos a tela do dispositivo. Esse mtodo dispara ou quando

pressionamos (tocamos) na tela com o dedo, ou quando arrastamos o dedo

pela tela ou quando tiramos o dedo do dispositivo. Vejamos a sua sintaxe:

public boolean onTouch (MotionEvent e)

O parmetro e guarda todas informaes do evento, como as coordenadas onde

ocorreu o toque na tela do dispositivo, e tambm o tipo do toque que ocorreu

(pressionamento, movimento (drag) ou liberao).

46

onExitGame:Esse mtodo disparado quando o jogo (aplicativo) encerrado.

Ele bastante til para finalizarmos alguma atividade antes do jogo acabar como

o encerramento de uma msica ou para liberar objetos da memria e etc.

O pacote gameutil2d.classes.basic

Nesse pacote esto contidos as classes bsicas que iremos utilizar para a

construo dos nossos jogos. Vejamos abaixo quais so essas classes e a

finalidade de cada uma (que ser demonstrada nos captulos posteriores) :

Image.java : Esse arquivo (ou classe) utilizado quando queremos exibir

uma imagem na tela em um jogo.

AnimationSprites.java: Esse arquivo (ou classe) utilizado para realizar

animaes de sprites em um jogo.

Collision.java : Esse arquivo (ou classe) utilizado para detectar colises

entre dois elementos em um jogo.

FlipEffect.java : Classe utilizada para inverter uma imagem (ou um

conjunto de imagens de uma animao de sprites) na horizontal.

GameElement.java: Essa a base utilizada para a construo da maioria

das classes citadas acima (e de algumas outras classes que sero citadas

em seguida), e de bastante utilidade para a construo de outros elementos

do jogo por parte do usurio.

Box.java : Classe utilizada somente para definir pontos de coliso,

bastante til para a construo de jogos baseados em plataforma (muito

utilizada em conjunto com as classe Character e Scene).

GameState.java: Essa classe possui somente uma finalidade : guardar o

status do jogo, ou seja, se ele est no modo pausa ou no modo play.

47

O pacote gameutil2d.classes.character

Nesse pacote existe somente uma classe, destinada para a criao de

personagens (para jogos no estilo plataforma).

Character.java : Esse arquivo (ou classe) utilizado para a construo de

personagens, que iremos utilizar em um jogo.

O pacote gameutil2d.classes.scene

Nesse pacote existe somente uma classe, destinada para a criao de cenrios

do jogo.

Scene.java : Esse arquivo (ou classe) utilizado para representar uma

cena do jogo, e quais elementos estaro presentes nele.

O pacote gameutil2d.classes.text

Nesse pacote existe somente uma classe, destinada para a exibio de

informaes na tela do jogo.

TextDrawable.java : Esse arquivo (ou classe) utilizado para exibir

informaes na tela do jogo (mensagens, textos etc.).

O diretrio res (resources)

Dentro da estrutura do projeto Android existe um diretrio chamado res

(resources), onde dentro dele colocamos todos os recursos que podemos utilizar

em um jogo no Android (como imagens, sons, msicas e etc). Vamos conhecer os

subdiretrios existentes dentro dessa pasta e a finalidade de cada um deles.

48

Os diretrios drawable-hdpi, drawable-mdpi , drawable-ldpi e drawable-xhpdi.

A partir da verso 1.6 da plataforma Android foram adicionados dentro da pasta

res (resources) trs diretrios responsveis pelo gerenciamento de imagens:

drawable-ldpi, drawable-mdpi, drawable-hdpi. Nas verses do Android 2.2 em

diante , podemos encontrar dentro da pasta do projeto (alm dos diretrios

citados), tambm o diretrio drawable-xhdpi . Todos esses diretrios possuem a

mesma finalidade : armazenar imagens que sero utilizadas por uma aplicao

em Android. Agora , qual a diferena que existe entre esses diretrios ? Cada um

desses diretrios ser utilizado de acordo com a resoluo do dispositivo Android

em uso.

Um dispositivo Android possui naturalmente as seguintes resolues : HVGA,

QVGA, WVGA e etc. Por exemplo, uma resoluo QVGA (320x240) possui uma

densidade baixa (low density ldpi), logo, se voc criar uma aplicao para

dispositivos desse tipo de configurao, o diretrio que voc utilizar para guardar

suas imagens ser o drawable-ldpi.

Uma resoluo HVGA (320x480) possui densidade mdia (medium density

mdpi), logo, se voc criar uma aplicao para dispositivos desse tipo de

configurao, o diretrio que voc utilizar para guardar suas imagens ser o

drawable-mdpi.

Uma resoluo WVGA (800x480 , resoluo de um Tablet por exemplo) possui

densidade alta (high density hdpi), porm, h algumas resolues WVGA que

suportam densidade mdia (mdium density mdpi).

Para os jogos que iremos desenvolver daqui por diante, vamos trabalhar com a

resoluo WVGA (conforme havamos configurado no nosso emulador

Bluestacks), que por padro possui densidade mdia (mdpi) , logo, todas as

imagens que vamos utilizar no jogo sero adicionadas dentro do diretrio

drawable-mdpi.

O diretrio values

Um dos recursos que o Android permite que usemos na construo de

aplicaes so constantes. Como bom programador que todos ns somos,

49

sabemos que uma constante nada mais do que um endereo de memria que

vai armazenar um determinador valor, que ser nico at o fim da execuo do

programa. Mas, o que isso tem a ver com as telas da nossa aplicao ? Vou

explicar.

Normalmente usamos constantes para armazenar valores fixos que,

naturalmente, estaro presentes na maior parte do seu programa. muito comum

criarmos um ttulo como nome de uma aplicao (como por exemplo : Alpha

Software), que vai estar presente na maioria das telas (ou em todas) da sua

aplicao. Imagine voc digitar manualmente o nome de seu software em todas

as telas da sua aplicao, seria um processo trabalhoso voc no acha ? Agora

imagine futuramente que voc precise mudar o nome de sua aplicao ? Voc

ter novamente o mesmo trabalho para digitar em cada tela o nome da nova

aplicao, sem dvida. Usando constantes, voc no ter esse trabalho.

Dentro dessa pasta temos os seguintes arquivos:

- strings.xml : Esse arquivo guarda constantes relacionadas nossa aplicao

em geral (como o nome da aplicao, o ttulo que vai aparecer na aplicao e

etc.).

- dimen.xml : Esse arquivo guarda constantes relacionadas as dimenses que

podemos utilizar em nossa aplicao.

- styles.xml : Esse arquivo guarda constantes relacionadas estilos que

podemos utilizar em nossa aplicao.

Definindo o nome de um projeto

Como voc percebeu, o nome do nosso projeto no Eclipse (ADT) se chama

GameUtil2DCanvas, mas, se eu quiser um outro nome para esse projeto (como

por exemplo Meu Primeiro Jogo), visto que todos os nossos projetos que iremos

criar ser a partir deste modelo ? Para darmos um novo nome para o projeto,

basta selecion-lo e em seguida pressionar a tecla F2, para renomear o projeto

com um novo nome, conforme voc pode conferir na figura abaixo:

50

Caixa de dilogo Rename Java Project

Agora vamos renomear o nosso projeto com o seguinte nome : Meu Primeiro

Jogo. Confira como ficou na figura seguinte:

Caixa de dilogo Rename Java Project

Depois de escrever o novo nome do projeto basta clicar em OK para que o

projeto seja renomeado. Confira o resultado na figura seguinte:

51

Projeto renomeado

Se lembra do arquivo strings.xml, que responsvel por guardar constantes de

uma aplicao ? Pois bem, uma das constantes desse arquivo armazena o nome

do projeto e uma outra constante armazena o nome da aplicao (jogo). Vamos

abrir o contedo desse arquivo, e o resultado voc confere na figura seguinte:

Contedo do arquivo strings.xml

Se ns observarmos acima, temos as seguintes constantes:

app_name : Apesar do nome (app_name, de Application Name), essa

constante guarda no nome do projeto.

Para visualizarmos o contedo de uma das constantes acima, basta selecionar a

constante desejada. Veja na figura seguinte:

52

Constante app_name selecionada

Quando selecionamos uma constante, so exibidos dois campos:

Name : Guarda o nome da constante (podendo o mesmo ser alterado)

Value : Armazena o valor que a constante est assumindo (podendo o mesmo

ser alterado)

Para essa situao, estaremos alterando o contedo que a constante est

armazenando. A constante app_name armazena o valor GameUtil2D V1.1.

Vamos substituir o valor armazenado por essa constante pelo seguinte nome :

Meu Primeiro Jogo.

Feito isso, vamos salvar as alteraes feitas nesse arquivo (pressionando as

teclas CTRL+S).

Definindo o cone da aplicao (jogo)

Para definirmos o cone da aplicao , devemos escolher uma imagem que v

represent-la (normalmente se usa uma imagem de extenso PNG de dimenso

48x48 pixels).

Por padro, esse modelo j possui um cone padro que vai representar a

aplicao, mas, voc pode alterar esse cone. Para definirmos a imagem que vai

ser o cone da aplicao, devemos fazer algumas configuraes no arquivo

53

AndroidManifest.xml (esse arquivo considerado o sistema nervoso do

Android, nele que definimos as principais caractersticas e permisses da nossa

aplicao). Vamos dar um duplo clique no arquivo, e o mesmo ser aberto

conforme mostra a figura seguinte:

Contedo do arquivo AndroidManifest.xml

Se voc observar a figura acima, existe uma guia chamada Application, vamos

clicar nela para carregar essa seo, conforme demonstra a figura seguinte:

54

Contedo do arquivo AndroidManifest.xml Seo Application

Se ns observamos acima existe um campo chamado Icon, nele que

definimos o cone da nossa aplicao (jogo). Lembre-se, como o cone vai ser

uma imagem que vamos utilizar, todas as imagens que estaremos utilizando na

nossa aplicao devem estar dentro do diretrio drawable-mdpi. Aps definir o

cone da aplicao, salve o arquivo AndroidManifest.xml para que as alteraes

tenham efeito.

Para esse exemplo (e os posteriores), vamos utilizar o cone padro do projeto.

Executando o jogo

Para executarmos o nosso jogo feito no Android, basta clicarmos com boto

direito sobre o projeto (Meu Primeiro Jogo) e em seguida selecionar a opo Run

As, feito isso selecione Android Application, conforme demonstra a figura

seguinte:

55

Executando a aplicao

Feito isso o projeto ser compilado e em instantes ser aberto uma caixa de

dilogo, pedindo que voc escolha o dispositivo a ser utilizado, conforme voc

confere em seguida:

56

Caixa de dilogo Android Device Chooser

Essa caixa de dilogo aparece porque o Android Developer Tools reconhece o

emulador BlueStacks como se fosse um dispositivo externo, logo, vamos

selecionar o nosso emulador do BlueStacks (identificado como emulator-5554) e

em seguida vamos clicar em OK.

Feito isso , nossa aplicao ser instalada no dispositivo e na barra de tarefas do

Windows surgir o seguinte balo, avisando que a aplicao foi instalada no

emulador com sucesso.

Aplicao instalada com sucesso

57

Caso seu emulador BlueStacks esteja fechado, clique no balo que surge para

que possamos executar a nossa aplicao. Vejamos a nossa aplicao em

execuo na figura seguinte:

Aplicao em execuo no emulador

A tela escura indica que no h nada na tela, que nenhum elemento est

presente no jogo, por isso este resultado ocorre.

Neste captulo conhecemos nosso framework de desenvolvimento, que iremos

utilizar para a construo dos nossos jogos (o GameUtil2D). Nos prximos

captulos vamos conhecer todas as classes que compem esta framework e como

criar vrios exemplos de jogos (e tambm jogos) atravs dela.

58

Capitulo 6 Visualizando imagens no jogo (A classe Image)

o captulo anterior conhecemos e aprendemos a manusear e a executar

uma aplicao (jogo) atravs do framework para jogos no Android. Neste

captulo iremos aprender a inserir e visualizar imagens em um jogo no

Android, atravs da classe Image , que faz parte do pacote que acompanha o

framework.

Conforme havia falado, todos os nossos projetos que iremos desenvolver,

utilizando nosso framework (o arquivo GameUtil2DV1_1.zip). Para isso vamos

importar esse arquivo, conforme j foi mostrado no captulo anterior.

Agora vamos alterar algumas propriedades do projeto, conforme podemos

conferir abaixo:

Nome do projeto : VisualizandoImagensJogo

Constante app_name : Visualizando Imagens Jogo

Depois de alterada as informaes acima, vamos abrir o arquivo GameMain.java

(que o arquivo no qual vamos escrever o cdigo do nosso jogo), que est

situado no pacote gameutil2d.project (dentro da pasta src).

Para visualizarmos uma imagem no jogo, precisamos fazer uso da classe Image ,

responsvel por essa finalidade. Para isso, dentro da classe GameMain vamos

declarar um atributo do tipo Image.

Na classe GameMain, na seo de declarao de atributos, vamos declarar um

atributo chamado imagem , conforme podemos conferir em seguida:

Image imagem;

N

59

Agora dentro do construtor da classe (o mtodo GameMain), vamos carregar o

nosso atributo (objeto), com os seguintes parmetros conforme voc confere no

cdigo abaixo:

public GameMain(Context context) { //Insira o cdigo aqui imagem = new Image(context, R.drawable. logo_gameutil2d, 0, 0, 48, 48); }

Vamos analisar os parmetros do comando inserido acima. O construtor da

classe Image possui os seguintes parmetros :

imagem = new Image(context, R.drawable.logo_gameutil2d, 0, 0, 48, 48);

O primeiro parmetro do construtor padro, cujo argumento sempre ser o

context. O segundo parmetro corresponde a imagem que vamos visualizar no

jogo (que a imagem logo_game_util2d.png).

Antes de continuarmos com a explicao dos parmetros, vamos entender essa

notao que foi utilizada para expressar a imagem que ser carregada. Observe

que o argumento utilizado para especificar a imagem a ser carregada foi

R.drawable.logo_gameutil2d.

Conforme j foi explicado, todas as imagens que vamos utilizar em uma aplicao

Android ficam do diretrio drawable-mdpi (que fica dentro da pasta res). Na

teoria, como a imagem (com diretrio e tudo), expresso dessa forma :

res/drawable-mpdi/logo_gameutil2d.png

No Android, devemos utilizar a notao:

R.drawable.logo_gameutil2d

A letra R da expresso acima, representa o diretrio res, e a palavra

drawable representa o diretrio drawable-mdpi. Se observarmos acima, o

nome da imagem no leva a extenso, pois o Android j identifica

automaticamente a imagem e sua extenso.

60

Vejamos alguns exemplos da anlise feita na tabela seguinte:

Caminho completo da imagem Como expressar no Android

res/drawable-mdpi/aviao.png R.drawable.aviao

res/drawable-mdpi/cenario.jpg R.drawable.cenario

res/drawable-mdpi/personagem.png R.drawable.personagem

Agora vamos continuar com o comentrio dos parmetros.

O terceiro e quarto parmetro do construtor correspondem , respectivamente, as

coordenadas X e Y do objeto na tela do jogo (cujos valores so 0 e 0). J o

quinto e o sexto parmetro correspondem, respectivamente, a largura e a altura

do objeto (cujo valores so 48 e 48).

Bom, o que fizemos at agora foi carregar o objeto (imagem) na memria. Agora

precisamos desenhar a imagem carregada na tela. Para isso devemos utilizar o

mtodo Draw, responsvel por esse finalidade. Dentro do mtodo Draw vamos

escrever o cdigo abaixo:

protected void Draw(Canvas canvas) { imagem.Draw(canvas); }

Se observarmos o mtodo acima, inserimos a seguinte linha de comando :

imagem.Draw(canvas);

Que responsvel por desenhar a imagem na tela, atravs do mtodo Draw.

Nesse mtodo passamos como parmetro o canvas, que representa a tela

onde a imagem ser desenhada.

Vamos conferir na figura abaixo como ficar o resultado na tela do emulador.

61

Imagem em exibio na tela

E ai, aprendeu como visualiza uma imagem na tela do jogo ? com certeza que

sim!

Vamos aproveitar esse mesmo projeto para demonstrar mais um exemplo de

visualizao de imagens. Para isso, vamos utilizar como exemplo as seguintes

imagens para nossa demonstrao : bird.png, titulo_flappy_bird.png e

background_fase_flappy_bird.png (as imagens j acompanham este material).

Conforme j havia falado, todas as imagens que vamos utilizar em um jogo fica

situado dentro do diretrio drawable-mdpi, logo, a imagem que vamos usar para

ser visualizada deve estar dentro desse diretrio. Irei mostrar aqui duas formas de

se colocar uma imagem dentro desse diretrio, sendo que comearei pela forma

mais tradicional, e depois pela forma mais fcil.

Forma tradicional

Para importar um arquivo, clique com o boto direito do mouse sobre a pasta

res/drawable-mdpi e selecione Import, depois selecione File System (Que se

62

encontra dentro da pasta General, conforme mostra a figura abaixo) e em

seguida clique em Next.

Selecionando a opo File System

Aps clicar em Next ser exibida a caixa de dilogo como demonstra a figura

abaixo:

63

Caixa de dilogo Import

Clique no boto Browse... para selecionar o diretrio onde se encontram as

imagens. Feito isso, marque os arquivos (imagens) para que ele seja importado

para a pasta res/drawable-mdpi . Veja a figura abaixo:

64

Imagem selecionada

Depois disso, s clicar em Finish para importar as imagens para o projeto.

Forma mais fcil

A segunda forma, que diria que a mais fcil de todas, voc ir at o diretrio onde se encontra as imagens , para que voc em seguida possa selecion-la, e logo aps copi-la (o famoso Ctrl+C). Feito isso v at o projeto que criamos para selecionarmos o diretrio drawable-mpdi para colarmos as imagens dentro da pasta, simplesmente dando CTRL+V (simples no ?).

Com as imagens j inserida no projeto, vamos alterar as seguintes linhas de

comandos nos mtodos que citarei abaixo. Primeiramente vamos apagar todo o

cdigo que inserimos dentro da classe GameMain.

65

Em seguida, dentro da seo de declarao de atributos, vamos declarar os seguintes objetos abaixo:

: Image bird; Image titulo_flappy_bird;

Image background_fase_flappy_bird;

Context context;

Agora dentro do mtodo construtor GameMain inserir a seguinte linha de cdigo

abaixo, conforme mostrado no cdigo abaixo:

public GameMain(Context context) {

this.context = context; }

O comando que inserirmos acima ser responsvel por guardar dentro do atributo

da classe context o contedo armazenado dentro do parmetro context do

construtor da classe GameMain. Esse armazenamento ser necessrio, pois ,

ns iremos carregar todas as imagens dentro do mtodo onScreenloading e

precisamos do context para carregarmos todas as imagens fora do mtodo

GameMain (no somente imagem mas tambm todos os objetos que precisem do

argumento context fora do construtor).

Agora dentro do mtodo onScreenLoading vamos digitar os seguintes

comandos abaixo:

public void onScreenLoading(int w, int h, OrientationMode orientation) { background_fase_flappy_bird = new Image(context, R.drawable.background_fase_flappy_bird,0,0,w,h); titulo_flappy_bird = new Image(context, R.drawable.titulo_flappy_bird, 260, 100, 280, 92); bird = new Image(context, R.drawable.bird, 370, 200, 60, 47); }

Agora dentro do mtodo Draw vamos digitar o seguinte cdigo, conforme

mostrado em seguida:

66

public void Draw(Canvas canvas) { background_fase_flappy_bird.Draw(canvas); titulo_flappy_bird.Draw(canvas); bird.Draw(canvas); }

Dentro do mtodo Draw existem trs instrues onde cada uma ir exibir uma

imagem na tela. As instrues que inserimos no cdigo, possuem uma sequncia,

que precisarei explicar.

Observe que a primeira instruo adicionada no mtodo Draw foi:

background_fase_flappy_bird.Draw(canvas);

Que ir exibir uma imagem de fundo, que a fase do famoso jogo Flappy Bird.

Em seguida, temos a seguinte instruo:

titulo_flappy_bird.Draw(canvas);

Que ir exibir o ttulo Flappy Bird na tela. Como essa a segunda imagem a ser

exibida, a mesma exibida a frente da imagem de fundo.

Na terceira instruo temos a seguinte linha de cdigo:

bird.Draw(canvas);

Que ir desenhar o passarinho (personagem) do jogo na tela. Como essa a

terceira imagem a ser exibida na tela, a mesma mostrada a frente da imagem

de fundo e do ttulo.

Aps escrevermos os cdigos acima, vamos executar a nossa demonstrao. O

resultado voc confere na figura a seguir:

67

Imagens em exibio na tela

Invertendo uma imagem na tela

A classe Image possui um mtodo chamado Draw que serve para exibirmos uma

imagem na tela. Pois bem, o mesmo mtodo possui um segundo parmetro que

permite-nos inverter a imagem exibida na horizontal, que o

FlipEffect.HORIZONTAL.

Para realizarmos essa demonstrao de inverso de imagem, vamos alterar

dentro do mtodo Draw a seguite instruo destacada em azul abaixo:

public void Draw(Canvas canvas) { background_fase_flappy_bird.Draw(canvas); titulo_flappy_bird.Draw(canvas); bird.Draw(canvas, FlipEffect.HORIZONTAL); }

68

Observe que no objeto bird (que mostra o passarinho na tela), adicionamos o

segundo argumento no mtodo Draw, o FlipEffect.HORIZONTAL. Que ir inverter

a imagem na horizontal.

Depois de alterar o cdigo , salve-o e em segudia execute a aplicao. Veja o

resultado em seguida:

Imagens em exibio na tela (com a imagem do pssaro invetida)

E ai, est aprendendo aos poucos como se cria um jogo para Android ? com

certeza que sim.

Este s um pontap inicial, nos prximos captulos iremos aprender vrias

tcnicas de desenvolvimento de jogos que sero de grande valia para seus

futuros jogos desenvolvidos para a plataforma.

69

Capitulo 7 Movendo elementos do jogo pela tela

o captulo anterior aprendemos como visualizar elementos (como

imagens) na tela, porm, as imagens vistas ficam num ponto fixo da

dela, definido pelo cdigo. Agora vamos aprender a movimentar esses

elementos pela tela do jogo, usando os recursos oferecidos pelo Android.

Neste tpico vamos aprender a movimentar os elementos do jogo usando o

touch screen (visto que atualmente, no se usa mais o movimento dos

elementos do jogo via teclado fsico).

Antes de comearmos, vamos importar o nosso framework para o ADT, pois ser

a partir dele que vamos construir nossos jogos, como fizemos anteriormente.

Depois de importar o framework, vamos alterar algumas propriedades do projeto,

conforme podemos conferir abaixo:

Nome do projeto : MovendoObjetoPelaTela

Constante app_name : Movendo Objetos Pela Tela

Depois de criado o projeto, vamos adicionar as seguintes imagens (que se

encontram presentes neste material) , que se chamam aviao.png , nuvem.png

e ceu_azul.png.

Depois de adicionar as imagens no projeto (dentro do diretrio drawable-mdpi),

vamos abrir o arquivo GameMain.java para escrevermos o cdigo do nosso

jogo.

N

70

Para comear, vamos declarar os seguintes atributos na seo de declarao de

atributos da classe GameMain :

Image aviao, nuvem, ceu_azul;

Context context;

Agora dentro do mtodo construtor GameMain, vamos adicionar os seguintes

comandos, conforme voc confere em seguida:

public GameMain(Context context) { this.context = context; aviao = new Image(context, R.drawable.aviao, 0, 0, 90, 70); nuvem = new Image(context, R.drawable.nuvem, 250, 100, 90, 70); }

Nas linhas de comando que adicionamos acima (no mtodo GameMain),

carregamos as imagens do avio e da nuvem.

Agora vamos no mtodo onScreenLoading, para adicionarmos o seguinte

cdigo:

protected void onScreenLoading(int w, int h, Orientation orientation) { ceu_azul = new Image(context, R.drawable.ceu_azul, 0, 0, w, h); }

Na linha que adicionarmos no mtodo acima, carregamos a imagem do cu azul.

Agora a pergunta que eu fao : Por qu que carregamos a imagem do cu azul

nesse mtodo ? A resposta simples, simplesmente porque precisamos que a

imagem do cu azul se ajuste ao tamanho da tela, logo, a largura e a altura da

tela dever ser as mesmas do tamanho da tela.

Neste mtodo temos os seguintes argumentos, w que armazena a largura da tela

e h que armazena a altura da tela. Esses valores foram passados como

argumentos no construtor da imagem do cu azul, como podemos conferir em

seguida:

ceu_azul = new Image(context, R.drawable.ceu_azul, 0, 0, w, h);

71

Agora vamos no mtodo Draw para adicionarmos as seguintes linhas de

comando:

protected void onDraw(Canvas canvas) { ceu_azul.Draw(canvas); nuvem.Draw(canvas); aviao.Draw(canvas); }

Nas linhas de comando que adicionarmos acima, todas elas, desenham as

imagens na tela do jogo. Agora, as linhas de comando acima foram adicionadas

na seguinte sequencia:

A primeira linha de comando que adicionarmos, desenha a imagem do cu azul

na tela, at ai tudo bem. Na linha seguinte desenhamos a nuvem na tela, essa

nuvem ser desenhada na frente da imagem do cu azul. Por ltimo,

desenhamos a imagem do avio, e esse avio ser desenhado na frente da

imagem da nuvem e do cu azul (conforme j foi explicado no captulo anterior,

mas sendo reforado neste captulo).

Depois de escrever o cdigo , vamos executar nossa aplicao e conferir os

resultados:

72

Jogo em execuo

Por enquanto, s conseguimos visualizarmos o nosso avio, mas, no podemos

moviment-lo pela tela ainda.

Como havia falado, iremos movimentar os objetos via touch screen (neste caso

aqui, o avio).

Vamos voltar na seo de declarao de atributos, e l vamos declarar as

seguintes instrues, como segue:

enum Sentido { PRA_FRENTE, PRA_TRAS, PRA_CIMA, PRA_BAIXO, PARADO } Sentido sentidoAviao = Sentido.PARADO;

Image seta_direita, seta_esquerda, seta_cima , seta_baixo;

Agora dentro do mtodo onScreenLoading vamos digitar as seguintes instrues

destacadas em azul abaixo:

public void onScreenLoading(int w, int h, OrientationMode orientation) {

73

ceu_azul = new Image(context, R.drawable.ceu_azul, 0, 0, w, h); seta_esquerda = new Image(context, R.drawable.seta_esquerda, 0, h - 64, 64, 64); seta_cima = new Image(context, R.drawable.seta_cima, 64, h - 64, 64, 64); seta_baixo = new Image(context,R.drawable.seta_baixo, w - (64 * 2), h 64, 64 , 64); seta_direita = new Image(context,R.drawable.seta_baixo, w - 64, h - 64, 64 , 64); }

Agora dentro do mtodo Draw vamos adicionar as seguintes linhas de cdigos

destacada em azul abaixo:

public void Draw(Canvas canvas) { ceu_azul.Draw(canvas); nuvem.Draw(canvas); aviao.Draw(canvas); seta_esquerda.Draw(canvas); seta_cima.Draw(canvas); seta_baixo.Draw(canvas); seta_direita.Draw(canvas); }

Para realizarmos o movimento do avio vamos trabalhar com os seguintes

mtodos : onTouch e Update.

Dentro do mtodo onTouch vamos adicionar as seguintes linhas de cdigo

abaixo:

public void onTouch(MotionEvent e) { if(e.getAction() == MotionEvent.ACTION_DOWN) { if(seta_esquerda.IsTouch(e.getX(), e.getY())) sentidoAviao = Sentido.PRA_TRAS; else if(seta_cima.IsTouch(e.getX(), e.getY())) sentidoAviao = Sentido.PRA_CIMA; else if(seta_baixo.IsTouch(e.getX(), e.getY())) sentidoAviao = Sentido.PRA_BAIXO; else if(seta_direita.IsTouch(e.getX(), e.getY())) sentidoAviao = Sentido.PRA_FRENTE; }

74

else if(e.getAction() == MotionEvent.ACTION_UP) { sentidoAviao = Sentido.PARADO; } }

Irei explicar aqui o cdigo presente dentro do mtodo onTouch. A primeira linha

de cdigo:

if(e.getAction() == MotionEvent.ACTION_DOWN)

Avalia se houve algum toque na tela, ou seja, quando o mtodo getAction

presente dentro da instncia de classe MotionEvent (representado por e) retorna

um valor do tipo MotionEvent.ACTION_DOWN.

Se a condio avaliada for verdadeira, verifico se o toque ocorreu em uma das

imagens de direo presentes na tela. A instruo:

if(seta_esquerda.IsTouch(e.getX(), e.getY()))

Verifica se a imagem da seta para esquerda foi tocada na tela, atravs do mtodo

IsTouch, cujos argumentos do mesmo so as coordenas X e Y de onde ocorreu o

toque na tela (obtidos atravs dos mtodos getX e getY do objeto e,que

instncia da classe MotionEvent). Veja a instruo abaixo:

Caso a condio do toque seja verdadeira, atribudo a varivel sentidoAviao o

valor Sentido.PRA_TRAS, indicando que o avio ir andar para trs. Veja a

instruo:

sentidoAviao = Sentido.PRA_TRAS;

A explicao similar para o restante das instrues seguintes que avaliam,

respectivamente , se as imagens da seta pra cima, seta para baixo e seta para

direita foram tocadas tambm.

Agora para o primeiro if do bloco de comandos, existe um else, que avalia se o

toque foi liberado da tela, pela seguinte instruo:

if(e.getAction() == MotionEvent.ACTION_UP)

75

Caso seja verdadeira a instruo acima, executado o prximo cdigo:

sentidoAviao = Sentido.PARADO;

Que atribui para a varivel sentidoAviao o valor Sentido.PARADO, indicando

que o nosso avio ir ficar parado.

No evento onTouch o que ocorre somente a atualizao do valor do atributo

sentidoAviao. A atualizao do atributo no far (ainda) que o avio realize

nenhum movimento. Precisamos processar o valor armazenado em sentidoAviao

em um mtodo que ir realmente movimentar o objeto na tela. O movimento do

objeto ser processado no mtodo Update. Vamos no mtodo Update para

digitarmos o seguinte cdigo:

public void Update() { if(sentidoAviao == Sentido.PRA_FRENTE) aviao.MoveByX(10); else if(sentidoAviao == Sentido.PRA_TRAS) aviao.MoveByX(-10); else if(sentidoAviao == Sentido.PRA_CIMA) aviao.MoveByY(-10); else if(sentidoAviao == Sentido.PRA_BAIXO) aviao.MoveByY(10); }

Irei comentar as instrues do mtodo acima. A expresso :

if(sentidoAviao == Sentido.PRA_FRENTE)

Verifica se o atributo sentidoAviao assumi o valor Sentido.PRA_FRENTE, que

indica que o objeto ser movimentado para frente. Se a condio acima for

verdadeira, o avio ser movimento para frente, atravs do mtodo MoveByX,

conforme voc pode conferir abaixo:

aviao.MoveByX(10);

O comando acima vai deslocar o avio para frente (na verdade, para direita), de

10 em 10 pixels, conforme voc pode conferir no valor do argumento do mtodo

acima, que indica o tamanho do deslocamento em pixels.

76

Na condio seguinte, avaliado se o atributo sentidoAviao assumi o valor

Sentido.PRA_TRAS, que indica que o objeto ser movimentado para trs. Se a

condio acima for verdadeira, o avio ser movimento para trs, atravs do

mtodo MoveByX, conforme voc pode conferir abaixo:

aviao.MoveByX(-10);

O comando acima vai deslocar o avio para trs (na verdade, para esquerda), de

10 em 10 pixels (observe que , conforme voc pode conferir no argumento, o

valor est negativo, indicando que ele far o movimento no sentido contrrio).

A mesma explicao similar para as prximas instrues , que avaliam se o

avio se deslocar para cima e para baixo.

Vamos executar a nossa aplicao. O resultado voc confere na imagem

seguinte:

Movendo o avio pela tela (usando o touch screen)

77

Se observarmos o jogo, ns conseguimos mover o avio pela tela, porm, a

nuvem que adicionamos no jogo est imvel. O ideal seria que essa nuvem se

movimentasse, dando a sensao de que o avio est voando (em movimento).

Para colocarmos a nuvem em movimento, precisaremos adicionar mais algumas

instrues. Para comear vamos declarar um atributo, conforme voc pode

conferir em seguida:

int largura_tela;

Agora dentro do mtodo onScreenLoading , logo aps o comando que

adicionamos, vamos adicionar a seguinte instruo destacada em azul abaixo:

public void onScreenLoading(int w, int h, OrientationMode orientation) { : seta_baixo = new Image(context,R.drawable.seta_baixo, w - (64 * 2), h - 64, 64 , 64); seta_direita = new Image(context,R.drawable.seta_direita, w - 64, h - 64, 64 , 64); largura_tela = w; }

Que retorna para a varivel largura_tela o valor da largura da tela do dispositivo

(armazenado no argumento w do mtodo).

Agora dentro do mtodo Update vamos adicionar o seguinte comando destacado

em azul abaixo, como segue:

public void Update() { : else if(sentidoAviao == Sentido.PRA_CIMA) aviao.MoveByY(-10); else if(sentidoAviao == Sentido.PRA_BAIXO) aviao.MoveByY(10); nuvem.MoveByX(-15); if(nuvem.GetX() < -nuvem.GetWidth()) nuvem.SetX(largura_tela); }

78

Irei explicar cada linha de comando das instrues adicionadas acima. A linha:

nuvem.MoveByX(-15);

Desloca a nuvem para a esquerda, de 15 em 15 pixels (lembre-se : valor positivo

significa deslocamento pra direita, e valor negativo deslocamento para esquerda).

A prxima instruo :

if(nuvem.GetX() < -nuvem.GetWidth())

Verifica se a nuvem saiu for a da tela. Como interpretamos a avaliao feita pela

condio acima ? Irei explicar para voc. O mtodo GetX (do objeto nuvem, do

tipo Image) retorna a posio da coordenada X do objeto na tela, e o mtodo

GetWidth retorna a largura do objeto. Quando a posio X de qualquer objeto for

menor que o valor negativo de sua largura, significa que o objeto no est visvel

na tela, ou seja, est fora dela (fora pelo lado esquerdo da tela). Quando isso

acontece, executada a seguinte instruo:

nuvem.SetX(largura_tela);

Que reposiciona a nuvem para surgir a partir da direita da tela, dando a sensao

que o avio est realmente voando. Execute novamente a aplicao e confira o

resultado:

79

Jogo em Execuo Nuvem se movimentando pela tela

Se observarmos o nosso jogo, o nosso avio pode se deslocar perfeitamente pela

tela, porm, de deixarmos o avio se mover constante (e unicamente) para uma

direo, o mesmo sai da tela (independente se para frente, pra trs, pra cima ou

para baixo). Como solucionar esse problema ? simples, basta limitarmos seu

movimento de forma que o mesmo no saia da tela.

Para realizarmos esse procedimento, primeiramente, vamos declarar o seguinte

atributo abaixo (destacado em azul): :

Image seta_direita, seta_esquerda, seta_cima , seta_baixo; int largura_tela; int altura_tela;

Agora vamos dentro do mtodo Update para digitarmos as seguintes linhas de

cdigo destacadas em azul abaixo:

public void Update() { if(sentidoAviao == Sentido.PRA_FRENTE)

80

{ aviao.MoveByX(10); //Comeou a sair da tela indo para frente ??? if((aviao.GetX() + aviao.GetWidth()) > largura_tela) aviao.SetX(largura_tela - aviao.GetWidth()); } else if(sentidoAviao == Sentido.PRA_TRAS) { aviao.MoveByX(-10); //Comeou a sair da tela indo para trs ??? if(aviao.GetX() < 0) aviao.SetX(0); } else if(sentidoAviao == Sentido.PRA_CIMA) { aviao.MoveByY(-10); //Comeou a sair da tela indo para cima ??? if(aviao.GetY() < 0) aviao.SetY(0); } else if(sentidoAviao == Sentido.PRA_BAIXO) { aviao.MoveByY(10); //Comeou a sair da tela indo para baixo ??? if((aviao.GetY() + aviao.GetHeight()) > altura_tela) aviao.SetX(altura_tela - aviao.GetHeight()); } }

Irei explicar agora a finalizade de cada instruo adicionada no cdigo. A

instruo:

if((aviao.GetX() + aviao.GetWidth()) > largura_tela)

Avalia se o avio est comeando a sair da tela indo para frente (se a posio

atual do avio na coordenada X somado com a largura do mesmo for maior que a

largura da tela. Isso uma regra padro). Caso a condio seja verdadeira,

executado a seguinte instruo:

aviao.SetX(largura_tela - aviao.GetWidth());

Que impede que o avio saia da tela, atravs do reajuste da posio dele na

coordenada X, que ser a largura da tela a largura do avio.

81

Quando o avio anda para trs, executado a seguinte avaliao condicional:

if(aviao.GetX() < 0)

Que verifica se o avio est comeando a sair da tela (se a posio X do objeto

for menor que 0). Se a condio for verdadeira, ser executada a seguinte

instruo:

aviao.SetX(0);

Que reajusta a posio do avio , pela coordenada X (definindo a coordenada X

com o valor 0).

Quando o avio anda para cima, executado a seguinte avaliao condicional:

if(aviao.GetY() < 0)

Que verifica se o avio est comeando a sair da tela (se a posio Y do objeto

for menor que 0). Se a condio for verdadeira, ser executada a seguinte

instruo:

aviao.SetY(0);

Que reajusta a posio do avio , pela coordenada Y (definindo a coordenada Y

com o valor 0).

Quando o avio est se movimentando para baixo, executada a seguinte

avaliao:

if((aviao.GetY() + aviao.GetHeight()) > altura_tela)

Que verifica se o avio est comeando a sair da tela (se a posio atual do avio

na coordenada Y somado com a altura do mesmo for maior que a altura da tela.

Isso uma regra padro). Caso a condio seja verdadeira, executado a

seguinte instruo:

aviao.SetY(altura_tela - aviao.GetHeight());

82

Que impede que o avio saia da tela, atravs do reajuste da posio dele na

coordenada Y, que ser a altura da tela a altura do avio.

Executando nossa aplicao, teremos o seguinte resultado:

Jogo em execuo Avio no sai mais da tela

83

Capitulo 8 Trabalhando com animao de sprites (A classe AnimationSprites)

os captulos anteriores, aprendemos a visualizar imagens estticas no

jogo (pode ser qualquer elemento do jogo como uma rvore, um poste,

um bloco e etc). Agora, se eu quisesse que algum elemento do jogo

apresenta-se alguma animao ? Neste captulo vamos aprender como realizar

essas animaes usando sprites no jogo.

Na maioria dos jogos em 2D (talvez podemos dizer todos), alguns os elementos

apresentam algum tipo de animao (como o movimento de um personagem ou a

ao de algum objeto). Agora a pergunta que fao : como so realizadas essas

animaes no jogo ? Essas animaes so realizadas utilizando o que ns

chamamos de sprites. O que vem a ser uma sprite ? Sprites nada mais so do

que um conjunto de imagens, onde cada imagem representa o movimento ou

ao de um determinado elemento do jogo (como um personagem ou um objeto

do jogo qualquer).

Vamos ver abaixo um conjunto de imagens (sprites) de um personagem, onde

cada imagem representa um movimento:

Sprites de um personagem de um jogo (dando soco)

Como funciona a animao de um personagem (ou objeto) durante o jogo ? Se

observarmos as imagens acima, cada uma delas representa um movimento, e

N

84

cada uma delas exibida numa fatia de tempo, dando a sensao de

movimento ou ao.

Para trabalharmos com animao de sprites aqui no Android, ns vamos fazer

uso da classe chamada AnimationSprites, destinada somente para esse tipo de

tarefa (presente dentro do pacote gameutil2d.classes.basic do nosso

framework).

Para comearmos, vamos importar nosso framework para o ADT e em seguida,

vamos realizar algumas modificaes nele, conforme mostrado em seguida:

Nome do projeto : AnimacaoSprites

Constante app_name : Animacao de Sprites

Depois de criado o projeto, vamos adicionar as seguintes imagens , que j

acompanham este material, em nosso projeto : naruto_parado_1.png,

naruto_parado_2.png, naruto_parado_3.png e naruto_parado_4.png.

Depois de colocar as imagens dentro do projeto, vamos abrir o arquivo

GameMain.java, para digitarmos o cdigo do nosso jogo. Na declarao de

atributos, vamos realizar a seguinte declarao, conforme mostrado em

seguida:

AnimationSprites naruto;

Agora dentro do mtodo construtor GameMain , vamos escrever o seguinte

cdigo (destacado em azul), conforme mostrado abaixo:

public GameMain(Context context) { naruto = new AnimationSprites(context, 0, 0, 124, 164); naruto.Add(R.drawable.naruto_parado_1); naruto.Add(R.drawable.naruto_parado_2); naruto.Add(R.drawable.naruto_parado_3); naruto.Add(R.drawable.naruto_parado_4); naruto.Start(3, true); }

Irei explicar o cdigo inserido no mtodo acima. A linha de comando:

85

naruto = new AnimationSprites(context, 0, 0, 124, 164);

Carrega a instncia do objeto naruto do tipo AnimationSprites. No primeiro

argumento da classe, sempre passamos o valor context. No segundo e terceiro

parmetro, passamos respectivamente a coordenada X e Y do objeto na tela. J

os dois ltimos parmetros representam , respectivamente , a largura e a altura

do objeto (124 para largura e 164 para altura). Nas linhas de comando seguinte:

:

naruto.Add(R.drawable.naruto_parado_1); naruto.Add(R.drawable.naruto_parado_2); naruto.Add(R.drawable.naruto_parado_3); naruto.Add(R.drawable.naruto_parado_4); :

Adicionamos as imagens (sprites) dentro do objeto, para que possamos ter uma

animao do personagem, atravs do mtodo Add. Em seguida, vem a seguinte

instruo:

naruto.Start(20, true);

Que tem a finalidade de iniciar a animao, atravs do mtodo Start. Esse

mtodo possui dois parmetros : O primeiro parmetro responsvel por definir,

em frames, o intervalo da troca de imagens, e o segundo definimos se a

animao vai ficar em loop (caso true) ou no (caso false).

Agora no mtodo Draw vamos adicionar a seguinte instruo:

protected void Draw(Canvas canvas) { naruto.Draw(canvas); }

86

Vamos executar agora a nossa demonstrao ? Veja como ficou na figura

seguinte:

Animao do personagem em execuo

Em uma animao de sprites tambm podemos aplicar o efeito e flip (inverso)

de uma imagem, na horizontal (como j havamos visto com imagens estticas).

Para invertermos uma imagem na horizontal, basta adicionar um parmetro no

mtodo Draw do objeto, o FlipEffect.HORIZONTAL.

Vamos voltar para o mtodo Draw da classe GameMain para substituirmos a

linha abaixo:

naruto.Draw(canvas);

Por essa:

naruto.Draw(canvas,FlipEffect.HORIZONTAL);

87

Que inverte as imagens da animao (como havia falado, esse procedimento

acima funciona tambm para imagens estticas). Veja o resultado na figura

seguinte:

A

nimao do personagem invertida na horizontal

Mais um exemplo de animao de sprites

Vamos realizar agora mais uma pratica de animao de sprites no Android

usando a classe AnimationSprites. Para essa pratica vamos importar um projeto

em Android j feito (que j acompanha este material), que o arquivo

AnimacaoSprites_GundamWing.zip, para dentro do ADT.

Aps importar o arquivo AnimacaoSprites_GundamWing.zip para dentro do ADT

execute o jogo e confira o resultado, conforme mostra a figura seguinte:

88

Jogo em execuo

Esse um exemplo baseado no jogo Gundam Wing Endless Duel, um dos

grandes sucessos da plataforma Super Nitendo.

A inteno deste exemplo trocarmos as posies dos personagens do jogo.

Para isso, vamos abrir o arquivo GameMain.java e em seguida vamos realizar

as seguintes modificaes citadas a seguir:

Dentro do mtodo onScreenLoading, vamos substituir as seguintes linhas de

cdigo destacadas em vermelho abaixo:

public void onScreenLoading(int w, int h, OrientationMode orientation) { wing_gundam = new AnimationSprites(context, 100, 130, 200, 250); wing_gundam.Add(R.drawable.wing_gundam_parado_1); wing_gundam.Add(R.drawable.wing_gundam_parado_2); : heavy_arms = new AnimationSprites(context, 450, 120, 197, 263);

89

heavy_arms.Add(R.drawable.heavy_arms_parado_1); heavy_arms.Add(R.drawable.heavy_arms_parado_2); : }

Pelas seguintes linhas de cdigo destacadas em azul abaixo:

public void onScreenLoading(int w, int h, OrientationMode orientation) { wing_gundam = new AnimationSprites(context, 450, 130, 200, 250); wing_gundam.Add(R.drawable.wing_gundam_parado_1); wing_gundam.Add(R.drawable.wing_gundam_parado_2); : heavy_arms = new AnimationSprites(context, 100, 120, 197, 263); heavy_arms.Add(R.drawable.heavy_arms_parado_1); heavy_arms.Add(R.drawable.heavy_arms_parado_2); : }

Agora dentro do mtodo Draw vamos substituir as seguintes linhas de cdigo

destacadas em vermelho abaixo:

public void Draw(Canvas canvas) { : wing_gundam.Draw(canvas); heavy_arms.Draw(canvas,FlipEffect.HORIZONTAL); }

Pelas seguintes linhas de cdigo destacadas em azul abaixo:

public void Draw(Canvas canvas) { : wing_gundam.Draw(canvas, FlipEffect.HORIZONTAL); heavy_arms.Draw(canvas); }

Depois de realizar as alteraes de cdigo citadas acima, execute novamente o

jogo e confira os resultados, conforme podemos observar na figura seguinte:

90

Jogo em execuo Personagens trocados de posio

Regras para a criao de sprites

Quando vamos criar as sprites (animaes) de um determinado elemento de um

jogo, normalmente, cada imagem que ir representar uma ao desse elemento,

deve ter o mesmo tamanho (padronizado para cada elemento do jogo), e quando

salvas, devero estar nomeadas de forma que fique fcil a organizao das

imagens (como por exemplo : personagem_andando_1.png ,

personagem_andando2.png e etc).

91

Capitulo 9 Detectando colises entre objetos no jogo

ma das tcnicas mais importantes que no se pode faltar em um jogo, a

deteco de colises entre elementos .Neste captulo, iremos aprender a

detectar se dois objetos (ou mais) se colidem um com o outro no jogo,

atravs dos recursos oferecidos neste material.

Para a deteco de coliso entre elementos, iremos fazer uso da classe

Collision, que j se encontra presente no modelo de projeto que usamos.

Para comear, vamos importar nosso framework para o ADT, e em seguida

vamos fazer as seguintes modificaes:

Nome do projeto : ColisaoEntreObjetos

Constante app_name : Colisao entre Objetos

Depois de criado o projeto , vamos adicionar as seguintes imagens (dentro do

diretrio drawable-mdpi) : seta_esquerda.png , seta_direita.png ,

monstro_andando_1.png, monstro_andando_2.png , cenario.png e

obstaculo.png.

Agora vamos abrir o arquivo GameMain.java para escrevermos o cdigo do

nosso jogo.

Dentro da seo de declarao de atributos, vamos realizar as declaraes

abaixo, como segue:

AnimationSprites personagem; Image cenario; Image obstaculo,obstaculo2; Context context;

U

92

Image seta_esquerda, seta_direita; enum Movimento { DIREITA, ESQUERDA, PARADO } Movimento movimentoPersonagem = Movimento.PARADO;

Agora dentro do mtodo GameMain vamos escrever o seguinte cdigo abaixo:

public GameMain(Context context) { this.context = context; }

Agora dentro do mtodo onScreenLoading vamos adicionar as seguintes

instrues:

public void onScreenLoading(int w, int h, OrientationMode orientation) { personagem = new AnimationSprites(context, (400 - 24), 305, 48, 50); personagem.Add(R.drawable.monstro_andando_1); personagem.Add(R.drawable.monstro_andando_2); personagem.Start(10, true); cenario = new Image(context, R.drawable.cenario, 0, 0, w, h); obstaculo = new Image(context, R.drawable.obstaculo, 80, 253, 68, 120); obstaculo2 = new Image(context, R.drawable.obstaculo, 630, 253, 68, 120); seta_esquerda = new Image(context, R.drawable.seta_esquerda, 0, h-96, 96, 96); seta_direita = new Image(context, R.drawable.seta_direita, w-96, h-96, 96, 96); }

Agora dentro do mtodo Update vamos escrever o seguinte cdigo abaixo:

public void Update() { if(movimentoPersonagem == Movimento.DIREITA) personagem.MoveByX(10); else if(movimentoPersonagem == Movimento.ESQUERDA) personagem.MoveByX(-10); }

Agora dentro do mtodo Draw vamos adicionar o seguinte cdigo:

public void Draw(Canvas canvas) { cenario.Draw(canvas); obstaculo.Draw(canvas);

93

obstaculo2.Draw(canvas); personagem.Draw(canvas); seta_esquerda.Draw(canvas); seta_direita.Draw(canvas); }

E para finalizar, no mtodo onTouch, vamos adicionar o seguinte cdigo abaixo:

public void onTouch(MotionEvent e) { if(e.getAction() == MotionEvent.ACTION_DOWN) { if(seta_direita.IsTouch(e.getX(), e.getY())) movimentoPersonagem = Movimento.DIREITA; else if(seta_esquerda.IsTouch(e.getX(), e.getY())) movimentoPersonagem = Movimento.ESQUERDA; } else if(e.getAction() == MotionEvent.ACTION_UP) movimentoPersonagem = Movimento.PARADO; }

Depois de adicionarmos o cdigo do nosso jogo, vamos execut-lo. O resultado

voc confere na figura seguinte:

94

Jogo em execuo

Se observarmos o jogo acima, nosso personagem pode se movimentar de um

lado para o outro, porm, o nosso personagem no pode ultrapassar os

obstculos (que so os elevadores).

A ideia seria desenvolver um cdigo que ir detectar a coliso do personagem

com os obstculos, que no caso so os elevadores.

Para adicionarmos o cdigo de coliso, vamos no mtodo Update para

adicionarmos as seguinte instrues, destacados em azul abaixo:

public void Update() { if(movimentoPersonagem == Movimento.DIREITA) { personagem.MoveByX(10);

95

//Colidiu com o obstculo da direita ("obstaculo2") if(Collision.Check(personagem, obstaculo2)) personagem.MoveByX(-10); } else if(movimentoPersonagem == Movimento.ESQUERDA) { personagem.MoveByX(-10); //Colidiu com o obstculo da esquerda ("obstaculo") if(Collision.Check(personagem, obstaculo)) personagem.MoveByX(10); } }

Irei explicar agora o cdigo que avalia a coliso do personagem com as barras

horizontais e verticais. A expresso abaixo:

if(movimentoPersonagem == Movimento.DIREITA)

Verifica se a varivel movimentoPersonagem est assumindo o status

Movimento.DIREITA (indicando que o personagem est andando para direita).

Se a condio acima for verdadeira, o personagem ir se deslocar para direita, 10

pixels, atravs da instruo abaixo:

personagem.MoveByX(10);

Em algum momento do deslocamento, poder haver um determinado momento em que o personagem poder se colidir com o obstculo da direita (o objeto obstaculo2), agora, como avaliar se houve a coliso ? Para verificar se houve uma coliso entre dois objetos usamos o mtodo Check da classe Collision, como podemos ver na instruo abaixo:

if(Collision.Check(personagem, obstaculo2))

Se ocorrer uma coliso, nosso personagem ir voltar um passo anterior (se ele

andou 10 pixels para direita e nesse movimento ele colidiu com o obstculo, ele

voltar um passo anterior), conforme voc confere em seguida:

personagem.MoveByX(-10);

96

A explicao das condies seguintes similar ao que foi explicado agora. Vamos executar agora a nossa demonstrao e conferir os resultados.

Jogo em execuo Personagem Colide com o Elevador

Como pudemos observar acima, a coliso uma das tcnicas de

desenvolvimento de jogos mais importantes, com essa tcnica conseguimos

muitas coisas (como verificar se o personagem est pisando

Documents

Apostila Android Jogos 2 Edicao Completa