livro jogos em java amostra

Luciano Alves da Silva

Desenvolvendo Jogos 2D com Plataforma Java - Guia para

Desenvolvedores [VERSÃO DE AMOSTRA]

2


3



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


5



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


7



8

Sobre o autor da obra

Luciano Alves da Silva ([email protected]) é

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


9



10


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).



12


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



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


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



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


17

Swing Copters

Angry Birds Rio



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.


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



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:


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



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


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 :



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.


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



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:


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:



28

Tela de abertura do Eclipse Luna

Em seguida irá se abrir a seguinte caixa de diálogo:

Caixa de diálogo – Workspace Launcher


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



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


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



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


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 :



34

Selecionando a opção

Feito isso clique no botão “Next”, que será aberta a seguinte

tela :


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



36

“GameUtil2D_Java1.x.zip”, que se encontra dentro da pasta

“GameUtil2D”). Feito isso, irá ser exibida a seguinte tela

abaixo:

Arquivo selecionado


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



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


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



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) { } }


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.



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.


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).



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”


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”


exibição de informações na tela do jogo.


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.



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”).


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:



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


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:



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 :


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.



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


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:



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.


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:



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:


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:



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


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



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 :


61

Imagem invertida na horizontal



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


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



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.


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



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á


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



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:


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):



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


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());



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)


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”).


73

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

executada a seguinte avaliação:

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


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:



74

Agora o avião não sai mais da tela


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



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”.


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:



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:


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:



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


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



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");


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:



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.).


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



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


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



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


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



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.).


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!

livro jogos em java amostra

Documents