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.
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,
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
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:id="@+id/button2"
android:layout_width="100dp"
android:layout_height="100dp"
android:layout_above="@+id/textView2"
android:layout_centerHorizontal="true"
android:background="@drawable/papel" />
<Button
android:id="@+id/button3"
android:layout_width="100dp"
android:layout_height="100dp"
android:layout_above="@+id/textView2"
android:layout_toRightOf="@+id/button2"
android:background="@drawable/tesoura" />
<TextView
android:id="@+id/textView2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:text="@string/ultimaJogada"
android:textSize="30sp" />
<TextView
android:id="@+id/textView3"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/textView2"
android:layout_toLeftOf="@+id/imageView2"
android:text="@string/jogadaPlayer" />
<TextView
android:id="@+id/textView4"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/textView2"
android:layout_centerHorizontal="true"
android:text="@string/resultado" />
<TextView
android:id="@+id/textView5"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/textView2"
android:layout_toRightOf="@+id/imageView2"
android:text="@string/jogadaPC" />
<ImageView
android:id="@+id/imageView1"
android:layout_width="100dp"
android:layout_height="100dp"
android:layout_below="@+id/textView4"
android:layout_toLeftOf="@+id/imageView2" />
<ImageView
android:id="@+id/imageView2"
android:layout_width="100dp"
android:layout_height="100dp"
android:layout_below="@+id/textView4"
android:layout_centerHorizontal="true" />
<ImageView
android:id="@+id/imageView3"
android:layout_width="100dp"
android:layout_height="100dp"
android:layout_below="@+id/textView4"
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() {
public void onClick(View v) {
findViewById(R.id
.imageView1).setBackgroundResource(R.drawable.papel);
realizaJogadaPC(2);
}
});
Button tesoura = (Button)findViewById(R.id.button3);
tesoura.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
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
.imageView2).setBackgroundResource(R.drawable.perdeu);
else if(jogadaPlayer==2)
findViewById(R.id
.imageView2).setBackgroundResource(R.drawable.empatou);
else
findViewById(R.id
.imageView2).setBackgroundResource(R.drawable.venceu);
}
else if(jogadaPC==3) {
findViewById(R.id
.imageView3).setBackgroundResource(R.drawable.tesoura);
if(jogadaPlayer==1)
findViewById(R.id
.imageView2).setBackgroundResource(R.drawable.venceu);
else if(jogadaPlayer==2)
findViewById(R.id
.imageView2).setBackgroundResource(R.drawable.perdeu);
else
findViewById(R.id
.imageView2).setBackgroundResource(R.drawable.empatou);
}
}
@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.
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: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:id="@+id/button2"
android:layout_width="100dp"
android:layout_height="100dp"
android:layout_above="@+id/textView2"
android:layout_centerHorizontal="true"
android:background="@drawable/papel" />
<Button
android:id="@+id/button3"
android:layout_width="100dp"
android:layout_height="100dp"
android:layout_above="@+id/textView2"
android:layout_toRightOf="@+id/button2"
android:background="@drawable/tesoura" />
<TextView
android:id="@+id/textView2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:text="@string/ultimaJogada"
android:textSize="30sp" />
<TextView
android:id="@+id/textView3"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/textView2"
android:layout_toLeftOf="@+id/imageView2"
android:text="@string/jogadaPlayer" />
<TextView
android:id="@+id/textView4"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/textView2"
android:layout_centerHorizontal="true"
android:text="@string/resultado" />
<TextView
android:id="@+id/textView5"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/textView2"
android:layout_toRightOf="@+id/imageView2"
android:text="@string/jogadaPC" />
< ImageView
android:id="@+id/imageView1"
android:layout_width="100dp"
android:layout_height="100dp"
android:layout_below="@+id/textView4"
android:layout_toLeftOf="@+id/imageView2" />
< ImageView
android:id="@+id/imageView2"
android:layout_width="100dp"
android:layout_height="100dp"
android:layout_below="@+id/textView4"
android:layout_centerHorizontal="true" />
< ImageView
android:id="@+id/imageView3"
android:layout_width="100dp"
android:layout_height="100dp"
android:layout_below="@+id/textView4"
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() {
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() {
public void onClick(View v) {
findViewById(R.id.imageView1).setBackgroundResource(R.drawable.papel);
realizaJogadaPC(2);
}
});
Button tesoura = (Button)findViewById(R.id.button3);
tesoura.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
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.imageView2).setBackgroundResource(R.drawable.perdeu)
;
else if(jogadaPlayer==2)
findViewById(R.id.imageView2).setBackgroundResource(R.drawable.empatou
);
else
findViewById(R.id.imageView2).setBackgroundResource(R.drawable.venceu)
;
}
else if(jogadaPC==3) {
findViewById(R.id.imageView3).setBackgroundResource(R.drawable.tesoura
);
if(jogadaPlayer==1)
findViewById(R.id.imageView2).setBackgroundResource(R.drawable.venceu)
;
else if(jogadaPlayer==2)
findViewById(R.id.imageView2).setBackgroundResource(R.drawable.perdeu)
;
else
findViewById(R.id.imageView2).setBackgroundResource(R.drawable.empatou
);
}
}
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
.imageView2).setBackgroundResource(R.drawable.venceu);
adicione, logo abaixo, as linhas:
MediaPlayer m = MediaPlayer.create(this,R.raw.win);
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
.imageView2).setBackgroundResource(R.drawable.venceu);
MediaPlayer m = MediaPlayer.create(this,R.raw.win);
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
.imageView2).setBackgroundResource(R.drawable.perdeu);
Atente-se ao fato de que essas linhas também precisam estar dentro de um mesmo bloco
limitado por chaves, ficando:
{
findViewById(R.id
.imageView2).setBackgroundResource(R.drawable.perdeu);
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.