apostila android desenvolvimento jogos 3 edicao free, Notas de estudo de Análise de Sistemas de Engenharia
paulo-cesar-alexandrino-2
paulo-cesar-alexandrino-2

apostila android desenvolvimento jogos 3 edicao free, Notas de estudo de Análise de Sistemas de Engenharia

131 páginas
50Números de download
1000+Número de visitas
Descrição
Apostila destinada ao ensino de criação de aplicativos para plataforma android
60 pontos
Pontos de download necessários para baixar
este documento
Baixar o documento
Pré-visualização3 páginas / 131
Esta é apenas uma pré-visualização
3 mostrados em 131 páginas
Esta é apenas uma pré-visualização
3 mostrados em 131 páginas
Esta é apenas uma pré-visualização
3 mostrados em 131 páginas
Esta é apenas uma pré-visualização
3 mostrados em 131 páginas

2

Aviso sobre esta apostila

Antes de iniciar a leitura deste material, veja esse aviso:

Este material usa a licensa Creative Commons isto significa

que ELE PODE SER DISTRIBUÍDO LIVREMENTE, porém, SOBRE AS

SEGUINTES REGRAS :

Esse material NÃO PODERÁ SER COMERCIALIZADO

Essa material NÃO PODERÁ SER DEVIRADO

E todos os créditos do autor DEVERÃO SER MANTIDOS

3

Sobre o Autor da Apostila

Luciano Alves da Silva é Bacharelado em Ciência da Computação pela UNISUAM

e Pós-Graduado em Docência do Ensino Superior pelo Instituto A Vez do Mestre

(Universidade Cândido Mendes - UCAM). Possui conhecimento e domínio das

linguagens de programação 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 também dos seguintes livros, pela editora AGBOOK

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

Desenvolvedores

- Desenvolvendo Jogos com a Plataforma XNA 2ª Edição – Guia para

Desenvolvedores.

- Desenvolvendo Jogos com o Framework MONOGAME – Guia para

Desenvolvedores.

- Desenvolvendo Jogos 2D com Plataforma Java – Guia para

Desenvolvedores.

4

Apresentação

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

voltados para a plataforma Android, através do framework GameUtil2D, utilizando

a ferramenta de desenvolvimento Android Studio.

Este material é completo, não é necessário adquirir nenhuma Apostila de Android

disponível no site para este aprendizado sobre jogos.

O usuário que tenha interesse em desenvolver jogos para essa plataforma,

precisa possuir conhecimentos básicos sobre linguagens de programação (de

preferência Java ou suas derivadas C++/C#) e algoritmos.

Se você possui os conhecimentos aqui citados neste material, você pode

prosseguir com o seu estudo. Agora, caso você não tenha nenhum conhecimento

sobre programação Android e deseja desenvolver um jogo, recomendo a

aquisição da “Apostila de Android : Programando DO ZERO” no meu site :

www.apostilaandroid.net

5

Índice analítico

Capitulo 1 Introdução ao desenvolvimento de jogos .............................. 6

Capitulo 2 Visão geral sobre o Google Android ....................................... 8

2.1) Sobre o Android ...................................................................................... 8 2.2) Estrutura Geral da plataforma Google Android ..................................... 10 2.2.1) A arquitetura do Android .................................................................... 11 2.2.2) Aplicações .......................................................................................... 12 2.2.3) Android Runtime ................................................................................ 13 2.2.4) Linux Kernel ....................................................................................... 13 2.3) Para qual versão do Android devemos desenvolver os nossos jogos ? 13

Capitulo 3 Instalando e Configurando a Ferramenta de Desenvolvimento16

2.1) A ferramenta de desenvolvimento Android Studio ................................ 16 2.2) Observações gerais sobre o Android Studio ......................................... 17 2.3) Baixando e configurando os componentes da ferramenta de

desenvolvimento .............................................................................................. 19 2.3.1) A Máquina Virtual Java ...................................................................... 19 2.3.2) O Android SDK .................................................................................. 23 2.3.3) O Android Studio ................................................................................ 39

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

Capitulo 5 Começando a desenvolver jogos para Android .................... 67

5.1) - Conhecendo a estrutura geral do projeto Android para jogos ............. 70 O diretório “java” .......................................................................................... 72 O diretório “res” (resources) ......................................................................... 79 Os diretórios “drawable-hdpi”, “drawable” , “drawable-ldpi” e “drawable- xhpdi”. .......................................................................................................... 80 O diretório “values” ....................................................................................... 80 Executando o jogo ....................................................................................... 81

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

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

Capitulo 8 Trabalhando com animação de sprites (A classe AnimationSprites) ............................................................................... 116

Capitulo 9 Detectando colisões entre objetos no jogo ........................ 124

Conclusão a respeito do material ........................................................ 131

6

Capitulo 1 Introdução ao desenvolvimento de jogos

ntes de começarmos 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 aplicação (programa),

desenvolvida e destinada somente para o entretenimento. Atualmente

encontramos jogos dos mais diversos gêneros para os mais diversos públicos.

Vejamos agora alguns títulos conhecidos de jogos que existem hoje em dia:

Angry Birds (Android)

A

7

Jetpack Joyride (Android)

Benji Bananas (Android)

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

mente : seu inicio, meio e fim (história do jogo de modo geral, não importando seu

gênero) ; as ferramentas que vamos utilizar para desenvolver os jogos e

programadores/artistas que estarão 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.

8

Capitulo 2 Visão geral sobre o Google Android

omo vamos desenvolver jogos para o Android, neste capítulo 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 versões da plataforma.

2.1) Sobre o Android

O Android é uma plataforma desenvolvida pela Google voltada para dispositivos

móveis, 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 constituído por

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

desenvolvimento de aplicações e serviços, com o objetivo e trazer aos

consumidores uma experiência mais rica em termos de recursos, menos

dispendiosa em ternos financeiros para o mercado móvel.

Um dos primeiros SmartPhones que ofereceu suporte a esse sistema operacional

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

C

9

G1 - T-Mobile

Atualmente o sistema Android se encontra hoje disponível tanto em SmartPhones

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

mercado com o sistema operacional Android:

SmartPhone Samsung Galaxy S3

10

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 necessárias para desenvolver aplicações para a plataforma

Android, utilizando a linguagem Java.

Vamos conhecer os recursos encontrados nessa plataforma:

- Application framework: Permite a reutilização e substituição de componentes ;

- Dalvik virtual machine: É uma Máquina Virtual Java (JVM) voltada para

dispositivos móveis ;

- Browser Integrado baseado no webkit engine ;

- Gráficos Otimizados O Android é constituído por bibliotecas 2D e 3D baseada

na especificação OpenGL ES 1.0 ;

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

Android para guardar dados ;

11

- Suporte multimídia: A plataforma já oferece para áudio, vídeo 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) ;

- Câmera, GPS, compasso, e acelerômetro (dependente de hardware) ;

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

ferramentas de depuração, memória, performance e recursos para

desenvolvimento ;

2.2.1) A arquitetura do Android

Arquitetura geral da plataforma

12

2.2.2) Aplicações

O Android nos fornece um conjunto de aplicações fundamentais, são elas:

- um cliente de e-mail;

- programa de SMS;

- agenda;

- mapas;

- navegador;

- contatos entre outros.

Todos os aplicativos acima presentes no Android foram desenvolvidos na

linguagem de programação Java.

O Android nos fornece um conjunto de bibliotecas C/C++ utilizadas por vários

componentes do sistema. Veja algumas das bibliotecas abaixo:

- System C library: Consiste em uma implementação derivada da biblioteca C

padrão baseado no sistema (libc) do BSD sintonizada para dispositivos rodando

Linux.

- Media Libraries: Baseado no PacketVideo’s OpenCORE; são as bibliotecas que

suportam os mais diversos formatos de áudio e vídeo, incluindo também imagens.

- Surface Manager: Responsável pelo acesso ao subsistema de exibição bem

como as múltiplas camadas de aplicações 2D e 3D;

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

Browser quanto para exibições web.

- SGL – o engine de gráficos 2D

- 3D libraries: Uma implementação baseada no OpenGL ES 1.0 APIs; As

bibliotecas utilizam aceleração 3D via hardware (quando disponível) ou o software

de renderização 3D altamente otimizado incluído no Android.

- FreeType – Biblioteca responsável pela renderização de fontes bitmap e vector;

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

de dados (SGBD) relacional disponível para todas as aplicações.

13

2.2.3) Android Runtime

O Android é constituído por um conjunto de bibliotecas que fornece a maioria das

funcionalidades disponíveis nas principais bibliotecas da linguagem Java.

Toda aplicação Android roda em seu próprio processo, com sua própria instância

da máquina virtual Dalvik. O Dalvik foi escrito de forma a executar várias VMs

eficientemente. Ele executa arquivos .dex, que é otimizado para consumo mínimo

de memória. A VM é baseada em registros e roda classes compiladas pela

linguagem Java que foram transformadas em arquivos .dex, através da

ferramenta “dx” incluída no SDK.

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

como o encadeamento e a gestão de baixo nível de memória.

2.2.4) Linux Kernel

O Android foi projetado em cima da versão 2.6 do kernel do Linux para os

serviços centrais do sistema, tais como segurança, gestão de memória, gestão de

processos, etc. O kernel também atua como uma camada de abstração entre o

hardware e o resto do software.

2.3) Para qual versão 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 versão 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 versão da plataforma

precisamos desenvolver.

14

1.3.1) Qual versão da plataforma Android é a mais utilizada no momento ?

Para falar a respeito dessa situação, irei mostrar aqui um gráfico que mostra quais

versões do Android são as mais usadas no mundo todo :

Gráfico de Estatística a respeito do S.O Android mais usado

O gráfico da estática acima foi feito em setembro de 2015, onde nele podemos

observar que as versões do Android mais utilizadas são o Kitkat (versão 4.4), Jelly

Bean (versão 4.1 – 4.3) e o Lollipop (Versão 5.0). As versões mais antigas do

Android como Eclair (versão 2.1) e Donut (versão 1.6) já nem são mais citadas e

faladas hoje em dia, e durante a atualização dessa apostila, a nova versão do

Android 6.0 (Marshmallow) , estava acabando de ser lançada em alguns

dispositivos.

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 versão 4.4

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

desenvolvermos nossa aplicação utilizando como base a versão 4.4, mas, em

nosso material iremos utilizar como base a versão do Android 4.0 .

15

1.3.2) O Publico

Outro fator muito importante , e que destaco aqui , é a questão O PUBLICO.

Nesse fator , a questão S.O deveria ser deixada “teoricamente” de lado, visto que

muitos usuários ainda possuem aparelhos Android com uma versão mais antiga

(como a versão 2.3 e 2.2), logo, devemos pensar também nesses usuários para

“usufruir” dos nossos jogos desenvolvidos.

1.3.4) Hardware e Processamento

Outro fator muito importante, que deve ser levado também em consideração, além

da versão do S.O, (quando se trata de desenvolvimento de jogos) é a questão

Hardware e Processamento. Existe uma grande diferença entre desenvolver uma

aplicação (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 especificações de hardware , que acompanham o produto.

Naturalmente os tablets “genéricos” que encontramos em algumas lojas, que

acompanham uma versão popular do Android, nem sempre possui uma

especificação de hardware adequada para jogos (principalmente para jogos em

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

muito atento as especificações do aparelho.

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

?

Agora a questão é : Como combinar a questão PUBLICO e VERSÃO do S.O /

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

jogo, a prioridade que devemos dar em primeira instância e à versão do S.O em

conjunto com Hardware, visto que naturalmente os jogos são mais exigentes em

requisitos de hardware e sistema que a maioria das aplicações em geral. Como

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

para um tablet (ou smartphone) Android são os mais essenciais possíveis para

rodar games dessa categoria.

16

Capitulo 3 Instalando e Configurando a Ferramenta de Desenvolvimento

ara a elaboração desse material eu fiz o uso da ferramenta Android

Studio. Qualquer versão (de preferência superior) do programa citado

acima serve. Para que toda essa aplicação funcione é necessário que

você tenha instalado, antes de tudo, a Máquina Virtual Java (de preferência a

versão 7 ou posterior). Bom, mãos a obra.

2.1) A ferramenta de desenvolvimento Android Studio

Há algum tempo atrás a ferramenta de desenvolvimento Eclipse com o plugin

ADT focado para o desenvolvimento Android (junto com o Android SDK), deixou

de ser a ferramenta de desenvolvimento oficial para Android, sendo deixada

“teoricamente” de lado (pois na prática ainda muitos programadores usam ela).

Agora o Google adotou como ferramenta oficial de desenvolvimento o Android

Studio (baseada e inspirada na ferramenta IntelliJ IDEA) , onde podemos

desenvolver nossas aplicações para Android utilizando a linguagem de

programação Java. Vejamos a figura da IDE na imagem seguinte :

P

17

A ferramenta de desenvolvimento Android Studio

2.2) Observações gerais sobre o Android Studio

A ferramenta Android Studio encontra-se disponível para download no seu atual

site oficial : https://developer.android.com/sdk/index.html. Eis a página do site

carregada abaixo :

18

Site oficial da ferramenta Android Studio

NÃO BAIXE A VERSÃO SUGERIDA PELO SITE

Isso mesmo leitor, NÃO IREMOS BAIXAR a versão sugerida pelo site (conhecida

como “bundle” (pacote) que já acompanha a IDE configurada com o Android

SDK).

A versão “bundle” oferecida pelo site , além de ser bem pesada (quase 1GB),

requer do computador onde será instalado configurações mais “pesadas” como

processador, suporte a aceleração de HARDWARE e etc.

Possivelmente você (que está lendo esse material) e outras pessoas ,

encontraram muitos problemas durante a configuração e execução da versão

“bundle” recomendada pelo site (assim como eu já tive).

Em resposta a alguns leitores das minhas apostilas, recomendei que para NÃO

USEM a ferramenta Android Studio, devido a toda essa problemática encontrada

na versão “bundle” (sugerindo o bom e velho “Android Developer Tools”).

19

SOLUÇÃO MAIS VIÁVEL (E ALTAMENTE) RECOMENDADA

Depois de algumas análises e pesquisas sobre o Android Studio, descobri uma

solução mais viável e prática para usarmos essa nova ferramenta (oficial) sem

muitos problemas (independente “teoricamente” da configuração de sua

máquina).

O ideal para quem for programar no Android Studio é baixarmos todos os seus

componentes de desenvolvimento “separados”, ou seja, baixar somente a IDE

Android Studio (sem o SDK) e o Android SDK (avulso) realizando suas

configurações de forma independente.

2.3) Baixando e configurando os componentes da ferramenta de

desenvolvimento

2.3.1) A Máquina Virtual Java

Bom, como todo bom programador deve saber, para iniciarmos o nosso

desenvolvimento com Android devemos ter instalado (como pré-requisito do

Android Studio e do Android SDK) a Máquina Virtual Java.

Como saber se eu tenho a Máquina Virtual Java instalada ?

Basta chamarmos o “Prompt de Comando” do Windows, digitando na caixa de

diálogo “Executar” (pressioando as teclas “Windows” + “R”) o seguinte comando :

20

Feito isso clique em “OK” e será aberta a seguinte caixa de diálogo , conforme

podemos ver a seguir :

Prompt de comando do Windows

Experimente agora digitar o seguinte comando abaixo:

java –version

Se mostrar a seguinte mensagem a seguir :

Máquina Virtual Java instalada no computador

21

Significa que você tem a Máquina Virtual Java em seu computador, PORÉM, na

versão do Android Studio utilizada nesta apostila (versão 1.1.0) será preciso que

sua Máquina Virtual Java seja mais atualizada (como o do “Prompt de Comando”

acima, com “Update 75”). Caso contrário, atualize a sua Máquina Virtual Java.

Agora, se ao digitar o comando solicitado aparecer :

Sua Máquina Virtual Java não se encontra instalada

Significa que você precisa realizar o download da Máquina Virtual Java, pois a

mesma não se encontra instalada no computador.

Para fazer o download da Máquina Virtual Java basta abrir o seguinte link em

seguida :

http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-

1880260.html?ssSourceSiteId=otnpt

Feito isso deverá se abrir a seguinte página em seguida:

22

Página de download do Java 7

Procure pela versão mais recente do Java 7 (bastando rolar a página até

embaixo). Feito isso aceite os termos de contrato e realize o download do arquivo

de instalação, conforme é mostrado em seguida:2.2.1) A Máquina Virtual Java

23

Baixando a Máquina Virtual Java

A instalação da Máquina Virtual Java é bem simples, basta ir seguindo toda a

orientação exibida durante a instalação (praticamente só clicando em “Next”).

2.3.2) O Android SDK

Depois de instalado a Máquina Virtual em seu computador, vamos baixar e

configurar agora o Android SDK que iremos utilizar junto com o Android Studio.

Como falei, o Android SDK que já vem configurado com a versão “bundle” do

Android Studio vai requerer muito de sua máquina (e possivelmente irá apresentar

muitos erros). Vamos baixar a versão “avulsa” dele, para isso basta visitar o

seguinte link :

https://developer.android.com/sdk/index.html?hl=i

No link apresentado role a página abaixo e procure a seção “SDK Tools Only”.

Veja na figura em seguida :

Aceitando os

termos da licença.

Baixando a Máquina Virtual Java

24

Seção SDK Tools Only

Nesta obra estarei fazendo uso da versão “r24.1.2” do Android SDK (qualquer

versão superior serve). Basta clicar no link : “installer_r24.1.2-windows.exe” para

abrir a seguinte caixa de diálogo em seguida :

25

Janela de Termos e Condições

Marque a opção “I have read and agree with the above terms and conditions” e

em seguida clique no botão “Download installer_r24.1.2-windows.exe”, que será

exibida a seguinte caixa de diálogo em seguida :

Caixa de diálogo de download do Android SDK

26

Após efetuar o download do Android SDK, vamos executar o seu instalador. Feito

veremos a seguinte tela em seguida :

Instalação do Android SDK

Ao clicarmos no botão “Next” o mesmo irá verificar se existe uma Máquina Virtual

Java instalada em seu computador (como pré-requisito), conforme podemos ver

na figura seguinte :

OBS : Caso você queira utilizar a mesma versão do Android SDK que está

sendo utilizada aqui na obra, segue abaixo o link para download :

http://dl.google.com/android/installer_r24.1.2-windows.exe

27

Instalação do Android SDK

Vamos clicar agora no botão “Next” para avançarmos para a próxima etapa. Na

etapa seguinte é questionado para quais usuários será destinado o acesso ao

Android SDK. Nessa opção a escolha fica por sua conta.

28

Instalação do Android SDK

Clicando em “Next” podemos escolher o local onde a ferramenta será instalada,

conforme mostra a figura seguinte :

Instalação do Android SDK

29

Bom, nesta etapa iremos definir COMO PADRÃO o diretório “c:\android_sdk\”,

conforme podemos ver em seguida :

Mudando o diretório de instalação

Ná próxima etapa definimos o nome da pasta que será exibida no menu iniciar

que servirá como atalho para iniciarmos as ferramentas oferecidas pelo Android

SDK. Aqui não precisaremos modificar nada, deixe como está.

30

Instalação do Android SDK

Clique no botão “Install” para iniciarmos a instalação, conforme mostra a próxima

figura :

Instalação do Android SDK

31

Após concluir a instalação do Android SDK clique no botão “Next”, conforme

mostra a próxima figura :

Instalação do Android SDK

Na próxima tela deixe marcado a opção “Start SDK Manager” e clique no botão

“Finish” para finalizarmos e iniciarmos a execução do “SDK Manager”.

32

Finalizando a instalação do Android SDK

Após clicarmos no botão “Finish” será aberta a seguinte caixa de diálogo do

“Android SDK Manager”, conforme mostra a figura seguinte :

33

Caixa de diálogo “Android SDK Manager”

Através do Android SDK iremos baixar e configurar todos os recursos necessários

que serão utilizados durante o desenvolvimento das nossas aplicações para

Android no Android Studio.

Aqui para testarmos e executarmos as nossa aplicações em Android faremos uso

de um emulador que irá simular um dispositivo com o sistema Android. No

momento do desenvolvimento deste material, a versão oferecida do sistema

Android erá a versão 5.1 (Lollipop). Essa versão ainda não ganhou popularidade,

logo, iremos utilizar a versão 4.0.3 (Ice cream Sandwish), sendo esta a versão

mais utilizada pelo mundo no momento em dispositivos Android.

34

Vamos no Android SDK “desmarcar” todas as opções marcadas por padrão pela

ferramenta e marcar as opções a seguir :

1) Marque “Android SDK Platform-tools” (marcar a versão mais atual)

2) Marque “Android SDK Build-tools” (marcar a versão mais atualizada)

3) Expanda o item “Android 4.0.3 (API 15)” e marque a opção “ARM EABI v7

System Image”.

35

4) Expanda a pasta “Extras” e marque as opções “Android Suport Library” e

“Google USB Driver”

Depois disso vamos clicar no botão “Install 5 Packages”, conforme indica a

próxima figura :

36

Clicando no botão “Install 5 packages”

Feito isso será aberta a seguinte caixa de diálogo a seguir:

Caixa de diálogo – Choose Packages to Install

37

Observe que todos os itens de instação (da seção “Packages”) estão marcados

com um “X” vermelho (conforme destacado acima). Para solucionarmos isso

basta marcarmos a opção “Accept License”, conforme mostra a figura a seguir :

Marcando a opção “Accept License”

Feito isso teremos o seguinte resultado :

38

Caixa de diálogo – Choose Packages to Install

Clique no botão “Install” para instalarmos os itens selecionados. Feito isso será

exibida a seguinte caixa de diálogo a seguir :

39

Instalação dos pacotes selecionados

Aguarde a instalação e configuração de todos os pacotes através do Android SDK

Manager. Depois disso, podemos fechar o Android SDK Manager.

2.3.3) O Android Studio

Agora para finalizar, vamos baixar e configurar o Android Studio. O download

encontra-se na mesma página onde baixamos o Android SDK

(https://developer.android.com/sdk/index.html?hl=i)

Após carregar a página, role até abaixo até encontrar a seção “All Android Studio

Packages”, conforme mostra a figura seguinte :

40

Seção All Android Studio Packages”

Agora vamos instalar a versão do Android Studio sem o SDK incluso (pois já

baixamos ele por fora e configuramos), clicando no link indicado a seguir :

41

Selecionando a versão do Android Studio sem o SDK incluso

Feito isso irá se abrir a caixa de diálogo de termos e condições (como já vimos no

“Android SDK”). Confirme os termos de condições e clique no botão de

“Download”. Feito isso irá se abrir a caixa de diálogo abaixo :

Caixa de diálogo – Download do Android Studio

OBS : Caso você queira utilizar a mesma versão do Android Studio que

está sendo utilizado neste material, segue abaixo o link para download :

https://dl.google.com/dl/android/studio/install/1.1.0/android-studio-ide-

135.1740770-windows.exe

42

Após efetuar o download do Android Studio vamos executar o seu arquivo de

instalação. Feito isso será aberta a seguinte caixa de diálogo a seguir :

Instalação do Android Studio

Vamos clicar no botão “Next” para avançarmos com a instalação. Feito isso será

aberta a seguinte caixa de diálogo a seguir :

43

Instalação do Android Studio

Por padrão as opções “Android Virtual Device” e “Performance (Intel ® HAXM)”

estão selecionadas. Vamos desmarcar todas as duas opções, conforme mostra a

figura seguinte :

Desmarcando as duas opções acima

44

Depois de seguir as orientações acima, vamos clicar em “Next”. Feito isso será

aberta a seguinte caixa de diálogo a seguir :

Instalação do Android Studio

Vamos deixar o diretório “default’ de instalação do Android Studio. Clique em

“Next” para irmos para a próxima etapa, conforme mostra a figura :

Sobre a opção “Performance (Intel ® HAXM)”

Possivelmente essa opção NÃO DEVE TER APARECIDO em seu

computador. Calma, está tudo bem. Essa opção só é exibida dependendo

da configuração de seu PC. Essa opção permite o recurso de simulação de

“aceleração de hardware” (suportado por computadores com uma

configuração mais “pesada”), porém, ela não será utilizada neste material.

45

Instalação do Android Studio

Na tela da figura anterior, basta clicarmos no botão “Install” para instalarmos o

Android Studio em nosso computador. Vejamos o resultado na figura seguinte :

Instalando o Android Studio

46

Aguarde a instalação se concluída, conforme podemos ver abaixo:

Instalação concluída

Clique em “Next” e na próxima tela vamos clicar em “Finish” para iniciarmos a

execução do “Android Studio”, conforme podemos ver na figura seguinte :

47

Instalação do Android Studio concluída

Após clicarmos no botão “Finish”, será aberta a seguinte caixa de diálogo abaixo,

do Android Studio :

Caixa de diálogo – Complete Installation

48

Nessa caixa de diálgo é perguntado se você gostaria de importar os projetos

desenvolvidos em uma versão anterior do Android Studio. Supondo que estou

instalando o Android Studio pela primeira vez, vamos deixar marcada a segunda

opção , conforme mostra a figura abaixo :

Deixando marcada a segunda opção

Vamos clicar no botão “OK” para que possamos inicializar o Android Studio,

conforme podemos ver na figura seguinte :

49

Logo em seguida deverá ser mostrada a seguinte caixa de diálogo a seguir,

solicitando o download do Android SDK através do Android Studio :

Caixa de diálogo – Android Studio Wizard

Bom, como já instalamos o Android SDK, não será preciso realizar nenhum

download de SDK. Logo, vamos clicar no botão “Fechar” da caixa de diálogo e em

seguida será mostrada a seguinte mensagem :

Caixa de diálogo

50

Na caixa de diálogo que é exibida vamos desmarcar a primeira opção para

marcamos a opção de baixo “Do not re-run the setup wizard”.

Caixa de diálogo

Feito isso vamos clicar em “OK”. Em seguida será exibida a seguinte caixa de

diálogo a seguir :

Caixa de diálogo – Android Setup Wizard

51

A primeira coisa que iremos fazer agora, antes de criarmos qualquer projeto, é

configurar o Android SDK para atuar em conjunto com o Android Studio. Para

isso, vamos clicar na opção “Configure”, conforme podemos ver abaixo :

Selecionando a opção “Configure”

Na próxima caixa de diálogo que surge selecione a opção “Project Defaults” :

Selecionando a opção “Project Defaults”

Feito isso, vamos selecionar agora a opção “Project Structure” :

52

Selecionando a opção “Project Structure”

Feito isso irá se abrir a seguinte caixa de diálgo a seguir :

Caixa de diálogo – Project Structure

Nesta tela iremos definir o diretório onde nós instalamos o nosso Android SDK.

Para isso vamos clicar no botão “Browser” (...), conforme é indicado na figura a

seguir :

53

Selecionando o botão “Browser”

Feito isso será aberta a seguinte caixa de diálogo a seguir :

Caixa de diálogo – Choose Android SDK Location

Se lembra que instalamos o nosso “Android SDK” separadamente no diretório

“c:\android_sdk” ? Pois bem, vamos apontar para o diretório de instalação do

“Android SDK”, conforme podemos ver na figura seguinte :

54

Apontando para o diretório do Android SDK

Depois de apontar para o diretório do Android SDK, podemos clicar no botão “OK”

para finalizarmos o processo. Veja o resultado :

55

Diretório do SDK definido

Na caixa de diálogo da figura acima podemos clicar no botão “OK” para

confirmarmos o diretório do Android SDK.

Depois disso, feche o Android Studio.

56

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 instalação do emulador BlueStacks requer que seu computador possua

obrigatoriamente os drives de vídeo. (caso contrário, 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 página abaixo:

Página oficial do emulador BlueStacks

P

57

Feito isso basta clicarmos no botão “Download” situado na página e

automaticamente seremos redirecionamos para uma outra página e , em seguida,

a caixa de diálogo de download surgirá em seguida:

Caixa de diálogo de download

Faça o download da ferramenta e em seguida, após o termino do download,

vamos executar a instalação da aplicação. Feito veremos a seguitnte tela abaixo:

Caixa de diálogo – Instalação do BlueStacks

58

Clique no botão “Continue” para prosseguirmos com a instalação. Na caixa de

diálogo a seguir:

Caixa de diálogo – Instalação do BlueStacks

Vamos deixar o caminho do jeito que estar e clique em “Next” para avançarmos.

Na próxima caixa de diálogo :

59

Caixa de diálogo – Instalação do BlueStacks

Não será necessária fazer nenhuma alteração (fique a vontade caso você deseje

modificar as opções acima). Clique no botão “Install” para iniciar a instalação.

A instalação depende do uso da Internet, logo, os todos os arquivos de instalação

da ferramenta serão baixados do site (dependendo de sua Internet, esse

processo poderá demorar um pouco, tenha paciência!), conforme você confere

em seguida:

60

Caixa de diálogo – Instalando o BlueStacks

Após concluir a instalação, automaticamente você verá que ele já executar o

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

61

Emulador em execução (modo tela cheia)

Para sairmos do modo tela cheia basta clicar no botão Restaurar, situado no

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

Executando o emulador – Obtendo dados

62

Mesmo com o emulador em execução, 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 paciência!).

Depois de todo o processo acima concluído, será exibida a seguinte tela:

Emulador BlueStacks em execução

Bom , agora vamos fechar o nosso emulador.

Configurando a resolução de tela do emulador

O emulador BlueStacks já possui uma resolução padrão (que normalmente é

1280x720). Mas, e se eu quisesse alterar a resolução dele (Para 800x480, que

será a resolução que vamos trabalhar na apostila) ? O emulador BlueStacks NÃO

OFERECE nenhuma configuração para modificar através dele sua resolução,

mas, essas informações estão guardadas em uma chave de registro do Windows

(que vamos precisar mexer para definirmos a nossa resolução desejada). Vamos

no menu iniciar do “Windows” e em seguida chame a opção “Executar”. Dentro da

caixa de diálogo digite “regedit”, conforme abaixo:

63

Caixa de diálogo – 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

64

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:

65

Pronto!!! Feito isso nosso emulador irá executar na resolução que configuramos.

Porém, para que o emulador execute conforme nossas confurações, vamos na

barra de tarefas encontrar o ícone da aplicação BlueStacks, e em seguida clique

com o botão direito sobre o ícone e selecione “Restart”:

Feito isso nosso emulador será recarregado e executado conforme nossas

configurações feitas na chave de registro. Veja o resultado abaixo:

66

Emulador em execução – Na resolução 800x480

67

Capitulo 5 Começando a desenvolver jogos para Android

epois de tudo configurado e instalado, conforme foi mostrado nos

capítulos anteriores, vamos a partir de agora começar a desenvolver

nossos jogos para a plataforma Android.

Conforme havia falado, para criarmos os nossos jogos aqui no Android Studio,

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

processo de desenvolvimento de jogos, que se chama GameUtil2D

(http://www.gameutil2d.org) . Essa biblioteca de desenvolvimento foi atualizada

(em relação a versão anterior utilizada na segunda edição deste material), e agora

utiliza o OpenGL para a exibição e renderização dos elementos na tela do jogo

(além de rodar os jogos mais rápidos, independente da configuração do

dispositivo).

Vamos utilizar a versão do GameUtil2D voltado para o Android Studio (Versão

2.1). Para baixar basta clicar no seguinte link : http://goo.gl/NgfChz

Após baixar o arquivo do framework, descompacte-o em um local apropriado.

Uma observação: Coloque em um diretório em que o nome de todo o caminho

(pastas) não possua espaços, cedilhas e etc (por exemplo :

“C:\AndroidStudio\Projetos”).

5.1) – Abrindo o projeto

Bom, depois de descompactar o nosso projeto (framework GameUtil2D), vamos

abrir ele através do Android Studio. Com a IDE aberta, volte a tela principal e

selecione a opção “Open na existing Android Studio project”, veja na figura a

seguir :

D

68

Feito isso será aberta a seguinte caixa de diálogo abaixo:

Caixa de diálogo

Agora selecione o projeto no local onde você descompactou para que possamos

abri-lo. Veja na figura a seguir:

69

Selecionando o projeto

Clique em “OK” para que o projeto possa ser aberto.

OBSERVAÇÃO 1: Possivel durante o carregamento do projeto você deve

visualizar a seguinte mensagem abaixo:

Mensagem de erro de localização do SDK

70

A mensagem acima indica que você instalou o seu Android SDK eu um local

diferente onde o projeto do GameUtil2D foi desenvolvido, isso é absolutamente

normal. Essa mensagem só será visto uma única vez em seu projeto, depois

disso ela não irá ser exibida novamente.

OBSERVAÇÃO 2: Após o projeto ser carregado, possivelmente poderá surgir a

seguinte mensagem abaixo:

Erro durante o carregamento do Gradle

Esse erro ocorre devido a versão do Android Studio utilizada em sua máquina

(que é diferente onde esse projeto do GameUtil2D foi desenvolvido). Para

solucionar este problema basta clicar em “Fix plugin version and sync project”.

Feito isso aguarde todo o processo e o seu projeto estará pronto para uso.

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

Nós vamos utilizar para a construção 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 compõem este projeto no Android Studio.

Se visualizarmos o lado esquerdo, existe uma seção chamada “Android”, onde

nela existe uma pasta chamada “app” (onde está o nosso projeto), constituído por

vários subdiretórios , que por sua vez, possui seus respectivos arquivos. Se

expandirmos a pasta do projeto, veremos uma estrutura de diretórios e pacotes

conforme demonstra a figura seguinte:

71

Package Explorer

OBSERVAÇÃO : Se em seu projeto você constatar que a pasta “java” ESTÁ

VAZIA, conforme mostra a figura abaixo:

Cadê os arquivos ?

Na barra de ferramentas do Android Studio clique no botão “Sync Project with

Gradle Files”. Veja a figura a seguir :

72

Botão “Sync Project with Gradle Files”

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

várias pastas e arquivos, cada um com uma finalidade em especifico.

O diretório “java”

Vamos começar conhecendo primeiramente o diretório “java” (source). Dentro

desse diretório temos todos os arquivos de extensão “.java” que fazem parte de

uma aplicação Android. Se nós expandirmos essa pasta encontraremos uma

série de arquivos, todos eles organizações em seus respectivos “pacotes”,

conforme você pode conferir na figura seguinte:

73

Package Explorer

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

O pacote “gameutil2d.project”

Esse pacote é constituído 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 código do jogo.

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 conteúdo:

74

package gameutil2d.project; import gameutil2d.framework.*; import android.content.Context; import android.view.MotionEvent; import com.twicecircled.spritebatcher.SpriteBatcher; import gameutil2d.classes.ad.*; import gameutil2d.classes.basic.*; import gameutil2d.classes.scene.*; import gameutil2d.classes.character.Character; import gameutil2d.classes.text.*; publicclass GameMain { public GameMain(Context context) { /* Construtor da classe GameMain * Nesse método inicializamos todas as variáveis de controle, * objetos e entre outros elementos do jogo (imagens, animações e * personagens)*/ //Insira seu código aqui } publicvoid onScreenLoading(int w, int h, OrientationMode orientation) { /* Método que é executado logo após o construtor da classe GameMain * Aqui carregamos todos os elementos (imagens, animações, personagens) * que dependam das informações de largura (w) e altura (h) da tela do * jogo, incluindo também sua * orientação (orientation) */ //Insira seu código aqui } publicvoid Update() { // Método responsável pela execução da lógica do jogo (movimento, ação, // colisões e etc.) // Insira seu código aqui }

75

publicvoid Draw(SpriteBatcher spriteBatcher) { //Método responsável por desenhar todos os elementos do jogo na tela //(através do objeto "spriteBatcher") //Insira seu código aqui } publicvoid onTouch(MotionEvent e) { //Método executado quando ocorre algum evento de toque sobre a //superficie da tela //Insira seu código aqui } publicvoid onExitGame() { /* Método que é executado quando o jogo é encerrado * Adequado para a finalização de threads e músicas de fundo do jogo*/ // Insira seu código aqui } publicvoid onPauseGame() { /* Método que é executado quando o botão "HOME" do aparelho é pressionado ou quando a execução do jogo é suspensa*/ // Insira seu código aqui } publicvoid onResumeGame() { // Disparado quando a aplicação volta a ser executada // Insira seu código aqui } publicvoid onBackButtonPressed() { /* OBS: Para esse evento funcionar execute a instrução abaixo no método GameMain : ((GameActivity) context).SetCanClose(false); Esse método é executado quando o botão BACK do aparelho é pressionado */ // Insira seu código aqui } }

76

O código acima é a estrutura padrão da classe GameMain (arquivo

“GameMain.java”) no qual iremos escrever o código para o desenvolvimento do

nosso jogo. Essa classe é constituída pelos seguintes métodos:

GameMain: Esse é o método construtor, executado toda vez que o jogo é

executado. São neles que carregamos todos os objetos e iniciamos as variáveis

que serão utilizados no jogo. Veja sua sintaxe:

public GameMain(Context context)

onScreenLoadling: Esse sempre logo após a execução do método GameMain ,

nele carregamos objetos e entre outros elementos que dependam das

informações básicas da tela do dispositivo (como largura, altura e orientação do

mesmo). Veja sua sintaxe:

publicvoid onScreenLoading(int w, int h, OrientationMode orientation)

Irei explicar agora a finalidade de cada parâmetro acima:

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

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

orientation : Retorna a orientação da tela do dispositivo.

Update: Esse método é executado sempre durante a execução do jogo, e

também é o primeiro a ser executado. Ele é responsável por executar a “lógica”

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

publicvoid Update()

Draw: Esse método é executado sempre durante a execução do jogo, e

executado “alternadamente” com o método Update. Ele é responsável por

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

Vejas a sua sintaxe:

protected void Draw(SpriteBatcher spriteBatcher)

Esse método possui um parâmetro chamado “spriteBatcher”, que representa a

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

77

onTouch: Esse método é disparado toda vez quando ocorre um “touch screen”,

ou seja, quando tocamos a tela do dispositivo. Esse método 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 parâmetro “e” guarda todas informações do evento, como as coordenadas onde

ocorreu o toque na tela do dispositivo, e também o tipo do toque que ocorreu

(pressionamento, movimento (drag) ou liberação).

onExitGame: Esse método é disparado quando o jogo (aplicativo) é encerrado.

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

o encerramento de uma música ou para liberar objetos da memória e etc. Veja

sua sintaxe :

publicvoid onExitGame()

onPauseGame: Esse método é disparado quando o jogo entra em estado de

pausa (que ocorre quando o botão menu e pressionado ou quando o jogo sai de

foco para a execução de alguma outra tarefa como uma ligação que acontece no

momento). Quando esse método é disparado, o método Update é desativo. Veja

sua sintaxe :

publicvoid onPauseGame()

onResumeGame: Esse método é disparado quando o jogo retorna a sua

execução normal. Quando esse método é disparado, o método Update é ativado

novamente. Veja sua sintaxe :

publicvoid onResumeGame()

onBackButtonPressed: Esse método é disparado o botão back do aparelho é

pressionado, porém, isso so é possível quando a instrução ((GameMain)

context).SetCanClose(false);for executada dentro do método GameMain. Veja

sua sintaxe :

publicvoid onBackButtonPressed()

78

O pacote “gameutil2d.classes.basic”

Nesse pacote estão contidos as classes básicas que iremos utilizar para a

construção dos nossos jogos. Vejamos abaixo quais são essas classes e a

finalidade de cada uma (que será demonstrada nos capítulos 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

animações de sprites em um jogo.

Collision.java : Esse arquivo (ou classe) é utilizado para “detectar” colisões

entre dois elementos em um jogo.

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

conjunto de imagens de uma animação de sprites) na “horizontal”.

GameElement.java: Essa é a base utilizada para a construção da maioria

das classes citadas acima (e de algumas outras classes que serão citadas

em seguida), e de bastante utilidade para a construção de outros elementos

do jogo por parte do usuário.

Box.java : Classe utilizada somente para definir “pontos de colisão”,

bastante útil para a construção 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”.

O pacote “gameutil2d.classes.character”

Nesse pacote existe somente uma classe, destinada para a criação de

personagens (para jogos no estilo plataforma).

Character.java : Esse arquivo (ou classe) é utilizado para a construção de

personagens, que iremos utilizar em um jogo.

79

O pacote “gameutil2d.classes.scene”

Nesse pacote existe somente uma classe, destinada para a criação de cenários

do jogo.

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

“cena” do jogo, e quais elementos estarão presentes nele.

O pacote “gameutil2d.classes.text”

Nesse pacote existe somente uma classe, destinada para a exibição de

informações na tela do jogo.

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

informações na tela do jogo (mensagens, textos etc.).

O pacote “gameutil2d.classes.add”

Nesse pacote existe somente uma única classe, destinada para a exibição de

anúncios em seu jogo.

Ad.java : Esse arquivo (ou classe) é utilizado para exibir anúncios em seu

jogo (ela trabalha com a classe AdView do pacote “Google Play Services”,

responsável pela exibição dos anúncios através do AdMob).

O diretório “res” (resources)

Dentro da estrutura do projeto Android existe um diretório chamado “res”

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

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

subdiretórios existentes dentro dessa pasta e a finalidade de cada um deles.

80

Os diretórios “drawable-hdpi”, “drawable” , “drawable-ldpi” e “drawable- xhpdi”.

A partir da versão 1.6 da plataforma Android foram adicionados dentro da pasta

“res” (resources) três diretórios responsáveis pelo gerenciamento de imagens:

“drawable-ldpi”, “drawable”, “drawable-hdpi”. Nas versões do Android 2.2 em

diante , podemos encontrar dentro da pasta do projeto (além dos diretórios

citados), também o diretório “drawable-xhdpi” . Todos esses diretórios possuem a

mesma finalidade : armazenar imagens que serão utilizadas por uma aplicação

em Android. Agora , qual a diferença que existe entre esses diretórios ? Cada um

desses diretórios será utilizado de acordo com a resolução do dispositivo Android

em uso.

Quando estivermos trabalhando com as imagens que serão exibidas no jogo,

devemos copiar as imagens para todos os diretórios citados acima.

O diretório “values”

Um dos recursos que o Android permite que usemos na construção de

aplicações são “constantes”. Como bom programador que todos nós somos,

sabemos que uma “constante” nada mais é do que um endereço de memória que

vai armazenar um determinador valor, que será único até o fim da execução do

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

explicar.

Normalmente usamos constantes para armazenar valores fixos que,

naturalmente, estarão presentes na maior parte do seu programa. É muito comum

criarmos um título como nome de uma aplicação (como por exemplo : “Alpha

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

aplicação. Imagine você digitar “manualmente” o nome de seu software em todas

as telas da sua aplicação, seria um processo trabalhoso você não acha ? Agora

imagine “futuramente” que você precise “mudar” o nome de sua aplicação ? Você

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

aplicação, sem dúvida. Usando constantes, você não terá esse trabalho.

Dentro dessa pasta temos os seguintes arquivos:

- “strings.xml” : Esse arquivo guarda constantes relacionadas à nossa aplicação

em geral (como o nome da aplicação, o título que vai aparecer na aplicação e

etc.).

81

- “dimen.xml” : Esse arquivo guarda constantes relacionadas as dimensões que

podemos utilizar em nossa aplicação (não será utilizado no jogo).

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

podemos utilizar em nossa aplicação (não será utilizado no jogo).

Executando o jogo

Para executarmos um jogo feito no Android, basta clicarmos no botão “Run app”

situado na barra de ferramentas (ou pressionar as teclas SHIFT+F10):

Botão “Run app”

Após clicar nesse botão será aberta a seguinte caixa de diálogo abaixo:

Caixa de diálogo – Choose Device

82

Essa caixa de diálogo 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 aplicação será instalada no dispositivo e na barra de tarefas do

Windows surgirá o seguinte balão, avisando que a aplicação foi instalada no

emulador com sucesso.

Vejamos a nossa aplicação em execução na figura seguinte:

Aplicação em execução no emulador

A tela escura indica que não há nada na tela, que nenhum elemento está

presente no jogo, por isso este resultado ocorre.

Neste capítulo conhecemos nosso framework de desenvolvimento, que iremos

utilizar para a construção dos nossos jogos (o GameUtil2D). Nos próximos

capítulos vamos conhecer todas as classes que compõem esta framework e como

criar vários exemplos de jogos (e também jogos) através dela.

83

Capitulo 6 Visualizando imagens no jogo (A classe Image)

o capítulo anterior conhecemos e aprendemos a manusear e a executar

uma aplicação (jogo) através do framework para jogos no Android. Neste

capítulo iremos aprender a inserir e visualizar imagens em um jogo no

Android, através 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 ““GameUtil2DV2_1_AndroidStudio.zip”).

Para isso vamos “extrair” esse arquivo, conforme já foi mostrado no capítulo

anterior, em um local apropriado.

Após extrair o arquivo, vamos renomear o diretório que contém os arquivos do

projeto para “VisualizandoImagensJogo”.

Após renomear a pasta vamos abrir o nosso arquivo, vamos abrir nosso projeto

através do Android Studio. Vejamos na figura seguinte:

N

84

Selecionando o proximo projeto a ser aberto

Após abrir o projeto, abra o arquivo “strings.xml” , conforme mostra a figura a

seguir:

85

Arquivo “strings.xml”

Vamos motificar o nome da constante “app_name” para Visualizando Imagens

Jogo”, conforme mostra a figura a seguir:

86

Depois de alterada as informações acima, vamos abrir o arquivo “GameMain.java”

(que é o arquivo no qual vamos escrever o código do nosso jogo), que está

situado no pacote “gameutil2d.project” (dentro da pasta “java”).

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

responsável por essa finalidade. Para isso, dentro da classe GameMain vamos

declarar um atributo do tipo Image.

Na classe GameMain, na seção de declaração de atributos, vamos declarar um

atributo chamado imagem , conforme podemos conferir em seguida:

Image imagem;

Agora dentro do construtor da classe (o método GameMain), vamos carregar o

nosso atributo (objeto), com os seguintes parâmetros conforme você confere no

código abaixo:

public GameMain(Context context) { //Insira seu código aqui imagem = new Image(context, R.drawable.gameutil2d_logo, 0, 0, 96, 96); }

Vamos analisar os parâmetros do comando inserido acima. O construtor da

classe Image possui os seguintes parâmetros :

imagem = new Image(context, R.drawable.gameutil2d_logo, 0, 0, 96, 96);

O primeiro parâmetro do construtor é padrão, cujo argumento sempre será o

“context”. O segundo parâmetro corresponde a imagem que vamos visualizar no

jogo (que é a imagem “gameutil2d_logo.png”).

Antes de continuarmos com a explicação dos parâmetros, vamos entender essa

“notação” 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.gameutil2d_logo”.

Conforme já foi explicado, todas as imagens que vamos utilizar em uma aplicação

Android ficam em todos os diretórios do tipo “drawable” (que fica dentro da pasta

“res”). Na teoria, como a imagem (com diretório e tudo), é expresso dessa forma :

87

“res/drawable-mpdi/gameutil2d_logo.png”

No Android, devemos utilizar a notação:

“R.drawable.gameutil2d_logo”

A letra “R” da expressão acima, representa o diretório “res”, e a palavra

“drawable” representa o diretório “drawable-mdpi”. Se observarmos acima, o

nome da imagem não leva a “extensão”, pois o Android já identifica

automaticamente a imagem e sua extensão.

Vejamos alguns exemplos da análise 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 comentário dos parâmetros.

O terceiro e quarto parâmetro do construtor correspondem , respectivamente, as

coordenadas X e Y do objeto na tela do jogo (cujos valores são “0” e “0”). Já o

quinto e o sexto parâmetro correspondem, respectivamente, a largura e a altura

do objeto (cujo valores são “96” e “96”).

Bom, o que fizemos até agora foi carregar o objeto (imagem) na memória. Agora

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

método Draw, responsável por esse finalidade. Dentro do método Draw vamos

escrever o código abaixo:

publicvoid Draw(SpriteBatcher spriteBatcher) { imagem.Draw(spriteBatcher); }

Se observarmos o método acima, inserimos a seguinte linha de comando :

88

imagem.Draw(spriteBatcher);

Que é responsável por desenhar a imagem na tela, através do método Draw.

Nesse método passamos como parâmetro o “spriteBatcher”, que representa a

“tela” onde a imagem será desenhada.

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

Imagem em exibição 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

visualização de imagens. Para isso, vamos utilizar como exemplo as seguintes

imagens para nossa demonstração : “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

deverão ser copiadas para todos os diretórios do tipo “drawable”.Irei mostrar aqui

como copiar as imagens para todos os diretórios.

89

Copie (CTRL+C) todas as imagens citadas acima no diretório onde você extraiu

em seu computador.

Em seguida, selecione a pasta “drawable” do seu projeto no Android Studio e em

seguida cole (CTRL + V) as imagens. A seguinte caixa de diálogo aparecerá em

seguida:

Caixa de diálogo – Choose Destination Directory

Conforme havia falado, existem quatro diretórios do tipo drawable que

precisaremos copiar as imagens, porém, em nosso projeto exergamos somente

um. Quando pressionamos “CTRL+V” ele nos mostrou alternativas, indicando

para qual diretório do tipo “drawable” desejaremos copiar as imagens. Vamos

selecionar o primeiro diretório (o diretório “drawable” padrão), conforme figura a

seguir:

90

Selecionando o primeiro diretório

Em seguida, clique em “OK”. Feito isso será exibida a seguinte caixa de diálogo:

Caixa de diálogo - Copy

Simplesmente clique em “OK” para que os arquivos sejam copiados para a pasta

“drawable”. Vejamos o resultado:

Imagens copiadas para o diretório

91

Agora vamos REPETIR O MESMO PROCESSO. Selecione o diretório “drawable”

e pressione CTRL+C novamente, e na caixa de diálogo que surge, selecione o

diretório “drawable-hdpi”.

Selecionando o diretório

Clique em “OK”. Agora na caixa de diálogo “Copy” que surge pressione

novamente “OK”.

Agora repetir o mesmo processo já mostrado acima para os diretórios “drawable-

ldpi” e “drawable-xhdpi”. Vejamos o resultado na figura a seguir:

Imagens copiadas para todos os diretórios

Se observarmos cada imagem copiada, observe um número quatro “(4)”, que

indica que a imagem está presente nos quatros diretórios já mencionados.

92

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

comandos nos métodos que citarei abaixo. Primeiramente vamos apagar todo o

código que inserimos dentro da classe GameMain.

Em seguida, dentro da seção de declaração de atributos, vamos declarar os seguintes objetos abaixo:

: Image bird; Image titulo_flappy_bird; Image background_fase_flappy_bird; Context context;

Agora dentro do método construtor GameMain inserir a seguinte linha de código

abaixo, conforme é mostrado no código abaixo:

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

O comando que inserirmos acima será responsável por guardar dentro do atributo

da classe context o conteúdo armazenado dentro do parâmetro context do

construtor da classe GameMain. Esse armazenamento será necessário, pois ,

nós iremos carregar todas as imagens dentro do método onScreenloading e

precisamos do context para carregarmos todas as imagens fora do método

GameMain (não somente imagem mas também todos os objetos que precisem do

argumento context fora do construtor).

Agora dentro do método onScreenLoading vamos digitar os seguintes

comandos abaixo:

publicvoid 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); }

93

Agora dentro do método Draw vamos digitar o seguinte código, conforme é

mostrado em seguida:

publicvoid Draw(SpriteBatcher spriteBatcher) { background_fase_flappy_bird.Draw(spriteBatcher); titulo_flappy_bird.Draw(spriteBatcher); bird.Draw(spriteBatcher); }

Dentro do método Draw existem três instruções onde cada uma irá exibir uma

imagem na tela. As instruções que inserimos no código, possuem uma sequência,

que precisarei explicar.

Observe que a primeira instrução adicionada no método Draw foi:

background_fase_flappy_bird.Draw(spriteBatcher);

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

Em seguida, temos a seguinte instrução:

titulo_flappy_bird.Draw(spriteBatcher);

Que irá exibir o título “Flappy Bird” na tela. Como essa é a segunda imagem a ser

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

Na terceira instrução temos a seguinte linha de código:

bird.Draw(spriteBatcher);

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 título.

Após escrevermos os códigos acima, vamos executar a nossa demonstração. O

resultado você confere na figura a seguir:

94

Imagens em exibição na tela

Invertendo uma imagem na tela

A classe Image possui um método chamado Draw que serve para exibirmos uma

imagem na tela. Pois bem, o mesmo método possui um segundo parâmetro que

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

“FlipEffect.HORIZONTAL”.

Para realizarmos essa demonstração de inversão de imagem, vamos alterar

dentro do método Draw a seguite instrução destacada em azul abaixo:

publicvoid Draw(SpriteBatcher spriteBatcher) { background_fase_flappy_bird.Draw(spriteBatcher); titulo_flappy_bird.Draw(spriteBatcher); bird.Draw(spriteBatcher, FlipEffect.HORIZONTAL); }

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

segundo argumento no método Draw, o FlipEffect.HORIZONTAL. Que irá inverter

a imagem na horizontal.

95

Depois de alterar o código , salve-o e em segudia execute a aplicação. Veja o

resultado em seguida:

Imagens em exibição na tela (com a imagem do pássaro invetida)

OBSERVAÇÕES IMPORTANTES ANTES DE CONTINUAR

Nesse material estamos utilizando a nova versão do meu framework GameUtil2D

(que utiliza agora o OpenGL, ao invés do Canvas como na antiga versão).

Gostaria de fazer uma observação a respeito do meu framework que se aplica

SOMENTE NA VERSÃO para Android.

Teoricamente falando, a ordem de execução dos comandos para a exibição das

imagens, conforme abaixo:

publicvoid Draw(SpriteBatcher spriteBatcher) { background_fase_flappy_bird.Draw(spriteBatcher); titulo_flappy_bird.Draw(spriteBatcher); bird.Draw(spriteBatcher); }

96

Define como os elementos serão exibidos. Então observe que colocamos pra

exibir primeiro o fundo (background), o título (que sairá na frende do fundo) e o

pássaro (que sairá na frente de todos, pois foi o último a ser exibido).

Agora vamos inverter a ordem de execução dos comandos, conforme é mostrado

abaixo:

publicvoid Draw(SpriteBatcher spriteBatcher) { titulo_flappy_bird.Draw(spriteBatcher); bird.Draw(spriteBatcher); background_fase_flappy_bird.Draw(spriteBatcher); }

Observe que agora o fundo é a ultima imagem a ser visualizada na tela e,

teoricamente falando, ela será exibida na frente das demais imagens, mas, se

executarmos teremos a seguinte surpresa:

Jogo em execução – Deu o mesmo resultado

97

Bom, vou explicar porque isso aconteceu.

Por mais que você troque a ordem de execução da exibição das imagens,

SEMPRE TEREMOS O RESULTADO.

Na versão do framework GameUtil2D para Android (MAIS UMA VEZ, isso só

ocorre nas versões para Android), eu utilizo uma classe chamada SpriteBatcher

que é a responsável por exibir através de OpenGL as imagens na tela do jogo. E

a ordem para a exibição das imagens não se dá pela ordem de execução dos

comandos , SE DÁ PELO NOME DAS IMAGENS em ordem alfabética. As

imagens que foram colocadas na dentro foram:

background_fase_flappy_bird.png (1ª imagem a entrar na fila de exibição)

bird.png (2ª imagem a entrar na fila de exibição, sairá na frente da imagem

acima)

titulo_flappy_bird.png (3ª imagem a entrar na fila de exibição, sairá na frente

da demais)

Se quisermos mesmo que a imagem de fundo FIQUE NA FRENTE de todas as

outras basta mudar o nome de forma que na ordem alfabética, ELA SEJA UMA

DAS ÚLTIMAS na lista (e como podemos ver, ela foi a primeira).

Fazemos fazer um teste na prática. Expanda a basta

“background_fase_flappy_bird” e selecione o primeiro arquivo , conforme abaixo:

98

Agora pressione as teclas SHIFT+F6, e surgirá a seguinte caixa de diálogo a

seguir:

Caixa de diálogo – Rename

Vamos renomear o arquivo para “zbackground.png” (não escrevi errado não, é

“zbackground.png” mesmo, com uma letra “z” na frente). Em seguida clique em

“Refactor”.

Automaticamente, o Android Studio irá renomear todas as imagens de todos os

diretórios, assim também como suas referentes por todo o código no projeto.

Agora experimente executar novamente o jogo e você o resultado, conforme a

figura a seguir:

99

Jogo em execução – Agora sim, o fundo na frente das imagens

Entendem como funciona ?

Via regra vamos sempre colocar no código a exibição das imagens pela ordem de

execução, pois na maioria das ferramentas e em outras versões do meu

framework GameUtil2D, sempre seguirá essa filosofia. Porém, nas versões para

Android vamos deternimar, catutelosamente, o nome das imagens para a correta

exibição na tela. Veremos nos exercícios posteriores algumas regras que irão

auxiliar você.

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

certeza que sim.

Este é só um pontapé inicial, nos próximos capítulos iremos aprender várias

técnicas de desenvolvimento de jogos que serão de grande valia para seus

futuros jogos desenvolvidos para a plataforma.

100

Capitulo 7 Movendo elementos do jogo pela tela

o capítulo anterior aprendemos como visualizar elementos (como

imagens) na tela, porém, as imagens vistas ficam num ponto “fixo” da

dela, definido pelo código. Agora vamos aprender a movimentar esses

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

Neste tópico vamos aprender a movimentar os elementos do jogo usando o

“touch screen” (visto que atualmente, não se usa mais o movimento dos

elementos do jogo via teclado físico).

Antes de começarmos, extraia o arquivo do framework em um local apropriado.

Em seguida faça as seguintes alterações abaixo:

Nome da pasta : MovendoObjetoPelaTela

Constante “app_name” (dentro do arquivo “strings.xml”) : Movendo Objetos Pela

Tela

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

encontram presentes neste material) , que se chamam “f_aviao.png” ,

“f_nuvem.png” e “b_ceu_azul.png”.

OBS: Observe que no nome das imagens foram colocamos os prefixos “f_” e “b_”.

a letra “b_” vem da “background” (fundo) e “f_” vem de “foreground” (o que vem

na frente) e sabemos que na ordem alfabética, a letra “f” vem depois de “b”, ou

seja, todas as imagens que começam com “f” serão exibidas na frente. FICA A

DICA.

N

101

Depois de adicionar as imagens no projeto (dentro dos diretórios do tipo

“drawable”), vamos abrir o arquivo “GameMain.java” para escrevermos o código

do nosso jogo.

Para começar, vamos declarar os seguintes atributos na seção de declaração de

atributos da classe GameMain :

Image aviao, nuvem, ceu_azul; Context context;

Agora dentro do método 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.f_1_aviao, 0, 0, 90, 70); nuvem = new Image(context, R.drawable.f_0_nuvem, 250, 100, 90, 70); }

Nas linhas de comando que adicionamos acima (no método GameMain),

carregamos as imagens do avião e da nuvem.

Agora vamos no método onScreenLoading, para adicionarmos o seguinte

código:

publicvoid onScreenLoading(int w, int h, OrientationMode orientation) { ceu_azul = new Image(context, R.drawable.b_ceu_azul, 0, 0, w, h); }

Na linha que adicionarmos no método acima, carregamos a imagem do céu azul.

Agora a pergunta que eu faço é : Por quê que carregamos a imagem do céu azul

nesse método ? A resposta é simples, simplesmente porque precisamos que a

imagem do céu azul se ajuste ao tamanho da tela, logo, a largura e a altura da

tela deverá ser as mesmas do tamanho da tela.

Neste método 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 céu azul, como podemos conferir em

seguida:

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

102

Agora vamos no método Draw para adicionarmos as seguintes linhas de

comando:

publicvoid Draw(SpriteBatcher spriteBatcher) { ceu_azul.Draw(spriteBatcher); nuvem.Draw(spriteBatcher); aviao.Draw(spriteBatcher); }

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 céu azul

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

nuvem será desenhada “na frente” da imagem do céu azul. Por último,

desenhamos a imagem do avião, e esse avião será desenhado na frente da

imagem da nuvem e do céu azul (conforme já foi explicado no capítulo anterior,

mas sendo reforçado neste capítulo).

Depois de escrever o código , vamos executar nossa aplicação e conferir os

resultados:

103

Jogo em execução

Por enquanto, só conseguimos visualizarmos o nosso avião, mas, não podemos

movimentá-lo pela tela ainda.

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

aqui, o avião).

Vamos voltar na seção de declaração de atributos, e lá vamos declarar as

seguintes instruções, como segue:

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

Agora dentro do método onScreenLoading vamos digitar as seguintes instruções

destacadas em azul abaixo:

publicvoid onScreenLoading(int w, int h, OrientationMode orientation) { ceu_azul = new Image(context, R.drawable.b_ceu_azul, 0, 0, w, h); seta_esquerda = new Image(context, R.drawable.f_2_seta_esquerda, 0, h – 64, 64, 64); seta_cima = new Image(context, R.drawable.f_2_seta_cima, 64, h - 64, 64, 64);

104

seta_baixo = new Image(context,R.drawable.f_2_seta_baixo, w - (64 * 2), h - 64, 64 , 64); seta_direita = new Image(context,R.drawable.f_2_seta_direita, w - 64, h – 64, 64 , 64); }

Agora dentro do método Draw vamos adicionar as seguintes linhas de códigos

destacada em azul abaixo:

publicvoid Draw(SpriteBatcher spriteBatcher) { ceu_azul.Draw(spriteBatcher); nuvem.Draw(spriteBatcher); aviao.Draw(spriteBatcher); seta_esquerda.Draw(spriteBatcher); seta_cima.Draw(spriteBatcher); seta_baixo.Draw(spriteBatcher); seta_direita.Draw(spriteBatcher); }

Para realizarmos o movimento do avião vamos trabalhar com os seguintes

métodos : onTouch e Update.

Dentro do método onTouch vamos adicionar as seguintes linhas de código

abaixo:

publicvoid onTouch(MotionEvent e) { if(e.getAction() == MotionEvent.ACTION_DOWN) { if(seta_esquerda.IsTouch(e.getX(), e.getY())) sentidoAviao = Sentido.PRA_TRAS; elseif(seta_cima.IsTouch(e.getX(), e.getY())) sentidoAviao = Sentido.PRA_CIMA; elseif(seta_baixo.IsTouch(e.getX(), e.getY())) sentidoAviao = Sentido.PRA_BAIXO; elseif(seta_direita.IsTouch(e.getX(), e.getY())) sentidoAviao = Sentido.PRA_FRENTE; } elseif(e.getAction() == MotionEvent.ACTION_UP) { sentidoAviao = Sentido.PARADO; } }

Irei explicar aqui o código presente dentro do método onTouch. A primeira linha

de código:

105

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

Avalia se houve algum toque na tela, ou seja, quando o método getAction

presente dentro da instância de classe MotionEvent (representado por e) retorna

um valor do tipo “MotionEvent.ACTION_DOWN”.

Se a condição avaliada for verdadeira, verifico se o toque ocorreu em uma das

imagens de direção presentes na tela. A instrução:

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

Verifica se a imagem da seta para esquerda foi tocada na tela, através do método

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

toque na tela (obtidos através dos métodos getX e getY do objeto “e”,que é

instância da classe MotionEvent). Veja a instrução abaixo:

Caso a condição do toque seja verdadeira, é atribuído a variável sentidoAviao o

valor “Sentido.PRA_TRAS”, indicando que o avião irá andar para trãs. Veja a

instrução:

sentidoAviao = Sentido.PRA_TRAS;

A explicação é similar para o restante das instruções seguintes que avaliam,

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

direita foram tocadas também.

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

toque foi liberado da tela, pela seguinte instrução:

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

Caso seja verdadeira a instrução acima, é executado o próximo código:

sentidoAviao = Sentido.PARADO;

Que atribui para a variável sentidoAviao o valor “Sentido.PARADO”, indicando

que o nosso avião irá ficar parado.

No evento onTouch o que ocorre é somente a atualização do valor do atributo

sentidoAviao. A atualização do atributo não fará (ainda) que o avião realize

106

nenhum movimento. Precisamos processar o valor armazenado em sentidoAviao

em um método que irá realmente “movimentar” o objeto na tela. O movimento do

objeto será processado no método Update.Vamos no método Update para

digitarmos o seguinte código:

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

Irei comentar as instruções do método acima. A expressão :

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 condição acima for

verdadeira, o avião será movimento para frente, através do método MoveByX,

conforme você pode conferir abaixo:

aviao.MoveByX(10);

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

10 em 10 pixels, conforme você pode conferir no valor do argumento do método

acima, que indica o tamanho do deslocamento em pixels.

Na condição seguinte, é avaliado se o atributo sentidoAviao assumi o valor

“Sentido.PRA_TRAS”, que indica que o objeto será movimentado para trás. Se a

condição acima for verdadeira, o avião será movimento para trás, através do

método MoveByX, conforme você pode conferir abaixo:

aviao.MoveByX(-10);

107

O comando acima vai deslocar o avião para trás (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 contrário).

A mesma explicação é similar para as próximas instruções , que avaliam se o

avião se deslocará para cima e para baixo.

Vamos executar a nossa aplicação. O resultado você confere na imagem

seguinte:

Movendo o avião pela tela (usando o touch screen)

Se observarmos o jogo, nós conseguimos mover o avião pela tela, porém, a

nuvem que adicionamos no jogo está imóvel. O ideal seria que essa nuvem se

movimentasse, dando a sensação de que o avião está voando (em movimento).

Para colocarmos a nuvem em movimento, precisaremos adicionar mais algumas

instruções. Para começar vamos declarar um atributo, conforme você pode

conferir em seguida:

int largura_tela;

108

Agora dentro do método onScreenLoading , logo após o comando que

adicionamos, vamos adicionar a seguinte instrução destacada em azul abaixo:

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

Que retorna para a variável largura_tela o valor da largura da tela do dispositivo

(armazenado no argumento w do método).

Agora dentro do método Update vamos adicionar o seguinte comando destacado

em azul abaixo, como segue:

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

Irei explicar cada linha de comando das instruções 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 próxima instrução : if(nuvem.GetX() < -nuvem.GetWidth())

Verifica se a nuvem saiu for a da tela. Como interpretamos a avaliação feita pela

condição acima ? Irei explicar para você. O método GetX (do objeto nuvem, do

tipo Image) retorna a posição da coordenada X do objeto na tela, e o método

GetWidth retorna a largura do objeto. Quando a posição X de qualquer objeto for

menor que o valor negativo de sua largura, significa que o objeto não está visível

109

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

acontece, é executada a seguinte instrução:

nuvem.SetX(largura_tela);

Que reposiciona a nuvem para surgir a partir da direita da tela, dando a sensação

que o avião está realmente voando. Execute novamente a aplicação e confira o

resultado:

Jogo em Execução – Nuvem se movimentando pela tela

Se observarmos o nosso jogo, o nosso avião pode se deslocar perfeitamente pela

tela, porém, de deixarmos o avião se mover constante (e unicamente) para uma

direção, o mesmo sai da tela (independente se é para frente, pra trás, pra cima ou

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

movimento de forma que o mesmo não 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;

110

No método onScreenLoading insira a seguinte linha de código destacada em

seguida:

publicvoid onScreenLoading(int w, int h, OrientationMode orientation) { : seta_direita = new Image(context,R.drawable.f_2_seta_direita, w - 64, h – 64, 64 , 64); largura_tela = w; altura_tela = h; }

Agora vamos dentro do método Update para digitarmos as seguintes linhas de

código destacadas em azul abaixo:

publicvoid Update() { if(sentidoAviao == Sentido.PRA_FRENTE) { aviao.MoveByX(10); //Começou a sair da tela indo para frente ??? if((aviao.GetX() + aviao.GetWidth()) > largura_tela) aviao.SetX(largura_tela - aviao.GetWidth()); } elseif(sentidoAviao == Sentido.PRA_TRAS) { aviao.MoveByX(-10); //Começou a sair da tela indo para trás ??? if(aviao.GetX() < 0) aviao.SetX(0); } elseif(sentidoAviao == Sentido.PRA_CIMA) { aviao.MoveByY(-10); //Começou a sair da tela indo para cima ??? if(aviao.GetY() < 0) aviao.SetY(0); } elseif(sentidoAviao == Sentido.PRA_BAIXO) { aviao.MoveByY(10); //Começou a sair da tela indo para baixo ??? if((aviao.GetY() + aviao.GetHeight()) > altura_tela) aviao.SetX(altura_tela - aviao.GetHeight()); } }

111

Irei explicar agora a finalizade de cada instrução adicionada no código. A

instrução:

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

Avalia se o avião está começando a sair da tela indo para frente (se a posição

atual do avião na coordenada X somado com a largura do mesmo for maior que a

largura da tela. Isso é uma regra padrão). Caso a condição seja verdadeira, é

executado a seguinte instrução:

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

Que impede que o avião saia da tela, através do reajuste da posição dele na

coordenada X, que será a largura da tela – a largura do avião.

Quando o avião anda para trás, é executado a seguinte avaliação condicional:

if(aviao.GetX() < 0)

Que verifica se o avião está começando a sair da tela (se a posição X do objeto

for menor que 0). Se a condição for verdadeira, será executada a seguinte

instrução:

aviao.SetX(0);

Que reajusta a posição do avião , pela coordenada X (definindo a coordenada X

com o valor “0”).

Quando o avião anda para cima, é executado a seguinte avaliação condicional:

if(aviao.GetY() < 0)

Que verifica se o avião está começando a sair da tela (se a posição Y do objeto

for menor que 0). Se a condição for verdadeira, será executada a seguinte

instrução:

aviao.SetY(0);

Que reajusta a posição do avião , pela coordenada Y (definindo a coordenada Y

com o valor “0”).

112

Quando o avião está se movimentando para baixo, é executada a seguinte

avaliação:

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

Que verifica se o avião está começando a sair da tela (se a posição atual do avião

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

Isso é uma regra padrão). Caso a condição seja verdadeira, é executado a

seguinte instrução:

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

Que impede que o avião saia da tela, através do reajuste da posição dele na

coordenada Y, que será a altura da tela – a altura do avião.

Executando nossa aplicação, teremos o seguinte resultado:

Jogo em execução – Avião não sai mais da tela

113

OBSERVAÇÃO IMPORTANTE

Antes de prosseguirmos para o próximo capítulo, se observarmos no nosso

emulador, o primeiro exemplo que fizemos “DESAPARECEU”. Se realizarmos os

próximos exemplos, todas as aplicações serão substituídas.

Como solucionar este problema ?

Toda aplicação Android internamente NÃO É IDENTIFICADA pelo seu nome

(embora cada aplicação (exemplo) tenha um nome diferente), e sim pelo nome de

seu pacote (que todo projeto do GameUtil2D é identificado pelo ID de

“gameutil2d.framework”, pois é nele que tem a aplicação principal que é a classe

GameActivity).

Para solucionarmos este problema, abra o projeto que você desenvolveu no

Android Studio e em seguida clique no menu “File” e em seguida clique em

“Project Structure” (ou pressione “CTRL+SHIFT+ALT+S”). Feito isso será aberta a

seguinte caixa de diálogo:

Caixa de diálogo – Project Structure

114

Vamos agora clicar na guia “Flavors”, conforme indica a figura a seguir:

Feito isso será exibido o seguinte painel:

Guia Flavors em exibição

Nessa guia existem vários campo, mas, o campo que iremos dar atenção é o

campo “Application Id”. Nele informamos o identificador da aplicação (expresso

como um nome de pacote). O nome padrão é “gameutil2d.framework”.

Se não mudarmos essa opção, todo é qualquer exemplo que for desenvolvido irá

substituir o antigo já instalado. Para evitarmos isso mude o nome do

indentificador. Ex : gameutil2d.visualizandoimagens.

115

Depois disso , que em “OK” para confirmar as alterações.

Após isso o projeto irá realizar as configurações automáticas de acordo com o

nome de ID escolhido. Quando tudo for concluído execute a aplicação e logo em

seguida, ENCERRE A APLICAÇÃO.

No emulador agora você verá DUAS APLICAÇÕES com o mesmo nome (sendo a

primeira com o ID “gameutil2d.framework” que substituiu a antiga e outra com o

novo ID que você adicionou).

116

Capitulo 8 Trabalhando com animação de sprites (A classe AnimationSprites)

os capítulos anteriores, aprendemos a visualizar imagens “estáticas” 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 animação ? Neste capítulo vamos aprender como realizar

essas animações usando sprites no jogo.

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

apresentam algum tipo de animação (como o movimento de um personagem ou a

ação de algum objeto). Agora a pergunta que faço é : como são realizadas essas

animações no jogo ? Essas animações são realizadas utilizando o que nós

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

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

ação 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 animação de um personagem (ou objeto) durante o jogo ? Se

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

cada uma delas é exibida numa fatia de “tempo”, dando a sensação de

movimento ou ação.

N

117

Para trabalharmos com animação de sprites aqui no Android, nós 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 começarmos, extraia o arquivo do framework em um diretório apropriado e

em seguida realiza as alterações conforme abaixo:

Nome da pasta : AnimacaoSprites

Constante “app_name” (arquivo “strings.xml” do seu projeto): 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 código do nosso jogo. Na declaração de

atributos, vamos realizar a seguinte declaração, conforme é mostrado em

seguida:

AnimationSprites naruto;

Agora dentro do método construtor GameMain , vamos escrever o seguinte

código (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 código inserido no método acima. A linha de comando:

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

Carrega a instância do objeto naruto do tipo AnimationSprites. No primeiro

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

118

parâmetro, passamos respectivamente a coordenada X e Y do objeto na tela. Já

os dois últimos parâmetros 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

animação do personagem, através do método Add. Em seguida, vem a seguinte

instrução:

naruto.Start(20, true);

Que tem a finalidade de “iniciar” a animação, através do método Start. Esse

método possui dois parâmetros : O primeiro parâmetro é responsável por definir,

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

animação vai ficar “em loop” (caso true) ou não (caso false).

Agora no método Draw vamos adicionar a seguinte instrução:

protectedvoid Draw(SpriteBatcher spriteBatcher) { naruto.Draw(spriteBatcher); }

Vamos executar agora a nossa demonstração ? Veja como ficou na figura

seguinte:

119

Animação do personagem em execução

Em uma animação de sprites também podemos aplicar o efeito e “flip” (inversão)

de uma imagem, na horizontal (como já havíamos visto com imagens estáticas).

Para invertermos uma imagem na horizontal, basta adicionar um parâmetro no

método Draw do objeto, o “FlipEffect.HORIZONTAL”.

Vamos voltar para o método Draw da classe GameMain para substituirmos a

linha abaixo:

naruto.Draw(spriteBatcher);

Por essa:

naruto.Draw(spriteBatcher,FlipEffect.HORIZONTAL);

Que inverte as imagens da animação (como havia falado, esse procedimento

acima funciona também para imagens estáticas). Veja o resultado na figura

seguinte:

120

Animação do personagem invertida na horizontal

Mais um exemplo de animação de sprites

Vamos realizar agora mais uma pratica de animação de sprites no Android

usando a classe AnimationSprites. Para essa pratica vamos usar um projeto já

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

“AnimacaoSprites_GundamWingAndroidStudio.zip”.

Descompacte o arquivo em um local apropriado e em seguida, abra o projeto e

execute logo em seguida. O resultado você confere na figura em seguida:

121

Jogo em execução

Esse é um exemplo baseado no jogo “Gundam Wing – Endless Duel”, um dos

grandes sucessos da plataforma “Super Nitendo”.

A intenção deste exemplo é trocarmos as posições dos personagens do jogo.

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

as seguintes modificações citadas a seguir:

Dentro do método onScreenLoading, vamos substituir as seguintes linhas de

código destacadas em vermelho abaixo:

publicvoid 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); heavy_arms.Add(R.drawable.heavy_arms_parado_1); heavy_arms.Add(R.drawable.heavy_arms_parado_2); : }

122

Pelas seguintes linhas de código destacadas em azul abaixo:

publicvoid 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 método Draw vamos substituir as seguintes linhas de código

destacadas em vermelho abaixo:

publicvoid Draw(SpriteBatcher spriteBatcher) { : wing_gundam.Draw(spriteBatcher); heavy_arms.Draw(spriteBatcher,FlipEffect.HORIZONTAL); }

Pelas seguintes linhas de código destacadas em azul abaixo:

publicvoid Draw(SpriteBatcher spriteBatcher) { : wing_gundam.Draw(spriteBatcher, FlipEffect.HORIZONTAL); heavy_arms.Draw(spriteBatcher); }

Depois de realizar as alterações de código citadas acima, execute novamente o

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

123

Jogo em execução – Personagens trocados de posição

Regras para a criação de sprites

Quando vamos criar as sprites (animações) de um determinado elemento de um

jogo, normalmente, cada imagem que irá representar uma ação desse elemento,

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

salvas, deverão estar nomeadas de forma que fique fácil a organização das

imagens (como por exemplo : personagem_andando_1.png ,

personagem_andando2.png e etc).

124

Capitulo 9 Detectando colisões entre objetos no jogo

ma das técnicas mais importantes que não se pode faltar em um jogo, é a

detecção de colisões entre elementos .Neste capítulo, iremos aprender a

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

através dos recursos oferecidos neste material.

Para a detecção de colisão entre elementos, iremos fazer uso da classe

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

Para começar, extraia o projeto do framework em um local apropriado. Em

seguida, realize as seguintes modificações abaixo:

Nome da pasta : ColisaoEntreObjetos

Constante “app_name” (arquivo “strings.xml” do projeto) : Colisao entre Objetos

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

diretório “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 código do

nosso jogo.

Dentro da seção de declaração de atributos, vamos realizar as declarações

abaixo, como segue:

AnimationSprites personagem; Image cenario; Image obstaculo,obstaculo2; Context context; Image seta_esquerda, seta_direita; enum Movimento { DIREITA, ESQUERDA, PARADO } Movimento movimentoPersonagem = Movimento.PARADO;

U

125

Agora dentro do método GameMain vamos escrever o seguinte código abaixo:

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

Agora dentro do método onScreenLoading vamos adicionar as seguintes

instruções:

publicvoid 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 método Update vamos escrever o seguinte código abaixo:

publicvoid Update() { if(movimentoPersonagem == Movimento.DIREITA) personagem.MoveByX(10); elseif(movimentoPersonagem == Movimento.ESQUERDA) personagem.MoveByX(-10); }

Agora dentro do método Draw vamos adicionar o seguinte código:

publicvoid Draw(SpriteBatcher spriteBatcher) { cenario.Draw(spriteBatcher); obstaculo.Draw(spriteBatcher); obstaculo2.Draw(spriteBatcher); personagem.Draw(spriteBatcher); seta_esquerda.Draw(spriteBatcher); seta_direita.Draw(spriteBatcher); }

126

E para finalizar, no método onTouch, vamos adicionar o seguinte código abaixo: publicvoid onTouch(MotionEvent e) { if(e.getAction() == MotionEvent.ACTION_DOWN) { if(seta_direita.IsTouch(e.getX(), e.getY())) movimentoPersonagem = Movimento.DIREITA; elseif(seta_esquerda.IsTouch(e.getX(), e.getY())) movimentoPersonagem = Movimento.ESQUERDA; } elseif(e.getAction() == MotionEvent.ACTION_UP) movimentoPersonagem = Movimento.PARADO; }

Depois de adicionarmos o código do nosso jogo, vamos executá-lo. O resultado

você confere na figura seguinte:

Jogo em execução

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

lado para o outro, porém, o nosso personagem não pode ultrapassar os

obstáculos (que são os elevadores).

127

A ideia seria desenvolver um código que irá detectar a colisão do personagem

com os obstáculos, que no caso são os elevadores.

Para adicionarmos o código de colisão, vamos no método Update para

adicionarmos as seguinte instruções, destacados em azul abaixo:

publicvoid Update() { if(movimentoPersonagem == Movimento.DIREITA) { personagem.MoveByX(10); //Colidiu com o obstáculo da direita ("obstaculo2") if(Collision.Check(personagem, obstaculo2)) personagem.MoveByX(-10); } elseif(movimentoPersonagem == Movimento.ESQUERDA) { personagem.MoveByX(-10); //Colidiu com o obstáculo da esquerda ("obstaculo") if(Collision.Check(personagem, obstaculo)) personagem.MoveByX(10); } }

Irei explicar agora o código que avalia a colisão do personagem com as barras

horizontais e verticais. A expressão abaixo: if(movimentoPersonagem == Movimento.DIREITA)

Verifica se a variável movimentoPersonagem está assumindo o status

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

Se a condição acima for verdadeira, o personagem irá se deslocar para direita, 10

pixels, através da instrução abaixo:

personagem.MoveByX(10);

Em algum momento do deslocamento, poderá haver um determinado momento em que o personagem poderá se colidir com o obstáculo da direita (o objeto obstaculo2), agora, como avaliar se houve a colisão ? Para verificar se houve uma colisão entre dois objetos usamos o método Check da classe Collision, como podemos ver na instrução abaixo:

if(Collision.Check(personagem, obstaculo2))

128

Se ocorrer uma colisão, nosso personagem irá voltar um passo anterior (se ele

andou 10 pixels para direita e nesse movimento ele colidiu com o obstáculo, ele

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

personagem.MoveByX(-10);

A explicação das condições seguintes é “similar” ao que foi explicado agora. Vamos executar agora a nossa demonstração e conferir os resultados.

Jogo em execução – Personagem Colide com o Elevador

Como pudemos observar acima, a colisão é uma das técnicas de

desenvolvimento de jogos mais importantes, com essa técnica conseguimos

muitas coisas (como verificar se o personagem está pisando em algum bloco, se

um tiro atingiu o inimigo e etc.).

Realizando mais um exemplo demonstrando colisões

Vamos realizar agora mais um exemplo de colisão entre objetos. Para isso,

vamos extrair a abrir o arquivo “ExemploColisao_PacmanAndroidStudio.zip”, que

já acompanha este material.

Após abrir o projeto no Android Studio execute o jogo e confira o resultado:

129

Jogo em Execução – Pacman

Qual será a ideia desse jogo ?

A ideia é utilizar a técnica da colisão para detectar a captura dos itens feitos pelo

pacman, removendo da tela cada item pego.

Vamos dentro do método Update para escrevermos o seguinte código destacado

em azul em seguida:

publicvoid Update() { if(movimentoPersonagem == Movimento.DIREITA) { pacman.MoveByX(5); for(Image item : aItens) { if(Collision.Check(pacman, item)){ aItens.remove(item); break; } } } elseif(movimentoPersonagem == Movimento.ESQUERDA) pacman.MoveByX(-5); }

130

Toda vez que o nosso personagem anda para a direita, é verificado se o

personagem colidiu com algum item, pelo seguinte código:

for(Image item : aItens) { if(Collision.Check(pacman, item)){ aItens.remove(item); break; } }

Que “varre” todo o array aItens através do for-each. A cada iteração dentro do for-

each, é executado a seguinte avaliação:

if(Collision.Check(pacman, item))

Que verifica se o objeto representado pela instância item colidiu com o objeto

personagem, que representa o nosso pacman. Se a condição for verdadeira, o

item capturado pelo personagem é removido do array pela instrução: aItens.remove(item);

Execute novamente o nosso jogo e confira o resultado, conforme demonstra a figura seguinte:

Jogo em execução – Capturando itens

131

Conclusão a respeito do material

Nesta apostila aprendemos alguns tóicos essenciais voltados para o

desenvolvendo jogos para a plataforma Android. Vimos um pouco sobre a

plataforma Android, como ela surgiu e tudo mais. Aprendemos a instalar e

configurar o Android Studio, que é a ferramenta que utilizamos para criar os

nossos jogos e o emulador BlueStacks, que utilizamos para executar nossos

games. Conhecemos também um pouco da framework de desenvolvimento de

jogos para Android chamado GameUtil2D (que eu mesmo desenvolvi, e que

encontra no link www.gameutil2d.org) que pode ser utilizado junto com o Android

Studio.

Depois do conhecimento do framework apresentado, aprendemos passo a passo

a construir alguns exemplos de jogos utilizando as classes oferecidas pela

GameUtil2D (As classes Image, AnimationSprites e Collision).

Se você quiser uma abordagem “mais completa” (incluindo mais técnicas de

desenvolvimento como criação de elementos dinâmicos na tela, inteligência

artificial, gerenciamento de telas e etc.) sobre desenvolvimento de jogos, além de

aprender a criar um jogo completo, adquira a “Apostila de Android –

Desenvolvimento de Jogos” 3ª Edição COMPLETA, efetuando o pagamento do

seu valor através do PagSeguro. Visite o site www.apostilaandroid.net para

mais informações à respeito da Apostila de Desenvolvimento de Jogos

“completa”.

Espero que esse material lhe tenha sido útil.

Abraços

Até o momento nenhum comentário
Esta é apenas uma pré-visualização
3 mostrados em 131 páginas