Post on 13-Jul-2016
Luciano Alves da Silva
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
2
Luciano Alves da Silva
3
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
4
Desenvolvendo Jogos 2D com Plataforma
Guia para Desenvolvedores
[VERSÃO DE AMOSTRA]
Autor: Luciano Alves da Silva
Rio de Janeiro – Outubro/2014
Copyright © 2014 – Todos os direitos reservados
Luciano Alves da Silva
5
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
6
Aviso importante
Esta obra É UMA VERSÃO DE AMOSTRA, ou seja, UMA
VERSÃO LIMITADA E LIVRE da versão COMPLETA.
Essa obra , PODERÁ SER DISTRIBUÍDA LIVREMENTE ,
MEDIANTE AS SEGUINTES REGRAS ABAIXO:
Esse material NÃO PODERÁ SER COMERCIALIZADO
Essa material NÃO PODERÁ SER DEVIRADO
E todos os créditos do autor DEVERÃO SER MANTIDOS
Download dos arquivos
Para realizar o download dos arquivos e imagens utilizados
nesta obra, clique no link abaixo:
Link dos materiais
http://goo.gl/uuSD60
Luciano Alves da Silva
7
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
8
Sobre o autor da obra
Luciano Alves da Silva (lucianopascal@yahoo.com.br) é
Bacharelado em Ciência da Computação pela UNISUAM e
Pós-Graduado em Docência do Ensino Superior pelo
Instituto A Vez do Mestre (Universidade Cândido Mendes -
UCAM). Possui conhecimento e domínio das linguagens de
programação Pascal, Java, C/C++, C#, Visual Basic, Delphi,
PHP e HTML. Já criou Ambientes de Desenvolvimento
Integrado (conhecidos como IDE) como o MakeWare (que
trabalha com as linguagens Pascal, C++ e Java) e o AlgoWare
(interpretador de algoritmos).
É autor também dos seguintes livros, pela editora AGBOOK
Aprenda Passo a Passo a Programar em Android –
Guia Essencial para Desenvolvedores
Desenvolvendo Jogos com a Plataforma XNA – Guia
para Desenvolvedores (2ª Edição)
Desenvolvendo Jogos com a Ferramenta RPG Maker
VX– Guia do Usuário
Desenvolvendo Jogos com o Framework MONOGAME
– Guia para Desenvolvedores
Luciano Alves da Silva
9
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
10
Luciano Alves da Silva
11
Apresentação
O mercado de desenvolvimento de jogos tem crescido
bastante nesses últimos tempos. Hoje encontramos jogos
para as mais diversas plataformas (como PC, Web e Mobile).
Atualmente o mercado de desenvolvimento de jogos para
PC tem ganhado bastante destaque, e hoje temos várias
ferramentas (como frameworks) voltados para a criação de
jogos destinados à plataforma PC, e uma dessas
ferramentas e o framework GameUtil2D (que eu mesmo
desenvolvi), que nada mais é do que um conjunto de classes
e recursos destinadas à criação de jogos ,voltado para as
mais diversas plataformas. E uma dessas plataformas é o
Java.
Neste livro você aprenderá nossos básicas de como criar
jogos utilizando o framework GameUtil2D com linguagem
Java (usando a ferramenta Eclipse Luna) , através dos seus
recursos disponíveis e também através dos exemplos
mostrados aqui nesta obra.
Para uma abordagem MAIS COMPLETA, adquira a VERSÃO
COMPLETA do livro no site da editora AGBOOK
(http://www.agbook.com.br).
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
12
Luciano Alves da Silva
13
Índice analítico
Capitulo 1 Fundamentos básicos sobre jogos ................ 15
1.1) O que é um jogo de computador ? ............................ 15
1.2) Regras para a criação de um jogo de computador . 16
1.3) Sobre a ferramenta de desenvolvimento ................ 18
1.4) Sobre a linguagem de programação Java ................. 18
Capitulo 2 Instalando as ferramentas de
desenvolvimento ................................................................ 19
2.1) A plataforma Java ....................................................... 19
2.2) A ferramenta Eclipse Luna ......................................... 24
2.3) A biblioteca GameUtil2D ........................................... 31
Capitulo 3 Criando nosso primeiro projeto .................... 32
O diretório “src” (source) ................................................... 39
O diretório “drawables” ..................................................... 46
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
14
O diretório “sounds” .......................................................... 47
Executando o jogo .............................................................. 49
Capitulo 4 Visualizando imagens no jogo ....................... 52
4.1) Criando nosso projeto ................................................ 52
Capitulo 5 Movendo elementos do jogo pela tela ......... 62
Capitulo 6 Trabalhando com animação de sprites........ 75
Capitulo 7 Detectando colisões entre objetos no jogo . 85
Considerações Finais.......................................................... 91
Luciano Alves da Silva
15
Capitulo 1 Fundamentos
básicos sobre jogos
ntes de começarmos a estudar e utilizar a
ferramenta Eclipse com a biblioteca GameUtil2D,
vamos entender melhor os fundamentos sobre jogos
de computador.
1.1) O que é um jogo de computador ?
Um jogo de computador (assim como um software que
utilizamos no dia a dia), é um programa voltado e destinado
somente ao entretenimento e diversão.
Praticamente, por parte de muitos usuários, os jogos fazem
parte do cotidiano (mesmo para aqueles que não são
desenvolvedores). Quem nunca se divertiu (em seu
momento de intervalo) com algum jogo de computador, por
mais simples que seja (como um jogo de campo minado, um
jogo de cartas, um jogo de plataforma como Mario Bros e
etc.).
A
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
16
1.2) Regras para a criação de um jogo de computador
Para desenvolvermos um jogo, naturalmente, precisamos
ter algumas coisas em mente : seu inicio, meio e fim
(história do jogo de modo geral, não importando seu
gênero) ; as ferramentas que vamos utilizar para
desenvolver os jogos e programadores/artistas que estarão
envolvidos no projeto do jogo.
Vejamos abaixo algumas imagens de alguns títulos de jogos
bastante conhecidos :
Jetpack joyride
Luciano Alves da Silva
17
Swing Copters
Angry Birds Rio
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
18
1.3) Sobre a ferramenta de desenvolvimento
Conforme foi abordado no tópico 1.2 deste capítulo, um dos
critérios para a construção de jogos é a ferramenta de
desenvolvimento escolhida, que neste caso, será a
ferramenta Eclipse Luna.
O Eclipse é uma das mais famosas ferramentas para o
desenvolvimento de aplicativos para a plataforma Java
(como também para outras linguagens como C/C++ e PHP
por exemplo).
1.4) Sobre a linguagem de programação Java
A linguagem de programação Java é a linguagem que iremos
utilizar para o desenvolvimento de jogos no GameUtil2D
(juntamente com o Eclipse Luna). Caso você , que esteja
lendo este livro, não tenha nenhum conhecimento de
linguagem de programação e/ou algoritmos, recomendo
fortemente o estudo sobre o assunto.
Luciano Alves da Silva
19
Capitulo 2 Instalando as
ferramentas de
desenvolvimento
este capítulo iremos aprender passo a passo a
instalar a ferramenta de desenvolvimento Eclipse
Luna e o framework (biblioteca) GameUtil2D.
2.1) A plataforma Java
Neste tópico iremos realizar o download da máquina virtual
Java, para que possamos executar os nosso jogos
desenvolvidos no Eclipse Luna.
Minha máquina virtual java está instalada ?
Bom, para você saber se você possui uma máquina virtual
Java instalada, abra o prompt de comando e digite o
seguinte comando:
java –version
N
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
20
Verifique se o resultado foi “similar” ao que é mostrado
abaixo:
Máquina virtual java instalada
Se observarmos as informações mostradas no console
acima, certifique se a versão é 1.7.x.x está instalada em sua
máquina, conforme é destacado abaixo:
Luciano Alves da Silva
21
A versão do Java que utilizo para o desenvolvimento do livro
é 1.7 (Java 7). Se a versão que se encontra instalada em sua
máquina é inferior ao utilizado no livro (como 1.6 ou 1.5),
recomendo a atualização da máquina virtual (que será
mostrado como instalar daqui a pouco).
Agora, se a versão que encontra instalada em sua máquina
for igual ou superior ao utilizado no livro, PODE PULAR ESTÁ
ETAPA e AVANCE PARA O PRÓXIMO TÓPICO.
Agora se o resultado ao digitar o comando “java –version” no
prompt do comando for igual ao da figura seguinte :
Máquina virtual Java NÃO INSTALADA
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
22
Significa que sua máquina virtual , possivelmente, não está
instalada em sua máquina.
Para realizarmos o download o Java, visite o seguinte link
abaixo:
http://www.oracle.com/technetwork/java/javase/downloads/
jdk7-downloads-1880260.html?ssSourceSiteId=otnpt
Feito isso deverá se abrir a seguinte página abaixo:
Página de download do Java 7
Luciano Alves da Silva
23
Procure pela versão mais recente do Java 7. Feito isso aceite
os termos de contrato e realize o download do arquivo de
instalação, conforme é mostrado abaixo:
Aceitando os termos de contrato e realizando o
download
Feito isso deverá ser mostrado a seguinte caixa de diálogo :
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
24
Caixa de diálogo - Download
Após realizar o download, siga todo o passo a passo da
instalação da máquina virtual Java.
2.2) A ferramenta Eclipse Luna
Conforme já foi mencionado no capítulo anterior, iremos
utilizar a ferramenta Eclipse Luna para o desenvolvimento
de jogos com o GameUtil2D.
OBSERVAÇÕES SOBRE O ECLIPSE
Neste livro utilizo a versão 4.4 do Eclipse (conhecido como
Eclipse Luna). Caso você esteja utilizando uma das versões
anteriores como Eclipse Kepler (4.3) ou Eclipse Juno (4.2),
não tem problema. Será possível também a utilização do
framework GameUtil2D com uma dessas versões.
Luciano Alves da Silva
25
Com a máquina virtual Java instalada em seu computador,
vamos realizar o download da ferramenta Eclipse Luna, no
seguinte link abaixo.
https://www.eclipse.org/downloads/
Feito isso, irá se abrir a seguinte página abaixo:
Página de download do Eclipse aberto
Iremos realizar o download do “Eclipse IDE for Java
Developers”, bastanto escolher uma das opções do
Windows ao lado (estarei utilizando aqui a versão de 32 bits
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
26
do Windows. Se por acaso você realizou o download do Java
de 64 bits, baixe a versão do Eclipse de 64 bits).
Feito isso irá se abrir a seguinte página abaixo:
Realizando o download do Eclipse Luna
Agora basta clicar na opção de download informado na
página. Feito isso, irá se abrir a seguinte caixa de diálogo:
Luciano Alves da Silva
27
Caixa de diálogo - Download
Efetue o seu download e em seguida, descompacte o
arquivo de instalação em um local apropriado (de
preferência, no drive “C:\”).
Após descompactar o arquivo, vamos executar o Eclipse,
conforme podemos ver na figura seguinte:
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
28
Tela de abertura do Eclipse Luna
Em seguida irá se abrir a seguinte caixa de diálogo:
Caixa de diálogo – Workspace Launcher
Luciano Alves da Silva
29
O que é o Workpace ?
O Workspace nada mais é do que um diretório que
escolhemos para administrar todos os nossos projetos que
iremos desenvolver no Eclipse.
Escolha o seu diretório de preferência e em seguida, clique
em “OK”. Feito isso irá se abrir (depois das configurações
que ocorrerá durante a escolha do diretório) a seguinte tela
abaixo:
Ambiente de programação Eclipse Luna
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
30
Agora vamos fechar a guia “Welcome” para encerrarmos a
tela de apresentação . Feito isso veremos a seguinte tela
abaixo:
Ambiente de programação Eclipse Luna
Luciano Alves da Silva
31
2.3) A biblioteca GameUtil2D
Nesta obra , irei utilizar para o desenvolvimento de nossos
jogos uma biblioteca (dentro dos nossos projetos no Eclipse
Luna) que eu mesmo desenvolvi chamado GameUtil2D.
Para que serve esta biblioteca ?
Essa biblioteca nada mais é do que um conjunto de classes
que facilitam a construção de jogos no JAVA. Ela já possui
uma série de recursos que facilitam a construção de jogos
de forma fácil e rápida (inclui classes para animação de
sprites, colisões, criação de personagens para jogos
plataforma e etc.) . Esse framework (que já acompanha este
material) pode ser encontrado em seu site oficial :
www.gameutil2d.org
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
32
Capitulo 3 Criando nosso
primeiro projeto
este capítulo iremos criar o nosso primeiro projeto
de jogo através do Eclipse Luna , usando a
biblioteca GameUtil2D.
Depois de tudo instalado, vamos executar o Eclipse Luna
(caso não esteja aberto). Em seguida, vamos importar o
nosso projeto do GameUtil2D para dentro do Eclipse, indo
no menu “File” e em seguida “Import”. Feito isso será aberta
a seguinte caixa de diálogo abaixo:
N
Luciano Alves da Silva
33
Caixa de diálogo – Import
Para importarmos um projeto já existente, expanda o
diretório “General” e em seguida selecione “Existing Projects
into Workspace”. Veja na figura seguinte :
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
34
Selecionando a opção
Feito isso clique no botão “Next”, que será aberta a seguinte
tela :
Luciano Alves da Silva
35
Caixa de diálogo – Import
Agora vamos clicar na opção “Select archive file” e em
seguida, clique no botão “Browse”, para selecionarmos a
nossa biblioteca, que acompanha este material (o arquivo
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
36
“GameUtil2D_Java1.x.zip”, que se encontra dentro da pasta
“GameUtil2D”). Feito isso, irá ser exibida a seguinte tela
abaixo:
Arquivo selecionado
Luciano Alves da Silva
37
Feito isso vamos clicar em “Finish” para adicionarmos a
nossa biblioteca (projeto) dentro do Eclipse. O resultado
você confere em seguida:
Biblioteca adicionada ao projeto
Conhecendo a estrutura geral do projeto em GameUtil2D
Conforme havia falado, iremos utilizar o “GameUtil2D” (que
foi o arquivo que acabamos de importar) para o
desenvolvimento de nossos jogos. Vamos conhecer abaixo
toda a estrutura (de arquivos e pastas) que compõem este
projeto.
Se visualizarmos o lado esquerdo, existe uma seção
chamada “Package Explorer”, onde nela existe uma pasta
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
38
chamada “GameUtil2D_Java1.x” (que é o nosso projeto),
constituído por vários subdiretórios , que por sua vez,
possui seus respectivos arquivos. Se expandirmos a pasta
do projeto veremos uma estrutura de diretórios e pacotes,
conforme demonstra a figura seguinte:
Estrutura de diretórios
Luciano Alves da Silva
39
Irei comentar agora toda a estrutura de um projeto do
GameUtil2D. Ele é composto por várias pastas e arquivos,
cada um com uma finalidade em especifico.
O diretório “src” (source)
Vamos começar conhecendo primeiramente o diretório “src”
(source). Dentro desse diretório temos todos os arquivos de
extensão “.java” que fazem parte de uma aplicação Java. Se
nós expandirmos essa pasta encontraremos uma série de
arquivos, todos eles organizações em seus respectivos
“pacotes”.
Irei descrever agora os pacotes dentro do nosso projeto, são
eles :
O pacote “gameutil2d.project”
Esse pacote é constituído por um arquivo principal, que será
a classe que iremos trabalhar daqui por diante:
GameMain.java : Esse é o arquivo principal do projeto,
é nele que entramos com o código do jogo.
Conforme vimos acima, o arquivo no qual iremos mexer
para escrever nossos jogos é o arquivo “GameMain.java”. Se
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
40
clicarmos duas vezes no arquivo, veremos o seguinte
conteúdo:
package gameutil2d.project; import gameutil2d.classes.input.*; import gameutil2d.classes.basic.*; import gameutil2d.classes.scene.*; import gameutil2d.classes.text.*; import gameutil2d.classes.character.*; import gameutil2d.classes.media.*; import java.awt.Graphics; public class GameMain { public GameMain() { } public void Update(KeyboardState keyboardState, MouseState mouseState) { } public void Draw(Graphics graphics) { } }
Luciano Alves da Silva
41
O código acima é a estrutura padrão da classe GameMain
(arquivo “GameMain.java”) no qual iremos escrever o código
para o desenvolvimento do nosso jogo. Essa classe é
constituída pelos seguintes métodos:
GameMain: Esse é o método construtor, executado toda
vez que o jogo é carregado. São neles que carregamos todos
os objetos e iniciamos as variáveis que serão utilizadas no
jogo. Veja sua sintaxe:
public GameMain()
Update: Esse método é processado sempre durante a
execução do jogo, e também é o primeiro a ser executado.
Ele é responsável por executar a “lógica” de processamento
do jogo (movimento, ações e etc.). Vejamos a sua sintaxe:
public void Update(KeyboardState keyboardState,
MouseState mouseState)
Nesse método Update existem dois parâmetros : um
responsável pelo armazenamento do status do teclado e
outro responsável pelo armazenamento do status do
mouse.
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
42
Draw: Esse método é processado sempre com a execução
do jogo, e executado “alternadamente” com o método
Update. Ele é responsável por desenhar a tela do jogo.
Vejas a sua sintaxe:
protected void Draw(Graphics graphics)
Esse método possui um parâmetro chamado “graphics”, que
representa a tela do jogo, no qual vamos utilizar para
desenhar os elementos na tela.
O pacote “gameutil2d.classes.basic”
Nesse pacote estão contidos as classes básicas que iremos
utilizar para a construção dos nossos jogos. Vejamos abaixo
quais são essas classes e a finalidade de cada uma (que será
demonstrada nos capítulos posteriores) :
Image.java : Esse arquivo (ou classe) é utilizado
quando queremos exibir uma imagem na tela em um
jogo.
Luciano Alves da Silva
43
AnimationSprites.java: Esse arquivo (ou classe) é
utilizado para realizar animações de sprites em um
jogo.
Collision.java : Esse arquivo (ou classe) é utilizado
para “detectar” colisões entre dois elementos em um
jogo.
FlipEffect.java : Classe utilizada para “inverter” uma
imagem (ou um conjunto de imagens de uma
animação de sprites) na “horizontal”.
GameElement.java: Essa é a base utilizada para a
construção da maioria das classes citadas acima (e de
algumas outras classes que serão citadas em seguida),
e de bastante utilidade para a construção de outros
elementos do jogo por parte do usuário.
Box.java : Classe utilizada somente para definir
“pontos de colisão”, bastante útil para a construção de
jogos baseados em plataforma (muito utilizada em
conjunto com as classe Character e Scene).
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
44
O pacote “gameutil2d.classes.character”
Nesse pacote existe somente uma classe, destinada para a
criação de personagens (para jogos no estilo plataforma).
Character.java : Esse arquivo (ou classe) é utilizado
para a construção de personagens, que iremos utilizar
em um jogo.
O pacote “gameutil2d.classes.scene”
Nesse pacote existe somente uma classe, destinada para a
criação de cenários do jogo.
Scene.java : Esse arquivo (ou classe) é utilizado para
representar uma “cena” do jogo, e quais elementos
estarão presentes nele.
O pacote “gameutil2d.classes.text”
Nesse pacote existe somente uma classe, destinada para a
exibição de informações na tela do jogo.
Luciano Alves da Silva
45
TextDrawable.java : Esse arquivo (ou classe) é
utilizado para exibir informações na tela do jogo
(mensagens, textos etc.).
O pacote “gameutil2d.classes.input”
Nesse pacote encontramos as classes responsáveis pela
entrada de dados, são elas :
KeyboardState.java : Esse arquivo (ou classe) é
utilizado para guardar o status do teclado, ou seja,
quais teclas foram pressionadas e/ou liberadas.
MouseState.java : Esse arquivo (ou classe) é utilizado
para guardar o status do mouse, ou seja, qual posição
onde ele se encontra na tela (cursor), se o botão foi
pressionado e/ou liberado e etc.
Keys.java : Esse arquivo (ou classe) guarda todas as
constantes das teclas pressionadas e/ou liberadas, e é
utilizado como parâmetro nos métodos IsKeyDown e
IsKeyUp da classe KeyboardState.
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
46
O pacote “gameutil2d.classes.media”
Nesse pacote existe algumas classes destinadas ao
tratamento de áudio , são elas :
Song.java : Esse arquivo (ou classe) é utilizado para
guardar e armazenar uma música (em “mp3”) que
será reproduzida no jogo (pela classe MediaPlayer).
MediaPlayer.java : Essse arquivo (ou classe) é
responsável por reproduzir as músicas do jogo
(armazenadas dentro da classe Song)
SoundEffect.java : Esse arquivo (ou classe) é
utilizado para armazenar e reproduzir um som de
efeito (em “wav”) no jogo.
O diretório “drawables”
Dentro da estrutura do projeto GameUtil2D existe um
diretório chamado “drawables”, onde dentro dele colocamos
todas as imagens que iremos utilizar no jogo (no momento
somente imagens do tipo “png” e “jpeg”).
Luciano Alves da Silva
47
O diretório “sounds”
Dentro da estrutura do projeto GameUtil2D existe um
diretório chamado “sounds”, onde dentro dele colocamos
todos os arquivos de áudio (de extensão “.mp3” e “.wav”)
que utilizaremos no jogo.
Definindo o nome do projeto
Como você percebeu, o nome do nosso projeto no Eclipse
Luna se chama “GameUtil2D_Java1.x”, mas, se eu quiser um
outro nome para esse projeto (como por exemplo “Meu
Primeiro Jogo”), visto que todos os nossos projetos que
iremos criar será a partir deste modelo ? Para darmos um
novo nome para o projeto, basta selecioná-lo e em seguida
pressionar a tecla “F2”, para renomear o projeto com um
novo nome, conforme você pode conferir na figura seguinte:
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
48
Caixa de diálogo – Rename Java Project
Depois de escrever o novo nome do projeto basta clicar em
“OK” para que o projeto seja renomeado. Confira o
resultado na figura seguinte:
Projeto renomeado
Luciano Alves da Silva
49
Executando o jogo
Para executarmos o nosso jogo feito no Java, basta
clicarmos no botão localizado na barra de ferramentas.
Veja na figura seguinte :
Botão “Run As”
Feito isso será aberta a seguinte caixa de diálogo:
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
50
Caixa de diálogo – Run As
Selecione agora a opção “Java Application” e em seguida,
clique em “OK”. Vejamos o resultado na figura seguinte :
Luciano Alves da Silva
51
Aplicação em execução
A tela escura indica que não há nada na tela, que nenhum
elemento está presente no jogo.
Neste capítulo conhecemos nosso framework de
desenvolvimento, que iremos utilizar para a construção dos
nossos jogos (o GameUtil2D). Nos próximos capítulos vamos
conhecer todas as classes que compõem esta framework e
como criar vários exemplos de jogos (e também jogos)
através dela.
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
52
Capitulo 4 Visualizando
imagens no jogo
o capítulo anterior aprendemos a criar e a executar
um projeto (vazio) do GameUtil2D no Java. Agora
vamos começar a colocar a MÃO NA MASSA. Nesse
capítulo iremos aprender como visualizar uma imagem na
tela (já utilizando a biblioteca GameUtil2D).
4.1) Criando nosso projeto
Conforme já foi mostrado, vamos importar o arquivo
“GameUtil2D_Java1.x.zip” para dentro do Eclipse Luna, para
criarmos um novo projeto. Feito isso, renomeie o projeto
com o nome de “Visualizando Imagens”.
Depois disso abra a pasta “Capitulo 4” (que acompanha este
material) e em seguida copie (CTRL + C) todas as imagens
presentes deste diretório para dentro do pasta “drawables”
do nosso projeto (CTRL + V). Vejamos o resultado :
N
Luciano Alves da Silva
53
Imagens copiadas para dentro do projeto
Para visualizarmos uma imagem no jogo, precisamos fazer
uso da classe Image , responsável por essa finalidade. Para
isso, dentro da classe GameMain vamos declarar um
atributo do tipo Image.
Na classe GameMain, na seção de declaração de atributos,
vamos declarar um atributo chamado imagem , conforme
podemos conferir em seguida:
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
54
Image imagem;
Agora dentro do construtor da classe (o método
GameMain), vamos carregar o nosso atributo (objeto), com
os seguintes parâmetros conforme você confere no código
abaixo:
public GameMain() { imagem = new Image("personagem_swing_copters", 0, 0, 80, 80); }
Vamos analisar os parâmetros do comando inserido acima.
O construtor da classe Image possui os seguintes
parâmetros :
imagem = new Image("personagem_swing_copters", 0, 0, 80, 80);
O primeiro parâmetro do construtor corresponde a imagem
que vamos visualizar no jogo (que é a imagem
“personagem_swing_copters.png”). Observe que quando
informamos o nome da imagem NÃO INFORMAMOS A SUA
EXTENSÃO (e também NÃO É PRECISO), pois o GameUtil2D
já reconhece a imagem presente dentro do projeto.
Luciano Alves da Silva
55
O segundo e terceiro parâmetro do construtor
correspondem , respectivamente, as coordenadas X e Y do
objeto na tela do jogo (cujos valores são “0” e “0”). Já o
quarto e o quinto parâmetro correspondem,
respectivamente, a largura e a altura do objeto (cujo valores
são “80” e “80”).
Bom, o que fizemos até agora foi carregar o objeto (imagem)
na memória. Agora precisamos desenhar a imagem
carregada na tela. Para isso devemos utilizar o método
Draw, responsável por essa finalidade. Dentro do método
Draw vamos escrever o seguinte código destacado em
seguida:
public void Draw(Graphics graphics) { imagem.Draw(graphics); }
O método Draw do objeto imagem é responsável por
visualizar a imagem na tela , passando como argumento
para o método um objeto do tipo Graphics (que nesse caso,
é a variável graphics).
Agora compile e execute novamente o projeto e confira o
resultado, conforme demonstra a figura seguinte:
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
56
Imagem sendo visualizada no jogo
E ai, aprendeu como visualizar uma imagem na tela do
jogo ? Com certeza que sim!
Vamos aproveitar esse mesmo projeto para demonstrar
mais um exemplo de visualização de imagens.
Vamos voltar para o código de declaração de atributos para
digitarmos o seguinte trecho de código destacado em
seguida em negrito:
Luciano Alves da Silva
57
public class GameMain {
Image imagem; Image titulo_swing_copters; Image fundo_tela_swing_copters; :
Agora dentro do método GameMain VAMOS SUBSTITUIR o
código em negrito abaixo :
public GameMain() { imagem = new Image("personagem_swing_copters", 0, 0, 80, 80); }
Pelo seguinte código em negrito:
public GameMain() { titulo_swing_copters = new Image("titulo_swing_copters", (800 / 2) - (372/2), 30 , 372, 223); fundo_tela_swing_copters = new Image("fundo_tela_swing_copters", 0, 0, 800, 480); imagem = new Image("personagem_swing_copters", 400 - 50, 320, 100, 100); }
Agora dentro do método Draw vamos digitar o seguinte
código, conforme é mostrado em seguida:
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
58
public void Draw(Graphics graphics) { fundo_tela_swing_copters.Draw(graphics); titulo_swing_copters.Draw(graphics); imagem.Draw(graphics); }
Dentro do método Draw existem três instruções onde cada
uma irá exibir uma imagem na tela. As instruções que
inserimos no código, possuem uma sequência, que
precisarei explicar.
Observe que a primeira instrução adicionada no método
Draw foi:
fundo_tela_swing_copters.Draw(graphics);
Que irá exibir uma imagem de fundo, que é a fase do
famoso jogo “Swing Copters”.
Em seguida, temos a seguinte instrução:
titulo_swing_copters.Draw(graphics);
Luciano Alves da Silva
59
Que irá exibir o título “Swing Copters” na tela. Como essa é a
segunda imagem a ser exibida, a mesma é exibida a frente
da imagem de fundo.
Na terceira instrução temos a seguinte linha de código:
imagem.Draw(graphics);
Que irá desenhar o “personagem” do jogo na tela. Como
essa é a terceira imagem a ser exibida na tela, a mesma é
mostrada a frente da imagem de fundo e do título.
Executando o nosso código, teremos o seguinte resultado :
Resultado do código na tela
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
60
Invertendo uma imagem na tela
A classe Image possui um método chamado Draw que
serve para exibirmos uma imagem na tela. Pois bem, o
mesmo método possui um segundo parâmetro que nos
permite “inverter” a imagem exibida na horizontal.
Para realizarmos essa demonstração de inversão de
imagem vamos alterar dentro do método Draw, conforme
mostra instrução destacada em negrito em seguida:
public void Draw(Graphics graphics) { fundo_tela_swing_copters.Draw(graphics); titulo_swing_copters.Draw(graphics); imagem.Draw(graphics,FlipEffect.HORIZONTAL); }
Observe que no objeto imagem (que mostra o personagem
na tela), adicionamos o segundo argumento no método
Draw, o argumento “FlipEffect.HORIZONTAL” (que indica
que a imagem será invertida na horizontal). Vejamos o
resultado :
Luciano Alves da Silva
61
Imagem invertida na horizontal
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
62
Capitulo 5 Movendo
elementos do jogo pela tela
o capítulo anterior aprendemos como visualizar
elementos (como imagens) na tela, porém, as
imagens vistas ficam num ponto “fixo” da dela,
definido pelo código. Agora vamos aprender a movimentar
esses elementos pela tela do jogo usando os recursos
oferecidos pela biblioteca “GameUtil2D” no Java.
Primeiramente vamos criar um novo projeto no Eclipse Luna
(usando o arquivo “GameUtil2D_Java1.x.zip”). O nome do
nosso projeto irá se chamar “Movendo Objetos pela Tela”.
Depois de criado o projeto copie todas as imagens
presentes dentro da pasta “Capitulo 5” (que já acompanha
este material) para dentro do nosso projeto, para a pasta
“drawables” .
Dentro da seção de declaração de atributos da classe vamos
digitar as seguintes instruções em negrito abaixo :
N
Luciano Alves da Silva
63
Image aviao, nuvem, ceu_azul;
Agora dentro do método GameMain vamos digitar o
seguinte bloco de comandos destacados em negrito a
seguir :
public GameMain() { aviao = new Image("aviao", 0, 0, 90, 70); nuvem = new Image("nuvem", 250, 100, 90,70); ceu_azul = new Image( "ceu_azul", 0, 0, 800, 480); }
Agora vamos no método Draw para adicionarmos as
seguintes linhas de comando:
public void Draw(Graphics graphics) { ceu_azul.Draw(graphics); nuvem.Draw(graphics); aviao.Draw(graphics); }
Nas linhas de comando que adicionarmos acima, todas
elas, desenham as imagens na tela do jogo. Agora, as
linhas de comando acima foram adicionadas na seguinte
sequencia:
A primeira linha de comando que adicionamos, desenha
a imagem do céu azul na tela, até ai tudo bem. Na linha
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
64
seguinte desenhamos a nuvem na tela, essa nuvem será
desenhada “na frente” da imagem do céu azul. Por último,
desenhamos a imagem do avião, e esse avião será
desenhado na frente da imagem da nuvem e do céu azul
(conforme já foi explicado no capítulo anterior).
Depois de escrever o código , vamos executar nossa
aplicação e conferir os resultados:
Jogo em execução na tela
Por enquanto só conseguimos visualizar o nosso avião,
mas, não podemos movimentá-lo pela tela ainda.
Luciano Alves da Silva
65
Como havia falado, iremos movimentar os objetos via
teclado (neste caso aqui, o avião).
Para isso dentro do método Update vamos digitar o
seguinte bloco de comandos destacado em negrito abaixo:
public void Update(KeyboardState keyboardState, MouseState mouseState) { if (keyboardState.IsKeyDown(Keys.RIGHT)) aviao.MoveByX(5); else if (keyboardState.IsKeyDown(Keys.LEFT)) aviao.MoveByX(-5); else if (keyboardState.IsKeyDown(Keys.UP)) aviao.MoveByY(-5); else if (keyboardState.IsKeyDown(Keys.DOWN)) aviao.MoveByY(5); }
Vamos analisar os comandos digitados em negrito. Na
instrução :
if (keyboardState.IsKeyDown(Keys.Right)) aviao.MoveByX(5);
Verifico se a tecla de direção para direita (representada por
“Keys.RIGHT”) está pressionada, através do método
IsKeyDown (do objeto keyboardState). Caso verdadeiro, é
executado o método MoveByX que é responsável por
deslocar o nosso avião. Observe que o valor que passamos
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
66
como parâmetro para o método foi 5, ou seja, nosso avião
irá andar 5 pixels para a direita partindo da posição atual
que ele se encontra.
A explicação acima é similar para as demais condições
seguintes.
Vamos executar a aplicação para conferir os resultados,
conforme mostra a figura seguinte :
Movendo nosso avião pela tela
Se observarmos o jogo, nós conseguimos mover o avião
pela tela, porém, a nuvem que adicionamos no jogo está
Luciano Alves da Silva
67
imóvel. O ideal seria que essa nuvem se movimentasse,
dando a sensação de que o avião está voando (em
movimento).
Para colocarmos a nuvem em movimento, precisaremos
adicionar mais algumas instruções. Para começar vamos
declarar um atributo, conforme você pode conferir em
seguida (na seção de declaração de atributos) :
int largura_tela = 800;
Agora dentro do método Update vamos adicionar o
seguinte comando destacado em negrito, como segue:
public void Update(KeyboardState keyboardState, MouseState mouseState) { : else if (keyboardState.IsKeyDown(Keys.DOWN)) aviao.MoveByY(5); nuvem.MoveByX(-15); if (nuvem.GetX() < -nuvem.GetWidth()) nuvem.SetX(largura_tela); }
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
68
Irei explicar cada linha de comando das instruções
adicionadas acima. A linha:
nuvem.MoveByX(-15);
Desloca a nuvem para a esquerda, de 15 em 15 pixels
(lembre-se : valor positivo significa deslocamento pra direita,
e valor negativo deslocamento para esquerda).
A próxima instrução :
if(nuvem.GetX() < -nuvem.GetWidth())
Verifica se a nuvem saiu for a da tela. Como interpretamos a
avaliação feita pela condição acima ? Irei explicar para você.
O método GetX (do objeto nuvem, do tipo Image) retorna a
posição da coordenada X do objeto na tela, e o método
GetWidth retorna a largura do objeto. Quando a posição X
de qualquer objeto for menor que o valor negativo de sua
largura, significa que o objeto não está visível na tela, ou
seja, está fora dela (fora pelo lado esquerdo da tela).
Quando isso acontece, é executada a seguinte instrução:
nuvem.SetX(largura_tela);
Que reposiciona a nuvem para surgir a partir da direita
da tela, dando a sensação que o avião está realmente
voando. Execute novamente a aplicação e confira o
resultado:
Luciano Alves da Silva
69
Nuvem em movimento
Se observarmos o nosso jogo, o avião pode se deslocar
perfeitamente pela tela, porém, se deixarmos o avião se
mover constante (e unicamente) para uma direção, o
mesmo sai da tela (independente se é para frente, pra trás,
pra cima ou para baixo). Como solucionar esse problema ? É
simples, basta limitarmos seu movimento de forma que o
mesmo não saia da tela.
Para realizarmos esse procedimento, primeiramente, vamos
declarar o seguinte atributo em seguida (destacado em
negrito):
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
70
: int largura_tela = 800; int altura_tela = 480;
Agora vamos dentro do método Update para digitarmos as
seguintes linhas de código destacadas em negrito abaixo:
public void Update(KeyboardState keyboardState, MouseState mouseState) { if (keyboardState.IsKeyDown(Keys.RIGHT)) { aviao.MoveByX(5); if ((aviao.GetX() + aviao.GetWidth()) > largura_tela) aviao.SetX(largura_tela - aviao.GetWidth()); } else if (keyboardState.IsKeyDown(Keys.LEFT)) { aviao.MoveByX(-5); if (aviao.GetX() < 0) aviao.SetX(0); } else if (keyboardState.IsKeyDown(Keys.UP)) { aviao.MoveByY(-5); if (aviao.GetY() < 0) aviao.SetY(0); }
Luciano Alves da Silva
71
else if (keyboardState.IsKeyDown(Keys.DOWN)) { aviao.MoveByY(5); if ((aviao.GetY() + aviao.GetHeight()) > altura_tela) aviao.SetY(altura_tela - aviao.GetHeight()); } nuvem.MoveByX(-15); if (nuvem.GetX() < -nuvem.GetWidth()) nuvem.SetX(largura_tela); }
Irei explicar agora a finalidade de cada instrução adicionada
no código. A instrução:
if((aviao.GetX() + aviao.GetWidth()) > largura_tela)
Avalia se o avião está começando a sair da tela indo para
frente (se a posição atual do avião na coordenada X somado
com a largura do mesmo for maior que a largura da tela.
Isso é uma regra padrão). Caso a condição seja verdadeira, é
executada seguinte instrução:
aviao.SetX(largura_tela - aviao.GetWidth());
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
72
Que impede que o avião saia da tela, através do reajuste da
posição dele na coordenada X, que será : largura da tela –
largura do avião. Quando o avião anda para trás, é
executada a seguinte avaliação condicional:
if(aviao.GetX() < 0)
Que verifica se o avião está começando a sair da tela (se a
posição X do objeto for menor que 0). Se a condição for
verdadeira, será executada a seguinte instrução:
aviao.SetX(0);
Que reajusta a posição do avião , pela coordenada X
(definindo a coordenada X com o valor “0”).
Quando o avião anda para cima, é executada a seguinte
avaliação condicional:
if(aviao.GetY() < 0)
Que verifica se o avião está começando a sair da tela (se a
posição Y do objeto for menor que 0). Se a condição for
verdadeira, será executada a seguinte instrução:
aviao.SetY(0);
Que reajusta a posição do avião , pela coordenada Y
(definindo a coordenada Y com o valor “0”).
Luciano Alves da Silva
73
Quando o avião está se movimentando para baixo, é
executada a seguinte avaliação:
if((aviao.GetY() + aviao.GetHeight()) > altura_tela)
Que verifica se o avião está começando a sair da tela (se a
posição atual do avião na coordenada Y somado com a
altura do mesmo for maior que a altura da tela. Isso é uma
regra padrão). Caso a condição seja verdadeira, é executada
a seguinte instrução:
aviao.SetY(altura_tela - aviao.GetHeight());
Que impede que o avião saia da tela, através do reajuste da
posição dele na coordenada Y, que será a altura da tela – a
altura do avião.
Executando nossa aplicação, teremos o seguinte resultado:
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
74
Agora o avião não sai mais da tela
Luciano Alves da Silva
75
Capitulo 6 Trabalhando com
animação de sprites
os capítulos anteriores aprendemos a visualizar
imagens “estáticas” no jogo (pode ser qualquer
elemento do jogo como uma árvore, um poste, um
bloco e etc.). Agora, se eu quisesse que algum elemento do
jogo apresenta-se alguma animação ? Neste capítulo vamos
aprender como realizar essas animações usando sprites no
jogo.
Na maioria dos jogos em 2D (talvez podemos dizer todos),
alguns dos elementos apresentam algum tipo de
animação (como o movimento de um personagem ou a
ação de algum objeto). Agora a pergunta que faço é :
como são realizadas essas animações no jogo ? Essas
animações são realizadas utilizando o que nós chamamos
de sprites. O que vem a ser uma sprite ? Sprites nada
mais são do que um conjunto de imagens, onde cada
imagem representa o movimento ou ação de um
determinado elemento do jogo (como um personagem
ou um objeto do jogo qualquer).
Vamos ver abaixo um conjunto de imagens (sprites) de
um personagem, onde cada imagem representa um
movimento:
N
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
76
Sprites de um personagem de um jogo (dando soco)
Como funciona a animação de um personagem (ou objeto)
durante o jogo ? Se observarmos as imagens acima, cada
uma delas representa um movimento, e cada uma delas é
exibida numa fatia de “tempo”, dando a sensação de
movimento ou ação.
Para trabalharmos com animação de sprites no GameUtil2D
faremos uso da classe chamada AnimationSprites,
destinada somente para esse tipo de tarefa (presente
dentro do pacote “gameutil2d.classes.basic” da nossa
biblioteca).
Para começarmos vamos criar um novo projeto no Eclipse
chamado “Animacao de Sprites”. Em seguida copie todas as
imagens presentes dentro da pasta “Capitulo 6” (que
acompanha este material) para dentro da pasta ”drawables”.
Luciano Alves da Silva
77
Agora dentro da classe GameMain , na seção de declaração
de atributos, vamos digitar a seguinte instrução abaixo:
AnimationSprites naruto;
Agora dentro do método construtor GameMain vamos
digitar o seguinte bloco de comandos destacados em
negrito abaixo:
public GameMain() { naruto = new AnimationSprites(0, 0, 124, 164); naruto.Add("naruto_parado_1"); naruto.Add("naruto_parado_2"); naruto.Add("naruto_parado_3"); naruto.Add("naruto_parado_4"); naruto.Start(6, true); }
Irei explicar o código inserido no método acima. A linha de
comando:
naruto = new AnimationSprites(0, 0, 124, 164);
Carrega a instância do objeto naruto do tipo
AnimationSprites. No primeiro e segundo parâmetro,
passamos respectivamente a coordenada X e Y do objeto na
tela. Já os dois últimos parâmetros representam ,
respectivamente , a largura e a altura do objeto (124 para
largura e 164 para altura). Nas linhas de comando seguinte:
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
78
: naruto.Add(“naruto_parado_1”); naruto.Add(“naruto_parado_2”); naruto.Add(“naruto_parado_3”); naruto.Add(“naruto_parado_4”); :
Adicionamos as imagens (sprites) dentro do objeto, para
que possamos ter uma animação do personagem, através
do método Add. Em seguida, vem a seguinte instrução:
naruto.Start(6, true);
Que tem a finalidade de “iniciar” a animação, através do
método Start. Esse método possui dois parâmetros : O
primeiro parâmetro é responsável por definir, em frames, o
intervalo da troca de imagens, e o segundo definimos se a
animação vai ficar “em loop” (caso true) ou não (caso false).
Agora no método Draw vamos adicionar a seguinte
instrução destacada:
public void Draw(Graphics graphics) { naruto.Draw(graphics); }
Depois de digitar o código solicitado, execute o nosso jogo e
confira o resultado, como demonstra a figura seguinte:
Luciano Alves da Silva
79
Animação do personagem em execução
Em uma animação de sprites também podemos aplicar o
efeito de “flip” (inversão) de uma imagem, na horizontal
(como já havíamos visto com imagens estáticas). Para
invertermos uma imagem na horizontal, basta adicionar um
parâmetro no método Draw do objeto, o valor true.
Vamos voltar para o método Draw da classe GameMain
para substituirmos a linha abaixo:
naruto.Draw(graphics);
Por essa:
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
80
naruto.Draw(graphics,FlipEffect.HORIZONTAL);
Depois de realizar a alteração no código execute novamente
o jogo , conforme demonstra o resultado mostrado abaixo .
Animação invertida na horitontal
Mais um exemplo de animação de sprites
Vamos realizar agora mais uma pratica de animação de
sprites no Java usando a classe AnimationSprites (da
biblioteca GameUtil2D). Para essa pratica vamos importar
para o Eclipse um projeto já feito (que já acompanha este
material), que é o arquivo
Luciano Alves da Silva
81
“AnimacaoSprites_GundamWing.zip” (presente dentro da
pasta “Capitulo 6”).
Depois de importar o nosso projeto execute-o, e confira o
resultado conforme demonstra a figura seguinte:
Jogo em execução
Esse é um exemplo baseado no jogo “Gundam Wing –
Endless Duel”, um dos grandes sucessos da plataforma
“Super Nitendo”.
A intenção deste exemplo é trocarmos as posições dos
personagens do jogo. Para isso, vamos na classe GameMain
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
82
e, em seguida, vamos realizar as seguintes modificações
citadas a seguir:
Dentro do método construtor GameMain vamos substituir
as seguintes linhas de código destacadas em negrito
abaixo:
public GameMain() { : wing_gundam = new AnimationSprites(450, 130, 200, 250); wing_gundam.Add("wing_gundam_parado_1"); wing_gundam.Add("wing_gundam_parado_2"); : heavy_arms = new AnimationSprites(100, 120, 197, 263); heavy_arms.Add("heavy_arms_parado_1"); heavy_arms.Add("heavy_arms_parado_2"); : }
Pelas seguintes destacadas em negrito em seguida :
public GameMain() { : wing_gundam = new AnimationSprites(100, 130, 200, 250); wing_gundam.Add("wing_gundam_parado_1");
Luciano Alves da Silva
83
wing_gundam.Add("wing_gundam_parado_2"); : heavy_arms = new AnimationSprites(450, 120, 197, 263); heavy_arms.Add("heavy_arms_parado_1"); : }
Agora dentro do método Draw vamos substituir as
seguintes linhas de código destacadas em negrito abaixo:
public void Draw(Graphics graphics) { : wing_gundam.Draw(graphics,FlipEffect.HORIZONTAL); heavy_arms.Draw(graphics); }
Pelas seguintes linhas de código destacadas em negrito
abaixo:
public void Draw(Graphics graphics){ : wing_gundam.Draw(graphics); heavy_arms.Draw(graphics,FlipEffect.HORIZONTAL); }
Depois de realizada as modificações execute novamente o
nosso jogo, e confira o resultado que é mostrado na figura a
seguir:
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
84
Jogo em execução – Imagens trocadas
Regras para a criação de sprites
Quando vamos criar as sprites (animações) de um
determinado elemento de um jogo, normalmente, cada
imagem que irá representar uma ação desse elemento deve
ter o mesmo tamanho (padronizado para cada elemento do
jogo), e quando salvas, deverão estar nomeadas de forma
que fique fácil a organização das imagens (como por
exemplo : personagem_andando_1.png ,
personagem_andando2.png e etc.).
Luciano Alves da Silva
85
Capitulo 7 Detectando
colisões entre objetos no
jogo
ma das técnicas mais importantes, que não se pode
faltar em um jogo, é a detecção de colisões entre
elementos . Neste capítulo, iremos aprender a
detectar se dois objetos (ou mais) se colidem um com o
outro no jogo, através dos recursos oferecidos neste
material.
Primeiramente vamos criar um novo projeto no Eclipse com
o GameUtil2D chamado “Colisoes entre Objetos”.
Depois de criarmos o projeto copie todas as imagens
(presentes dentro da pasta “Capitulo 7”) para dentro projeto
na pasta “drawables”.
Dentro da seção de declaração de atributos da classe,
vamos realizar as declarações abaixo, como segue:
AnimationSprites personagem; Image cenario; Image obstaculo,obstaculo2;
U
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
86
Agora dentro do método construtor GameMain vamos
adicionar as seguintes instruções:
public GameMain() { personagem = new AnimationSprites((400 - 24), 305, 48, 50); personagem.Add("monstro_andando_1"); personagem.Add("monstro_andando_2"); personagem.Start(10, true); cenario = new Image("cenario", 0, 0, 800, 480); obstaculo = new Image("obstaculo", 80, 253, 68, 120); obstaculo2 = new Image("obstaculo", 630, 253, 68, 120); }
Agora dentro do método Update vamos adicionar as
seguintes instruções destacadas em negrito:
public void Update(KeyboardState keyboardState, MouseState mouseState) { if (keyboardState.IsKeyDown(Keys.RIGHT)) personagem.MoveByX(5); else if (keyboardState.IsKeyDown(Keys.LEFT)) personagem.MoveByX(-5); }
Luciano Alves da Silva
87
Agora dentro do método Draw vamos adicionar as
seguintes instruções destacadas em negrito:
public void Draw(Graphics graphics) { cenario.Draw(graphics); personagem.Draw(graphics); obstaculo.Draw(graphics); obstaculo2.Draw(graphics); }
Depois de digitar os códigos solicitados, execute a aplicação
e confira o resultado:
Jogo em execução
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
88
Se observarmos o jogo acima nosso personagem pode se
movimentar de um lado para o outro, porém, o nosso
personagem não pode ultrapassar os obstáculos (que são os
elevadores).
A ideia seria desenvolver um código que irá detectar a
colisão do personagem com os obstáculos, que no caso são
os elevadores.
Para adicionarmos o código de colisão vamos no método
Update para adicionarmos as seguinte instruções,
destacados em negrito abaixo:
public void Update(KeyboardState keyboardState, MouseState mouseState) { if (keyboardState.IsKeyDown(Keys.RIGHT)) { personagem.MoveByX(5); //Colidiu com o obstáculo da direita //("obstaculo2") if (Collision.Check(personagem, obstaculo2)) personagem.MoveByX(-5); } else if (keyboardState.IsKeyDown(Keys.LEFT)) { personagem.MoveByX(-5); //Colidiu com o obstáculo da esquerda //("obstaculo") if (Collision.Check(personagem, obstaculo)) personagem.MoveByX(5); }
Luciano Alves da Silva
89
Irei explicar agora o código que avalia a colisão do
personagem com as barras horizontais e verticais. A
expressão abaixo:
if (keyboardState.IsKeyDown(Keys.RIGHT))
Verifica se a tecla seta para direita foi pressionada através
do método IsKeyDown (com o argumento “Keys.RIGHT”). Se
a condição for verdadeira, é executado a instrução dentro
da condição :
personagem.MoveByX(5);
Em uma determinada circustância, poderá haver um
determinado momento em que o personagem poderá se
colidir com o obstáculo da direita (o objeto obstaculo2).
agora, como avaliar se houve a colisão ? Para verificar se
houve uma colisão entre dois objetos usamos o método
Check da classe Collision, como podemos ver na instrução
abaixo:
if(Collision.Check(personagem, obstaculo2))
Se ocorrer uma colisão, nosso personagem irá voltar um
passo anterior (se ele andou 5 pixels para direita e nesse
movimento ele colidiu com o obstáculo, ele voltará um
passo anterior), conforme você confere em seguida:
personagem.MoveByX(-5);
Desenvolvendo Jogos 2D com Plataforma Java - Guia para
Desenvolvedores [VERSÃO DE AMOSTRA]
90
A explicação das condições seguintes é “similar” ao que foi
explicado agora.
Vamos executar agora a nossa demonstração e conferir os
resultados.
Jogo em execução – Personagem colide com o elevador
Como pudemos observar acima, a colisão é uma das
técnicas de desenvolvimento de jogos mais importantes.
Com essa técnica conseguimos muitas coisas (como verificar
se o personagem está pisando em algum bloco, se um tiro
atingiu o inimigo e etc.).
Luciano Alves da Silva
91
Considerações Finais
Neste livro aprendemos SOMENTE AS NOÇÕES BÁSICAS de
desenvolvimento de jogos através do framework
GameUtil2D utilizando a linguagem Java. Vimos um pouco
sobre fundamentos de desenvolvimento de jogos e
aprendemos a instalar o framework GameUtil2D na
ferramenta Eclipse Luna (para o desenvolvimento de jogos
com o Java). Neste material aprendemos e desenvolvemos
algumas demostrações de jogos, através do aprendizado
básico sobre técnicas de criação de games (como animações
de sprites, colisões e etc.).
Para o aprendizado COMPLETO desta obra, adquira a
VERSÃO COMPLETA do livro no site oficial da EDITORA
AGBOOK (http://www.agbook.com.br).
Espero que esse material lhe tenha sido útil.
Um forte abraço!