Desenvolver Jogos Para Smartphones e Tablets Que Utilizam a Plataforma Android

Que tal você desenvolver jogos para smartphones e tablets que utilizam a plataforma

Android? Você não sabe por onde começar ou o que precisa fazer?

Relaxa ... siga esse e os próximos tutoriais escritos por mim sobre desenvolvimento de

jogos Android que você fará games logo, logo. o/

Apresentando-se e explicando as ferramentas de trabalho

Então meu povo, para termos um início mais tranquilo, eu vou explicar sobre algumas

ferramentas que vamos trabalhar daqui em diante. Elas serão a base para que você possa

fazer praticamente qualquer aplicação Android. Vou deixar claro que vou focar todos os

tutoriais em um ambiente de desenvolvimento no Windows 8, mas saibam que todas essas

ferramentas têm para Linux também. Dessa forma se você curte o sistema operacional,

você pode baixá-las e fazer meus tutoriais da mesma forma. =]

Eu vou me referir como “ambiente de desenvolvimento” ao conjunto de todas as

ferramentas necessárias para podermos desenvolver uma aplicação Android. Mas quais

são essas ferramentas, Santy? (sim, esse é o meu apelido).

O ambiente de desenvolvimento padrão precisa de pelo menos o compilador Java e do kit

de desenvolvimento Android do Google. Sem eles, meus amigos, esqueçam. Eu

aconselho fortemente (tipo ... FORTEMENTE) vocês incluírem o Eclipse IDE como parte

do ambiente de desenvolvimento. Ele ajuda muito o desenvolvedor evitando um monte de

trabalho braçal com compilação e durante a procura de erros quando vocês começarem a

programar.

Vou explicar cada uma dessas ferramentas por partes.

O compilador Java

Para quem não sabe o que é um compilador, ele é um programa que transforma seu

código escrito em um programa de computador. Faz sentido ele ser essencial para quem

quer desenvolver aplicações para Android, não? É o compilador Java que vai ler o

programa que você vai escrever e transformar no arquivo que você geralmente baixa do

Google Play quando instala um aplicativo de lá.

O real nome do compilador é Java SE Development Kit, traduzindo para o português fica:

kit de desenvolvimento Java SE. O SE significa Standard Edition, que no português fica:

edição padrão. Tudo isso pode ser abreviado como JDK. \o/

Você pode baixar o compilador Java

diretamente do site da Oracle, que detêm os direitos do Java, clicando aqui. Você poderá

ver que tem bastantes instalações lá. Escolha aquela que é própria para o sistema

operacional que você está usando. A instalação é bem tranquila, seguindo aquele padrão

“next → next → finish”.

Para testar se você instalou direito, segure o botão do Windows e aperte “R”. Vai abrir a

janelinha “Executar”. Ali você digita “cmd” e aperta enter. Vai abrir a tela do prompt de

comando. No prompt de comando, você digita “cd %JAVA_HOME%” e aperta enter. Logo

depois, digite “javac -version”. Se aparecer “javac <alguma coisa>” significa que você

instalou certinho. Coloquei abaixo as imagens da tela do “Executar” (Figura 1 – Tela

executar) e do prompt de comando (Figura 2 – Tela do prompt) com os comandos que eu

falei para vocês digitarem. Provavelmente essas imagens vão ajudar bastante vocês.

Figura 1- Tela Executar

Figura 2 - Tela do Prompt

Kit de Desenvolvimento Android

O nome real dele é Android Software

Development Kit, que traduzindo fica: kit de desenvolvimento de aplicações Android. O

pessoal que desenvolve para a plataforma chama mais de Android SDK.

Você pode baixar o Android SDK no site próprio do Google para desenvolvedores Android

clicando aqui. Na página, clique em “Download SDK”.

Você fará o download de um arquivo compactado. Descompacte-o em qualquer lugar.

Quando você descompactar você verá que ali tem uma pasta do Eclipse e uma do próprio

SDK. Sim … até o pessoal do Google acha interessante você usar o Eclipse. ;D

Enfim, copie essas duas pastas onde você achar melhor, mas elas precisam estar juntas

(sdk e eclipse juntas na mesma pasta). Não as separe senão você terá vários problemas.

Você já está com praticamente todo o ambiente de desenvolvimento na sua máquina.

Agora só falta configurá-lo. Para isso, vamos saber como “funca” (funciona) o Eclipse IDE.

Eclipse IDE:

O nome real é Eclipse Integrated Development

Environment, traduzindo: ambiente de desenvolvimento integrado Eclipse. Ele fornece

praticamente tudo o que o desenvolvedor precisa. Aplicativo de edição de código, mostra

erros nos códigos, ajuda a consertar erros mostrando várias possíveis correções, compila

de forma automática e instala automaticamente no seu aparelho celular ou tablet, informa

erros e onde ocorreram esses erros. Cara … ele é uma maravilha para quem desenvolve.

Se você quiser saber mais sobre ele, entre no site oficial aqui. MAS … ele precisa ser

configurado, obviamente.

Para isso, primeiramente o abra, entrando na pasta eclipse e clicando em eclipse.exe.

Clique em “Ok” na tela que vai aparecer e então ele abrirá a tela inicial do Eclipse. Nela,

clique no botão “Android SDK Manager”. Se você não achou o botão, olhe o print de tela

que eu coloquei abaixo (Figura 3 – Botão SDK Manager). Clicando ali, ele vai abrir o

Gerenciador de pacotes do Android. Também coloquei uma imagem da tela dele (Figura 4

- SDK Manager). Para você conseguir desenvolver um aplicativo (game) você precisará

baixar pelo menos uma plataforma (eu baixo todas). Aconselho vocês a baixarem aquela

que é a do teu aparelho de teste. Se você não tem um aparelho de teste, baixe a última

mesmo (Android 4.3 API 18, nesse momento). Você precisará baixar também todas as

ferramentas (Tools).

Figura 3- Botão SDK Manager

Figura 4 - SDK Manager

Fazendo isso, respeitáveis leitores, vocês acabaram de configurar o ambiente de

desenvolvimento. Eeeeeeee . o/

Já dá para começar a programar, mas isso é tema para o próximo tutorial. ;D

Vamos com calma que tudo dará certo. Mas se vocês já quiserem ir fuçando ...

Pessoal, também quero

apresentar a vocês o melhor amigo de todo desenvolvedor Android, o canal Android

Developers. Vocês podem acessá-lo por aqui. Praticamente tudo o que eu falei no tutorial,

eu tirei dali. Legal, né? Qualquer dúvida que vocês tiverem que foge um pouco dos

tutoriais, procurem lá que muito provavelmente vocês acharão a resposta.

Aos desenvolvedores em Linux, existem algumas coisas que talvez vocês precisarão se

preocupar amais. Olhem nessa página, cliquem em “System Requirements” e deem uma

olhada lá caso esse tutorial não ajude vocês.

No próximo tutorial vamos desenvolver nossa primeira aplicação Android. Provavelmente

eu vou ver um game simples para já termos um bom resultado logo de cara.

No último tutorial, eu mostrei para vocês como configurar o ambiente de desenvolvimento

Android. Falei sobre o compilador Java, o SDK Android e sobre o Eclipse IDE. Nesse

tutorial, eu falarei sobre como instalar o driver do seu aparelho Android para rodarmos

nosso jogo no seu aparelho, como o configurar para executar a aplicação e os passos para

fazermos o nosso primeiro game.

Obviamente, como estamos iniciando, não esperem que vamos desenvolver hoje

um World of Warcraft para tablet. Isso seria um pouco ambicioso de nossa parte. Mas

como eu sei que vocês são confiantes e querem desenvolver jogos ao nível, então vamos

começar pelo basicão: o Jokenpô, ou o famoso jogo “pedra, papel e tesoura”. Vamos

começar? Let's play!

Instalação do driver e configuração do aparelho

Para você poder rodar uma aplicação

Android no seu celular ou tablet, você precisa instalar o driver USB no seu PC. Isso é

necessário principalmente porque o ambiente de desenvolvimento precisa se comunicar

certinho com o celular. Como existem aparelhos de muitas fabricantes diferentes, você

precisará encontrar o driver do seu aparelho na lista disponibilizada pelo Google. Procure

diretamente no site do fabricante do seu aparelho o driver do seu modelo certinho e

instale.

Agora você precisa configurar o seu telefone ou tablet para o modo depurador. O modo

depurador faz com que o seu aparelho fique apto para executar qualquer operação de

desenvolvimento conectado com o PC. Esse início é meio técnico, mas ele será realizado

uma única vez. =]

No seu aparelho, faça os seguintes caminhos:

Botão de Opções → Configurações → Segurança → Fontes desconhecidas

Deixa essa opção selecionada.

http://us.battle.net/wow/pt/

http://www.eclipse.org/

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

http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html?ssSourceSiteId=otnpt

http://www.fabricadejogos.net/posts/tutorial-desenvolvimento-de-jogos-para-android-parte-1

Botão Opções → Configurações → Opções do desenvolvedor → Depuração de

USB

Deixa essa opção selecionada também.

A Figura 1 mostra as telas das primeira e segunda opções. Vale falar que essas telas são

do Android versão 4.0.3 (Ice Cream Sandwich). Talvez o caminho para chegar nessas

opções varie dependendo a versão do seu Android.

Figura 1 - Depuração USB

Se vocês observarem, tem uma opção que eu não falei sobre o que é. Quando vocês

clicam em “Fontes desconhecidas”, o seu aparelho fica livre para instalar qualquer

aplicativo fora do Google Play. Como o seu jogo ainda não está publicado no Google Play,

você precisa selecionar essa opção para que o Android instale o seu jogo. Vale lembrar

que quando você clica nessa opção, o seu celular fica mais vulnerável a ataques de vírus.

Cuide sempre do seu celular desabilitando essa opção, logo depois de você desconectar o

seu celular da USB do seu PC.

Após instalar o driver e configurar o seu celular para desenvolvimento, vamos ver se ele é

reconhecido pelo SDK Android. Se ele for reconhecido, então ele está pronto para rodar o

seu aplicativo. Mas como fazer isso?

Primeiro conecte o seu aparelho em modo de depuração na USB do seu PC. Logo após

entre do Prompt de Comando. Se você não lembra como entrar no Prompt de Comando,

https://play.google.com/store?hl=pt_BR

olhe no primeiro tutorial como se faz. Acesse a pasta onde você descompactou o SDK

Android digitando “cd <c:\caminho da pasta>”. Digite “cd platform-tools” e aperte enter.

Digite “adb devices” e aperte enter. Se aparecer algum dispositivo na lista de aparelhos,

então você fez tudo certinho. =]

A Figura 2 mostra os comandos que eu fiz e o meu aparelho listado ali. No meu

computador, o SDK está copiado dentro da minha pasta de Arquivos e Programas. Eu

apaguei as primeiras letras do número identificador do meu celular porque eu não quero

que vocês o saibam. =P

Figura 2 - Dispositivo detectado

Bora programar nosso primeiro game? Weee … *_*

Criando o Projeto do Jogo no Eclipse

É bem tranquilo para criarmos o nosso projeto no Eclipse. Vou mostrar para vocês como

fazer isso praticamente do zero e com imagens sequenciais.

Primeiramente abra o Eclipse IDE. Clique no menu superior “File”, selecione “New” e

clique em “Other ...”.


Na janela que abriu, expanda a pasta “Android”, selecione a opção “Android Application

Project” e clique em “Next”.

Dê o nome da aplicação de “Jokenpo”. Depois disso, será preenchida a maioria dos

campos automaticamente. Eu mudei o nome do pacote para “com.santy.Jokenpo” por

opção mesmo. Ali nos campos sobre versão do Sistema Operacional Android, de

preferência, coloque a versão do seu aparelho em todos. Clique em “Next”.

Clique em “Next” nas próximas telas até aparecer a tela “Blank Activity”. Nessa tela, você

modifica o nome da Activity para “JokenpoActivity”. Clique em “Finish”.

Você acabou de criar a sua primeira aplicação Android. \o/

Agora eu vou mostrar o que você precisa fazer para criar o jogo Jokenpo. Esse jogo eu

programei aqui unicamente para vocês executarem aí. Não vai dar para eu explicar tudo o

que eu fiz nesse tutorial, mas eu explicarei tudo no próximo. Apenas façam o que eu

falar. ;D

Programando o Jokenpo

Após vocês criarem o projeto, vão no lado esquerdo da janela do Eclipse, em “Package

Explorer” abram a pasta “res” e a subpasta “values”. Nessa última pasta, tem um arquivo

“strings.xml”, abra-o clicando duas vezes sobre ele. Quando você abrir esse arquivo, ele

vai ser apresentado no centro da janela do Eclipse. Nessa parte, logo abaixo, tem uma aba

chamada “strings.xml”, clique nessa aba. A Figura 3 mostra sequencialmente todo o

caminho que eu descrevi.

Figura 3 - Editando o arquivo strings.xml

No editor de texto que abriu, digite as linhas a seguir:

<?xml version="1.0" encoding="utf-8"?>

<resources>

<string name="app_name">Jokenpo</string>

<string name="action_settings">Settings</string>

<string name="opcoes">Escolha uma opção</string>

<string name="ultimaJogada">Última Jogada</string>

<string name="jogadaPlayer">Você</string>

<string name="resultado">Resultado</string>

<string name="jogadaPC">Computador</string>

</resources>

Escrevendo isso, nós acabamos de criar um conjunto de constantes Strings que serão

utilizadas no jogo. Como eu falei, a explicação mais aprofundada eu deixarei para o

próximo tutorial.

Após isso, salve e feche o arquivo. Agora, crie uma pasta dentro da pasta “res” chamada

“drawable”. Após criá-la, coloque dentro os arquivos de imagem anexos nesse tutorial.

Esses arquivos podem serbaixados aqui. Para criar uma pasta em “res”, clique com o

botão direito em “res”, selecione “New” e clique em “Folder”. Depois de criar a pasta,

arraste os arquivos de imagem para dentro dela. A Ilustração 4 mostra como o projeto vai

ficar depois disso.

Figura 4 - Inclusão dos arquivos de imagem

http://adf.ly/qtYgk

Acabamos de incluir no projeto as imagens que ficarão nos botões quando você for

escolher se você quer pedra, papel ou tesoura. Essas imagens eu busquei na internet e,

como eu vi em vários blogs, então eu conclui que elas caíram em domínio público. De

qualquer forma, eu deixo claro que esse tutorial serve unicamente como aprendizado e

não como uma forma de eu ganhar dinheiro.

Depois disso, abra a pasta “res” e abra a subpasta “layout”. Nessa última pasta tem um

arquivo chamado “activity_jokenpo.xml”. Abra esse arquivo e selecione a aba

“activity_jokenpo.xml”, assim como fizemos quando editamos o arquivo “strings.xml”.

Nesse editor de texto, escreva as seguintes linhas:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:paddingBottom="@dimen/activity_vertical_margin"

android:paddingLeft="@dimen/activity_horizontal_margin"

android:paddingRight="@dimen/activity_horizontal_margin"

android:paddingTop="@dimen/activity_vertical_margin"

tools:context=".JokenpoActivity" >

<TextView

android:id="@+id/textView1"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_above="@+id/button2"

android:layout_centerHorizontal="true"

android:text="@string/opcoes"

android:textSize="30sp" />

<Button

android:id="@+id/button1"

android:layout_width="100dp"

android:layout_height="100dp"

android:layout_above="@+id/textView2"

android:layout_toLeftOf="@+id/button2"

android:background="@drawable/pedra" />

<Button






android:background="@drawable/papel" />

<Button





android:layout_toRightOf="@+id/button2"

android:background="@drawable/tesoura" />

<TextView





android:layout_centerVertical="true"

android:text="@string/ultimaJogada"


<TextView




android:layout_below="@+id/textView2"

android:layout_toLeftOf="@+id/imageView2"

android:text="@string/jogadaPlayer" />

<ImageView





android:layout_centerHorizontal="true" />

<ImageView





android:layout_toRightOf="@+id/imageView2" />

</RelativeLayout>

Acabamos de modelar a principal tela do jogo com esse código. Agora vamos incluir a

lógica no jogo. Para isso, abra a pasta “src” e a subpasta “com.santy.jokenpo”. Ali dentro

tem um arquivo chamado “JokenpoActivity.java”. Abra-o e digite no editor o seguinte

código:

package com.santy.jokenpo;

import java.util.Random;

import android.os.Bundle;

import android.app.Activity;

import android.view.Menu;

import android.view.View;

import android.view.View.OnClickListener;

import android.widget.Button;

public class JokenpoActivity extends Activity {

private Random numeroAleatorio;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_jokenpo);

numeroAleatorio = new Random();

Button pedra = (Button)findViewById(R.id.button1);

pedra.setOnClickListener(new OnClickListener() {

public void onClick(View v) {

findViewById(R.id

.imageView1).setBackgroundResource(R.drawable.pedra);

realizaJogadaPC(1);

}

});

Button papel = (Button)findViewById(R.id.button2);

papel.setOnClickListener(new OnClickListener() {


findViewById(R.id

.imageView1).setBackgroundResource(R.drawable.papel);

realizaJogadaPC(2);

}

});

Button tesoura = (Button)findViewById(R.id.button3);

tesoura.setOnClickListener(new OnClickListener() {


findViewById(R.id

.imageView1).setBackgroundResource(R.drawable.tesoura);

realizaJogadaPC(3);

}

});

}

public void realizaJogadaPC(int jogadaPlayer) {

int jogadaPC;

jogadaPC = numeroAleatorio.nextInt(3) + 1;

if(jogadaPC==1) {

findViewById(R.id

.imageView3).setBackgroundResource(R.drawable.pedra);

if(jogadaPlayer==1)

findViewById(R.id

.imageView2).setBackgroundResource(R.drawable.empatou);

else if(jogadaPlayer==2)

findViewById(R.id

.imageView2).setBackgroundResource(R.drawable.venceu);

else

findViewById(R.id

.imageView2).setBackgroundResource(R.drawable.perdeu);

}

else if(jogadaPC==2) {

findViewById(R.id

.imageView3).setBackgroundResource(R.drawable.papel);

if(jogadaPlayer==1)

findViewById(R.id



findViewById(R.id


else

findViewById(R.id


}


findViewById(R.id

.imageView3).setBackgroundResource(R.drawable.tesoura);

if(jogadaPlayer==1)

findViewById(R.id



findViewById(R.id


else

findViewById(R.id


}

}

@Override

public boolean onCreateOptionsMenu(Menu menu) {

// Inflate the menu; this adds items to the action bar

if it is present.

getMenuInflater().inflate(R.menu.jokenpo, menu);

return true;

}

}

Muito provavelmente o Eclipse deve apontar algum erro. Apontando ou não, é necessário

que ele atualize o projeto com todas as modificações que você fez. Para isso, clique no

menu superior “Project” e selecione “Clean ...”. Na janela que abrir, selecione “Clean all

projects” e clique em “OK”. Nesse momento, o Eclipse atualiza todo o projeto e elimina os

erros. As Ilustrações abaixo mostram o caminho e a tela que será aberta.

Figura 5 - Opção de limpeza do projeto

Figura 6 - Limpeza de todos os projetos

Uffffaaa … vamos rodar o game agora. ;D

Rodando o jogo no seu dispositivo

Se o seu celular estiver ligado na USB do PC e devidamente configurado como fizemos e

testamos, ele executará o jogo. Está curioso … né!? =P

No Eclipse, selecione a opção “Run” no menu superior e clique em “Run

Configurations ...”.

Figura 7- Opção de execução

Na tela que abrir, dê duplo clique na opção “Android Application”. Logo do lado, coloque

em nome a palavra “Jokenpo”. Clique em “Browse...” e selecione “Jokenpo”. Em “Launch

Action”, selecione “Launch” e selecione a opção “com.santy.jokenpo.JokenpoActivity” no

combobox logo ao lado. Logo após mude a aba clicando em “Target”.

Figura 8 - Configurando Execução do jogo

Na nova aba, clique em “Always prompt to pick device” e clique em “Run”. Você acabou de

executar o jogo que você programou. ;D

Quando você clicar em “Run” vai abrir uma tela perguntando em qual dispositivo você quer

executar o jogo. Selecione o seu dispositivo na tela e clique em “OK”. A Ilustração abaixo

mostra a tela de escolha de dispositivo.

Figura 9 - Seleção do dispositivo

Olhe a tela do seu celular e você verá o game executando. AAAWWWW YEEAAAHHH.

Corre mostrar o seu jogo para o seu irmão, amigo, pai, avô, tio, cunhado, namorada (o),

cachorro e para quem for. ;D

Para os curiosos de plantão que estão lendo o tutorial e não o estão fazendo, a Ilustração

abaixo é a tela do jogo executando.

Figura 10 - Execução do jogo Jokenpo

Ah, Santy … mas eu não tenho nenhum celular Android. O que eu faço? Eu vou explicar,

no próximo tutorial, cada linha de código que eu coloquei nesse, além de falar sobre como

executar o jogo no emulador que vem junto com o SDK. Infelizmente não dá para mostrar

tudo para todo mundo em um tutorial só. Aguardem. =]

Aprendemos hoje a instalar os drivers de um dispositivo Android para desenvolvimento.

Aprendemos também a configurar o dispositivo para ele servir como um aparelho teste.

Vimos como criar um projeto no Eclipse e como executar um aplicativo no celular.

Bastante coisa né!?

No tutorial Desenvolvimento de jogos para Android – Parte 2, eu mostrei para vocês como

instalar o driver do seu dispositivo e como configurá-lo para ele executar a sua aplicação

Android. Programamos também um game de Jokenpô.

Então meu povo, hoje vamos aprender como executar o jogo que vocês programaram

no emulador do SDK Android para qualquer tipo de hardware. Achei melhor deixar a parte

de explicação do programa para um único tutorial. O tutorial que explicará todo o código

será o próximo. Que tal irmos devagar? Muita informação às vezes confunde. ;D

Bora executar o jogo no emulador? Bora.

Como executar o jogo no emulador do SDK Android?

Eu comentei no último tutorial que é possível rodar o jogo no emulador que vem junto com

o SDK Android. Esse suporte é necessário porque nem sempre você tem um aparelho

para testar o jogo. Às vezes, também, o seu jogo precisa funcionar em todos os aparelhos

do mercado e, você concorda comigo que é um pouco caro comprar todos para fazer

testes. ;D

Primeiramente você precisa cadastrar um novo dispositivo virtual. O SDK trata dispositivos

virtuais da mesma forma como ele trata um dispositivo físico. Na verdade, ele “cria” um

celular com um determinado hardware e software do sistema Android. Quando você roda o

seu jogo, ele executa todo o sistema operacional Android em uma janela que representa o

dispositivo virtual criado. Ele, basicamente, emula um celular no seu computador. Para

criar um dispositivo virtual, clique no botão “Android Virtual Device Manager”, mostrado na

Ilustração 1.

http://developer.android.com/tools/devices/emulator.html


Ilustração 1- Gerenciador de dispositivos

Quando você clica nesse botão, ele abre a janela mostrada na Ilustração 2. Nessa janela

são listados todos os dispositivos virtuais criados para você testar o seu game. Se já tiver

cadastrado algum dispositivo, apague e crie um novo clicando em “New...”. O interessante

de criar dispositivos virtuais é que você poderá, por exemplo, criar três dispositivos

diferentes com tamanhos de tela diferentes. Você conseguirá ver como fica o seu jogo

rodando em celulares com diferentes tamanhos de tela.

Ilustração 2- Janela de dispositivos virtuais

Logo depois de você clicar em “New...” a janela de criação de um novo dispositivo virtual é

aberta. Essa janela é mostrada na Ilustração 3. Em “ADV Name” você nomeia o dispositivo

virtual como você desejar. Eu nomeei como “DispositivoVirtual”. Em “Device”, você escolhe

um dispositivo padrão certificado pelo Google. Eu escolhi um que tem a tela pequena

(320x480). Em “Target” você coloca no mínimo a versão de API que a sua aplicação está

sendo desenvolvida. Nós colocamos Android 2.2, lembra? Eu coloquei uma memória flash

no cartão SD de 256 MB. A nossa aplicação independe disso, mas eu coloquei mesmo

assim. Hehe.

Ilustração 3- Criando um novo dispositivo virtual

Quando você clica em “OK”, o novo dispositivo é adicionado na lista de dispositivos

virtuais. Agora você pode fechar a janela de dispositivos virtuais e executar a aplicação,

assim como fizemos para rodar o jogo no tutorial anterior. Se você configurou a execução

do jogo tudo certinho no tutorial anterior, então você poderá rodar o jogo simplesmente

clicando no botão “Run”. A Ilustração 4 mostra esse botão.

Ilustração 4- Botão para execução do jogo

Clicando nesse botão, a janela da Ilustração 5 é aberta. Primeiramente, você clica em

“Launch a new Android Virtual Device” mostrando que você executará o seu jogo em um

dispositivo virtual. Logo após, selecione o dispositivo virtual que você criou, nesse caso eu

selecionei “DispositivoVirtual”. Logo após, você pode clicar em “OK” para iniciar o

emulador. A Ilustração 5 mostra a sequência de cliques.

Quando você clica em “OK”, o computador começa a inicializar o dispositivo virtual e todo

o sistema operacional Android dentro do dispositivo. Como ele inicia todo um sistema

operacional, vai demorar um pouco até aparecer o seu jogo na tela. Apenas espere e veja

o resultado. ;D


Ilustração 5- Janela de execução do jogo

A Ilustração 6 mostra a inicialização do sistema operacional Android e a Ilustração 7

mostra o jogo sendo executado logo após a inicialização.

Ilustração 6- Inicialização do sistema Android

Ilustração 7- Execução do jogo no emulador

Quando você for rodar o seu aplicativo mais de uma vez, você pode deixar o emulador

aberto e apenas fechar o jogo dentro do emulador. Ao rodar o jogo novamente pelo

Eclipse, aparecerá um dispositivo na janela (Ilustração 5) onde você escolhe o dispositivo

para rodar o jogo. É só escolher o dispositivo virtual e você evita ter que inicializar todo o

sistema operacional do Android novamente.

Pronto … você que não tem tablet ou celular Android agora pode rodar o seu jogo no seu

PC. Se vocês forem curiosos e fuçarem no emulador, vocês verão que ele é praticamente

um celular dentro do computador. Você pode instalar e remover aplicativos, realizar

ligações (virtuais e não reais, obviamente), enviar e receber mensagens SMS e fazer

qualquer outra coisa. Yeeessss ...

Nesse tutorial nós vimos como executar um aplicativo Android no emulador que vem com

o SDK Android. No próximo tutorial veremos o que significa cada linha de código que

escrevemos ao programar o jogo Jokenpô do Desenvolvimento de jogos para Android –

Parte 2.

Já configuramos um monte de coisas, programamos o jogo Jokenpô e mostramos para os

outros que somos programadores Android, mas … e se nos perguntarem como

programamos? Vamos entender o que significam aqueles códigos que fizemos?

Relembrando o que fizemos até agora, no Desenvolvimento de jogos para Android - Parte

2 nós programamos o jogo Jokenpô. No Desenvolvimento de jogos para Android - Parte

3 eu mostrei como executar o jogo no emulador que vem com o SDK Android. Nesse

tutorial nós vamos aprender o que significa cada linha de código e a lógica usada no

Jokenpô.

Projeto Android e pastas editadas:

Antes de sabermos o que tem no código do Jokenpô, eu

mostrarei as pastas que mexemos e a função delas em um projeto Android. As pastas




editadas foram “src”, “res”, “drawable”, “layout” e “values”, como mostrado na figura ao

lado. Segue uma explicação breve sobre a função de cada uma delas no projeto Android.

src: contém todos os arquivos de código fonte do aplicativo. Arquivos de código

fonte, para quem não sabe, são os arquivos que contém códigos em uma

linguagem de programação e que ditam toda a lógica do aplicativo. Esses arquivos

são escritos na linguagemJava;

res: contém todos os arquivos de recursos do aplicativo. Esses podem ser

arquivos de layout (disposição dos elementos na tela), arquivos de imagem, vídeo

e de efeitos sonoros;

drawable: contém arquivos de imagem e arquivos descritores de objetos que

mudam seu design visual (botão clicado e não clicado, por exemplo);

layout: contém arquivos XML que descrevem a disposição dos elementos nas

diferentes telas do aplicativo;

values: contém arquivos que definem constantes com valores pré-definidos pelo

programador.

Existem outras pastas importantes que não mexemos no jogo do Jokenpô. Se você quiser

saber mais sobre cada uma dessas pastas, dê uma olhada aqui. Não vamos nos

desconcentrar do objetivo do tutorial. =]

Arquivos editados e função de cada um:

Os arquivos editados foram três no total: “JokenpoActivity.java”, “activity_jokenpo.xml” e

“strings.xml”. Se você não lembra onde eles estão, dê uma olhada na figura acima. Vou

explicar de forma sucinta a função de cada um deles. A ordem de explicação foi mudada

para vocês entenderem melhor o funcionamento do jogo.

strings.xml:

É um arquivo que especifica os valores das constantes textuais que serão utilizadas no

código. O nome do aplicativo e textos que fazem parte dos objetos da tela estão

especificados em cadeias de caracteres declaradas nesse arquivo. O que continha no

arquivo era:

<?xml version="1.0" encoding="utf-8"?>

<resources>

<string name="app_name">Jokenpo</string>

<string name="action_settings">Settings</string>

<string name="opcoes">Escolha uma opção</string>

<string name="ultimaJogada">Última Jogada</string>

<string name="jogadaPlayer">Você</string>

<string name="resultado">Resultado</string>

<string name="jogadaPC">Computador</string>

</resources>

Na primeira linha,

apenas é especificada qual versão do XML que o código está escrito, conforme a W3C, e

em qual tipo de codificação o arquivo será lido. Isso é meio que padrão, a não ser que

você queira mudar a codificação. Eu recomendo não mudar, senão caracteres especiais

como 'ç' e 'ã' serão apresentados de forma errada na tela.

Cada linha que inicia com a tag “string” é uma declaração de constante. Os nomes das

constantes estão entre aspas duplas e os valores delas estão entre a tag de abertura

(<tag>) e a tag de fechamento (</tag>).

No Jokenpô, foram criadas as constantes “app_name”, “action_settings”, “opcoes”,

“ultimaJogada”, “jogadaPlayer”, “resultado” e “jogadaPC”. Essas constantes serão

utilizadas no arquivo “activity_jokenpo.xml”, quando criarmos a tela do jogo, e durante a

programação da lógica, no arquivo “JokenpoActivity.java”.

activity_jokenpo.xml:

É um arquivo de layout, ou seja, especifica a disposição dos objetos gráficos na tela do

celular ou tablet. Toda a tela do aplicativo tem um arquivo XML que descreve a posição e

formato dos objetos. É possível você criar, limitar as bordas e posicionar cada objeto

diretamente no código Java, porém esse é um trabalho cansativo e desnecessário. A

edição de um objeto é feita no código Java como, por exemplo, a inclusão de uma opção

em um box, após o usuário clicar em um botão da tela. Como no jogo teve somente uma

tela, então existe somente esse arquivo na pasta “layout”. No arquivo tinha:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/

android"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:paddingBottom="@dimen/activity_vertical_margin"

android:paddingLeft="@dimen/activity_horizontal_margin"

android:paddingRight="@dimen/activity_horizontal_margin"

android:paddingTop="@dimen/activity_vertical_margin"

tools:context=".JokenpoActivity" >

<TextView




android:layout_above="@+id/button2"


android:text="@string/opcoes"


<Button





android:layout_toLeftOf="@+id/button2"

android:background="@drawable/pedra" />

<Button






android:background="@drawable/papel" />

<Button





android:layout_toRightOf="@+id/button2"

android:background="@drawable/tesoura" />

<TextView





android:layout_centerVertical="true"

android:text="@string/ultimaJogada"


<TextView





android:layout_toLeftOf="@+id/imageView2"

android:text="@string/jogadaPlayer" />

<TextView






android:text="@string/resultado" />

<TextView





android:layout_toRightOf="@+id/imageView2"

android:text="@string/jogadaPC" />

< ImageView





android:layout_toLeftOf="@+id/imageView2" />

< ImageView





android:layout_centerHorizontal="true" />

< ImageView





android:layout_toRightOf="@+id/imageView2" />

</RelativeLayout>

Nesse código, são especificados vários objetos que fazem parte de um layout, que é

especificado na tag “RelativeLayout”. Ele nos dá a liberdade de incluir os objetos onde

bem entendemos, desde que seja especificada a posição dele na tela. Alguns atributos

interessantes dessa tag são “android:layout_width” e “android:layout_height” que

especificam o tamanho do layout. Nesse caso, ambos foram atribuídos com

“match_parent”, que deixa claro que estamos lidando com toda a área da tela do aparelho.

A tag “Button” informa que foi adicionado um botão na tela, a tag “TextView” uma etiqueta

textual e a tag “ImageView” uma simples imagem. Dessa forma, adicionamos um total de

três botões, cinco etiquetas de texto e três imagens.

Quanto aos atributos, muitos se repetem entre os objetos. Vou explicar cada um deles:

"android:id": é um nome que o programador dá para que esse objeto possa ser

referenciado nos arquivos Java;

"android:layout_width" e “android:layout_height”: especificam a largura e a

altura do objeto, respectivamente;

“android:centerHorizontal” e “android:centerVertical”: especificam se o objeto

está centralizado horizontalmente e verticalmente na tela, respectivamente;

“android:text”: especifica o texto que será mostrado ao usuário. Nesse

caso, todos fazem referência a uma constante criada no arquivo “strings.xml”;

“android:textSize”: especifica o tamanho da fonte do texto;

“android:above” e “android:below”: especificam se o objeto está acima ou

abaixo de outro objeto, respectivamente;

“android:toLeftOf” e “android:toRightOf”: especificam se o objeto está à

esquerda ou à direita de outro objeto, respectivamente;

“android:background”: especifica a imagem de fundo que vai em um objeto.

Essa imagem precisa estar localizada na pasta “drawable”.

Se você for olhar bem, verá que existe uma etiqueta (TextView) central na tela (com “id”

igual a “textView2”) e todos os outros objetos são inseridos baseando-se na posição dessa

etiqueta. Tomando como base o significado de cada tag e atributo, não é difícil entender

como eu modelei a tela do jogo. =]

JokenpoActivity.java:

É um arquivo de código fonte, ou seja, ali está toda a lógica do jogo implementada na

linguagem Java. Todo arquivo de código fonte Java precisa ter a extensão “.java” e precisa

estar localizado em uma subpasta da pasta “src”. No caso desse jogo, foi necessário

somente um arquivo de lógica. Esse arquivo tinha:

package com.santy.jokenpo;

import java.util.Random;

import android.os.Bundle;

import android.app.Activity;

import android.view.Menu;

import android.view.View;

import android.view.View.OnClickListener;

import android.widget.Button;

public class JokenpoActivity extends Activity {

private Random numeroAleatorio;

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_jokenpo);

numeroAleatorio = new Random();

Button pedra = (Button)findViewById(R.id.button1);

pedra.setOnClickListener(new OnClickListener() {


findViewById(R.id.imageView1).setBackgroundResource(R.drawable.pedra);

realizaJogadaPC(1);

}

});

Button papel = (Button)findViewById(R.id.button2);

papel.setOnClickListener(new OnClickListener() {


findViewById(R.id.imageView1).setBackgroundResource(R.drawable.papel);

realizaJogadaPC(2);

}

});

Button tesoura = (Button)findViewById(R.id.button3);

tesoura.setOnClickListener(new OnClickListener() {


findViewById(R.id.imageView1).setBackgroundResource(R.drawable.tesoura

);

realizaJogadaPC(3);

}

});

}

public void realizaJogadaPC(int jogadaPlayer) {

int jogadaPC;

jogadaPC = numeroAleatorio.nextInt(3) + 1;

if(jogadaPC==1) {

findViewById(R.id.imageView3).setBackgroundResource(R.drawable.pedra);

if(jogadaPlayer==1)

findViewById(R.id.imageView2).setBackgroundResource(R.drawable.empatou

);


findViewById(R.id.imageView2).setBackgroundResource(R.drawable.venceu)

;

else

findViewById(R.id.imageView2).setBackgroundResource(R.drawable.perdeu)

;

}


findViewById(R.id.imageView3).setBackgroundResource(R.drawable.papel);

if(jogadaPlayer==1)


;



);

else


;

}


findViewById(R.id.imageView3).setBackgroundResource(R.drawable.tesoura

);

if(jogadaPlayer==1)


;



;

else


);

}

}

public boolean onCreateOptionsMenu(Menu menu) {

// Inflate the menu; this adds items to the

action bar if it is present.

getMenuInflater().inflate(R.menu.jokenpo, menu);

return true;

}

}

Nas primeiras linhas, que iniciam com a

palavra “import”, são inclusas algumas bibliotecas que especificam as funções dos objetos

que são utilizados no código. Não vou explicar hoje sobre linguagem Java, mas saibam

que esse é um requisito para quem quer programar Android. Talvez eu faça tutoriais sobre

linguagem Java (o que vocês acham?).

Na linha onde tem “public class”, eu estou criando uma classe que descreve o

comportamento da aplicação. Nessa classe, existe um método chamado “onCreate”, que é

iniciado quando o usuário da aplicação clica no ícone dela, lá na tela principal do Android.

Na linha onde tem “setContentView”, nós falamos para a aplicação jogar na tela o layout

especificado no arquivo “activity_jokenpo.xml”. Fácil, não? ;D

As linhas que iniciam “Button pedra”, “Button papel” e “Button tesoura” eu especifiquei o

que acontece quando o usuário clica nos botões pedra, papel e tesoura, respectivamente.

Vocês podem ver que são bem parecidas as linhas de código entre eles. Onde tem

“findViewById”, eu pego a referência dos botões que especificamos no arquivo

“activity_jokenpo.xml”. Depois de eu “selecionar” o botão que eu escolhi em

“findViewById”, eu programo a funcionalidade dele. A funcionalidade desses três botões

são similares: adicionar na tela a imagem da opção que o usuário fez na jogada e iniciar o

método (subrotina) “realizaJogadaPC”.

O método “realizaJogadaPC” recebe

como parâmetro um valor inteiro (“jogadaPlayer”) que informa qual foi a opção que o

jogador escolheu: 1 caso for pedra, 2 caso for papel e 3 caso for tesoura. Inicialmente esse

método realiza um sorteio entre três números: 1, 2 e 3. Logo após ele verifica qual número

foi sorteado, coloca na tela a opção do computador (a que foi sorteada) e faz a verificação

entre a jogada do usuário e a do computador. Dependendo do resultado, ele mostra se o

jogador perdeu, se ganhou ou se houve empate.

Existem algumas linhas de código que eu não expliquei porque eu achei

desnecessário, além de algumas que não valem a pena eu perder tempo explicando. Parte

dessas linhas são código geradas pelo próprio Eclipse, quando você cria uma aplicação e

parte eu adicionei, como o caso da variável para números aleatórios “numeroAleatorio”.

Mas, como vocês podem ver, a essência do programa está explicada: se o jogador clicar

em pedra, o aplicativo mostra a escolha do jogador na tela, faz um sorteio para definir a

opção do computador, mostra a opção dele na tela e dá o resultado final com base na

escolha do jogador e do computador.

Aqui terminamos mais um tutorial de desenvolvimento de jogos na plataforma Android.

Você já parou para pensar em tudo o que você aprendeu? Bastante coisa, né?

Nesse tutorial nós aprendemos como funciona o núcleo do jogo Jokenpô que

programamos no segundo tutorial. No próximo, saberemos como incluir efeitos sonoros

nos nossos jogos. ;D

A inclusão de efeitos sonoros e músicas de fundo são importantíssimas no

desenvolvimento de jogos eletrônicos. Muitos jogos são reconhecidos pelas suas músicas

de fundo. Posso dar os exemplos de uma das músicas da trilha do The Legend of Zelda e

do efeito sonoro de vitória da série Final Fantasy. Vamos incluir agora mesmo os efeitos

sonoros no Jokenpô. *_*

No tutorial anterior nós vimos como a lógica do Jokenpô foi programada na

linguagem Java. Vimos também como a tela principal do jogo foi modelada em um arquivo

XML. Nesse tutorial eu vou mostrar para vocês como é fácil incluir efeitos sonoros e

músicas de fundo no seu jogo que executa na plataforma Android. Vamos lá?

Classe MediaPlayer:

Então pessoal, iniciando o tutorial, eu vou falar sobre um dos pontos positivos da

linguagem Java e da maioria das linguagens orientadas a objetos. Se você precisa

programar algo que é padrão em vários aplicativos, pode ter certeza que já existe isso

implementado para você. No nosso caso, usaremos uma classe que lê e toca vários tipos

de arquivos de som no Android. Apresento a vocês a classe MediaPlayer.

Figura 1 - Diagrama de Estados da classe MediaPlayer

A Figura 1 mostra o diagrama de estados da classe MediaPlayer. Ali vocês verão que uma

música pode estar no estado “iniciada” (Started) e pode passar para o estado “reprodução

concluída” (PlaybackCompleted), por exemplo. Nesse tutorial nós não aplicaremos cada

um desses estados, mas saibam que vocês podem pausar a música (quando o telefone

toca, por exemplo) chamando o método “pause” enquanto a música está sendo tocada

(Started).

A classe MediaPlayer suporta vários tipos de arquivos

de áudio, entre eles podemos listar os arquivos MP3, WAVE, MIDI, AAC e mais alguns

(veja toda a lista aqui). O que vocês acham de colocarmos esse aprendizado em prática? \

o

Tocando os efeitos no Jokenpô:

Primeiramente, precisamos adicionar no projeto do Android uma pasta chamada “raw”.

Para isso, clique com o botão direito do mouse na pasta “res”, selecione “New” e clique em

“Folder”. Dê o nome da pasta a ser criada de “raw” e clique em “Finish”. Após isso será

criada uma nova pasta chamada “raw” dentro da pasta “res”. A Figura 2 mostra certinho o

procedimento.

Figura 2 - Criando a pasta "raw"

Após ter sido criada a pasta “raw”, adicione nela os

arquivos MP3 compactados nesse arquivo que eu disponibilizei para vocês testarem.

Asmúsicas contidas aqui são livres para serem usadas em qualquer jogo. Eu tirei essas

músicas desse site. Quando vocês forem fazer o jogo de vocês com outras músicas,

atentem aos direitos autorais delas. Para adicionar essas músicas em “raw”, basta arrastar

os arquivos MP3 para a pasta “raw” dentro do próprio Eclipse.

Após isso, atualize o projeto com esses arquivos adicionados. Para isso abra o menu

superior “Project” e clique em “Clean ...”. Na janela que abrir, selecione a opção “Clean all

projects” e clique em “OK”. A Figura 3 mostra a explicação dada em sequência de cliques.

Figura 3 - Atualizando o projeto Android

Agora basta abrir os arquivos MP3 e tocá-los quando quisermos. Coloquei dois arquivos

de efeito sonoro: um toca quando o jogador ganha do PC e o outro toca quando o jogador

perde. Estamos no momento de voltar a mexer nos códigos Java.

Abra o arquivo “JokenpoActivity.java” dentro da pasta “src”. Serão adicionadas nesse

arquivo as seguintes linhas de código.

MediaPlayer m = MediaPlayer.create(this,R.raw.win);

m.start();

Na primeira linha estamos abrindo um arquivo MP3 contido na pasta “raw” e na segunda

estamos dando o play no arquivo aberto.

Como queremos tocar o mesmo som sempre quando o jogador ganha, então, em todo o

código, onde estiver a linha:

findViewById(R.id


adicione, logo abaixo, as linhas:


m.start();

Como essas linhas sempre serão adicionadas dentro de uma estrutura de seleção (if),

então será necessário que você inclua chaves antes e depois delas. Ficará exatamente

dessa forma:

{

findViewById(R.id



m.start();

}

Para que seja tocado um efeito sonoro também quando o jogador perde, em todo o código,

adicione as linhas:

MediaPlayer m = MediaPlayer.create(this,R.raw.lose);

m.start();

logo abaixo da linha:

findViewById(R.id


Atente-se ao fato de que essas linhas também precisam estar dentro de um mesmo bloco

limitado por chaves, ficando:

{

findViewById(R.id


MediaPlayer m = MediaPlayer.create(this,R.raw.lose);

m.start();

}

Após você adicionar essas linhas, o jogo está pronto para ser executado.

Percebeu os sons que tocam quando você ganha e quando você perde? =]

Vale lembrar que não adicionamos os efeitos sonoros que tocam quando o jogador

empata. Mas acho que vocês estão aptos para incluir esse efeito a partir de agora. ;D

Caso, no seu jogo, você precise pausar ou continuar uma música de fundo, por exemplo,

dê uma olhada melhor nos métodos da classe MediaPlayer e no diagrama que eu

apresentei na Figura 1.

Com isso, concluímos mais um tutorial de desenvolvimento de

jogos para plataforma Android. Aprendemos como incluir efeitos sonoros e músicas de

fundo em um jogo. Nopróximo tutorial eu iniciarei o desenvolvimento de jogos com a

utilização de um motor gráfico muito bom: o Cocos2d-X.

Desenvolver Jogos Para Smartphones e Tablets Que Utilizam a Plataforma Android

Documents

Transcript of Desenvolver Jogos Para Smartphones e Tablets Que Utilizam a Plataforma Android