FACULDADE DE TECNOLOGIA DA ZONA LESTE

DAVI BALBI CARVALHO LOPES

Desenvolvimento de um jogo na linguagem de programação
Java

São Paulo
2009

DAVI BALBI CARVALHO LOPES

Desenvolvimento de um jogo na linguagem de programação
Java

Monografia apresentada à Faculdade de
Tecnologia da Zona Leste como requisito parcial para obtenção do título de
Tecnólogo em Informática para Gestão de
Negócios.
Área de Concentração: Programação de jogos Orientador: Prof.
Carvalho Neto

São Paulo
2009

Antonio

Rodrigues

Nome: LOPES, Davi Balbi Carvalho
Título: Desenvolvimento de um jogo na linguagem de programação Java
Monografia apresentada à Faculdade de
Tecnologia da Zona Leste como requisito parcial para obtenção do título de
Tecnólogo em Informática para Gestão de
Negócios.

Aprovado em:

Banca Examinadora:

Prof.

Instituição:

Julgamento:

Assinatura:

Prof.

Instituição:

Julgamento:

Assinatura:

Prof.

Instituição:

Julgamento:

Assinatura:

RESUMO

LOPES, Davi Balbi Carvalho. Desenvolvimento de um jogo na linguagem de programação Java. 2009. 73 f. Monografia - Faculdade de Tecnologia da Zona
Leste, São Paulo, 2009.

A

linguagem

de

programação

Java

não

é

tradicionalmente

usada

no

desenvolvimento de jogos para computadores. Este trabalho busca demonstrar o uso da linguagem com esse propósito por meio da criação de um jogo. Pesquisa bibliográfica foi usada com o fim de expor os conceitos relacionados a jogos em geral, video games e à linguagem Java. As etapas de desenvolvimento do jog o são apresentadas em um estudo de caso. Os resultados do estudo mostram a possibilidade de criação de jogos em Java com sucesso. As abordagens empregadas podem ser usadas em projetos futuros
Palavras-chave: Desenvolvimento de jogos. Java. Programação.

ABSTRACT

LOPES, Davi Balbi Carvalho. Development of a game in the Java programming language. 2009. 73 f. Monografia - Faculdade de Tecnologia da Zona Leste, São
Paulo, 2009.

The Java programming language is not traditionally used in the development of computer games. This work seeks to demonstrate the use of the language for that purpose through the creation a game. Bibliographic research was used in order to set forth the concepts related to games in general, video games and the Java language.
The stages of the development of the game are presented in a case study. The results of the study show the possibility of the creation of games in Java successfully.
The approaches employed can be used in future projects.
Keywords: Game development. Java. Programming.

LISTA DE FIGURAS

Figura 1 – Classe Pessoa ......................................................................................... 23
Figura 2 – Relacionamento de herança .................................................................... 27
Figura 3 – Interface ................................................................................................... 28
Figura 4 – Estado inicial do jogo ............................................................................... 33
Figura 5 – Diagrama de classes do jogo ................................................................... 34
Figura 6 – Matriz de imagens do herói ...................................................................... 42
Figura 7 – Três tipos de detecção de colisões (DAVISON, 2005, p. 279). ................ 48
Figura 8 – Detecção de colisão do personagem com blocos acima.......................... 49
Figura 9 – Detecção de colisão do personagem com blocos abaixo ......................... 50
Figura 10 – Posicionamento horizontal dos Blocos ................................................... 54
Figura 11 – Mapa do jogo ......................................................................................... 55
Figura 12 – Ordem de renderização das entidades .................................................. 63
Figura 13 – Área visível do jogo em seu início .......................................................... 69

LISTA DE QUADROS

Quadro 1 – Classe Pessoa........................................................................................ 23
Quadro 2 – Criação de objetos.................................................................................. 24
Quadro 3 – Construtor ............................................................................................... 25
Quadro 4 – Subclasse ............................................................................................... 26
Quadro 5 – Polimorfismo ........................................................................................... 27
Quadro 6 – Interface ................................................................................................. 28
Quadro 7 – Classe Jogo ............................................................................................ 35
Quadro 8 – Atributos da classe PainelJogo .............................................................. 36
Quadro 9 – Construtor da classe PainelJogo ............................................................ 37
Quadro 10 – Classe Entidade ................................................................................... 40
Quadro 11 – Construtor da classe Heroi ................................................................... 41
Quadro 12 – Método desenha() da classe Heroi ....................................................... 42
Quadro 13 – Método testaDirecao() .......................................................................... 43
Quadro 14 – Método anda() ...................................................................................... 43
Quadro 15 – Método para() ....................................................................................... 44
Quadro 16 – Método ataca() ..................................................................................... 45
Quadro 17 – Classe Inimigo ...................................................................................... 45
Quadro 18 – Classe Objeto ....................................................................................... 46
Quadro 19 – Método distribuiEntidades() .................................................................. 47
Quadro 20 – Classe Bloco......................................................................................... 47
Quadro 21 – Método colidiu() .................................................................................... 50
Quadro 22 – Método getRetangulo() ......................................................................... 51
Quadro 23 – Método carregaImagem() ..................................................................... 51
Quadro 24 – Método carregaFonte() ......................................................................... 52
Quadro 25 – Matriz base ........................................................................................... 53
Quadro 26 – Método criaMapa() ............................................................................... 53
Quadro 27 – Código da interação ............................................................................. 57
Quadro 28 – Método iniciaCombate() ....................................................................... 58
Quadro 29 – Laço do jogo ......................................................................................... 59
Quadro 30 – Método atualiza() de forma geral .......................................................... 60
Quadro 31 – Testes de colisão com objetos e inimigos ............................................ 61

Quadro 32 – Primeira parte do método render() ....................................................... 64
Quadro 33 – Segunda parte do método render() ...................................................... 65
Quadro 34 – Método mostraHP() .............................................................................. 66
Quadro 35 – Double buffering ................................................................................... 67
Quadro 36 – Método pintaTela() ............................................................................... 68
Quadro 37 – Cálculo do tempo de pausa .................................................................. 70

SUMÁRIO

1 INTRODUÇÃO ....................................................................................................... 11
2 JOGOS................................................................................................................... 13
2.1 Video games ...................................................................................................... 15
2.2 Serious games ................................................................................................... 17
2.3 Role-playing games........................................................................................... 17
2.4 Desenvolvimento de jogos eletrônicos ........................................................... 19
2.5 Java .................................................................................................................... 21
2.5.1 Orientação a objetos básica em Java .............................................................. 22
2.5.2 Threads ............................................................................................................ 29
2.5.3 Exceções .......................................................................................................... 29
2.5.4 JARs ................................................................................................................. 30
2.5.5 Uso de Java no desenvolvimento de jogos ...................................................... 30
3 DESENVOLVIMENTO DE UM JOGO EM JAVA ................................................... 32
3.1 Estrutura do jogo .............................................................................................. 33
3.2 Sprites ................................................................................................................ 38
3.2.1 Entidades ......................................................................................................... 39
3.2.2 Herói ................................................................................................................. 40
3.2.3 Inimigos ............................................................................................................ 45
3.2.4 Objetos ............................................................................................................. 46
3.2.5 Blocos............................................................................................................... 47
3.3 Detecção de colisões ........................................................................................ 48
3.4 Carregamento de imagens e fontes ................................................................. 51
3.5 Criação do mapa ............................................................................................... 52
3.6 Interação ............................................................................................................ 56
3.7 Combate ............................................................................................................. 58
3.8 Estrutura da animação ...................................................................................... 59
3.8.1 Atualização ....................................................................................................... 59
3.8.2 Renderização ................................................................................................... 62
3.8.3 Pausa ............................................................................................................... 69

4 CONCLUSÔES ...................................................................................................... 71
REFERÊNCIAS ......................................................................................................... 72

11

1 INTRODUÇÃO

Este trabalho tem como objetivo apresentar as etapas do processo de desenvolvimento de um protótipo de jogo na linguagem de programação Java, mostrando para isso os problemas surgidos, assim como as abordagens e soluções empregadas, tanto as tradicionais, já utilizadas no desenvolvimento de jogos, quan to as criadas especificamente para o projeto. O jogo desenvolvido é baseado em características dos role-playing games; sua complexidade, entretanto, é mantida baixa, de forma que são priorizados conceitos que podem ser reutilizados e expandidos em outros jogos.
A linguagem Java não é comumente usada na criação de jogos para computadores, muitas vezes devido a concepções equivocada por parte dos desenvolvedores. Este trabalho servirá, portanto, como demonstração do uso da linguagem nesse campo.
Antes de serem expostos os tópicos referentes ao desenvolvimento do jogo, o capítulo ―Jogos‖ trata dos assuntos necessários ao pleno conhecimento do tema. É apresentada, de forma breve, a história dos jogos em geral, com ênfase nos jogos de tabuleiro, da antiguidade ao surgimento dos role-playing games na segunda metade do século XX, bem como as descrições, os conceitos e as definições dos autores pesquisados. A seguir, são abordados especificamente os videogames, com as definições dos autores sobre o que caracteriza essa modalidade dos jogos e suas origens históricas. Fala-se, então, de forma sucinta sobre os chamados jogos sérios, ou serious games, para, em seguida serem tratados os role-playing games como gênero dos video games, com a exposição de sua origem nos jogos de tabuleiro de mesmo nome e suas características definidoras. A próxima seção se refere ao desenvolvimento de jogos comerciais, com a listagem e subseqüente explicação das partes o compõem. Por fim, são apresentados os aspectos relacionados à linguagem Java, à orientação a objetos básica e ao uso dessa linguagem no desenvolvimento de jogos.
O capítulo ―Desenvolvimento de um jogo em Java‖ expõe as etapas do desenvolvimento do jogo, as quais incluem : sprites; detecção de colisões; criação do mapa do jogo; animação, que se divide de forma geral em atualização, renderização

12

e pausa, mas possui subdivisões como renderização ativa e double buffering; e interação do usuário com o jogo. Cada um desses tópicos é descrito e explicado de maneira que sejam expostos da melhor forma possível os conceitos mais importantes utilizados.
A metodologia empregada envolveu pesquisa bibliográfica para os aspectos históricos e conceituais dos assuntos tratados. Realizou-se um estudo de caso a partir da criação do jogo, o qual contém especificações a respeito de suas etapas de desenvolvimento. 13

2 JOGOS

Os jogos estão presentes nas diversas épocas da história , havendo registros de exemplos com milhares de anos de idade, como o senet, encontrado em uma tumba egípcia datada de 2686 a. C. (JUUL, 2005). Entretanto, Huizinga (2003, p.1, tradução nossa) afirma, referindo-se ao comportamento dos animais, que brincam entre si, que o jogo ―é mais velho que a cultura, pois a cultura, todavia inadequadamente definida, sempre pressupõe a sociedade humana, e os animais não esperaram que o homem lhes ensinasse seu jogo.‖ 1
Diversas definições e descrições sobre o que é um jogo foram propostas, muitas das quais por vezes entram em conflito entre si, mostrando as maneiras diferentes de pensar dos autores e o foco que adotaram. Assim, o jogo pode ser considerado
[...] uma atividade livre que permanece conscientemente fora da vida
―ordinária‖ como sendo ―não séria‖, mas ao mesmo tempo absorvendo o jogador intensa e completamente. É uma atividade não conectada com qualquer interesse material, e nenhum lucro pode ser ganho por ela. Ela avança em seus próprios limites de tempo e espaço de acordo com regras fixas e de maneira ordenada. Ela promove a formação de agrupamentos sociais que tendem a se cercar de sigilo e a expressar sua diferença do
2
mundo comum através de disfarces ou outros meios (HUIZINGA, 2003,
p.13, tradução nossa).

Crawford (2003) buscou definir o que é um jogo atravé s de uma série de considerações, tomando como ponto de partida a expressão criativa. Se a motivação do criador é a beleza, então o resultado é a arte, entretanto se o criador tem como motivação o dinheiro, tem-se como resultado entretenimento. Este, caso não seja interativo, pertence à mesma classe dos filmes e livros. Por outro lado, se há interação, Crawford (2003) chama o entretenimento de joguete3. Um joguete que não possua objetivo definido associado ao seu uso é um brinquedo, enquanto um

1

―Play is older than culture, for culture, however inadequately defined, always presupposes human society, and animals have not waited for man to teach them their playing.‖
2
―[…] a free activity standing quite consciously outside ‗ordinary‘ life as being ‗not serious‘, but at the same time absorbing the player intensely and utterly. It is an activity connected with no material interest, and no profit can be gained by it. It proceeds within its own proper boundaries of time and space according to fixed rules and in a orderly manner. It promotes the formation of social groupings which tend to surround themselves with secrecy and to stress their difference from the common world by disguise or other means.‖
3
Crawford emprega o termo plaything.

14

que possua objetivo definido é chamado de desafio. Segundo essa categorização, jogos de computador como SimCity e The Sims são exemplos de brinquedos.
Quando existe um agente ativo contra quem competir, o desafio é um conflito, caso contrário se trata de um quebra-cabeça. Por fim, se os oponentes podem apenas devotar sua atenção para melhorar seu próprio desempenho, o conflito é uma competição, porém se é permitido que os oponentes tentem impedir o progresso de seu adversário, então temos um jogo.
De acordo com Egenfeldt-Nielsen, Smith e Tosca (2008), na Mesopotâmia, por volta do tempo em que o senet era jogado no Egito, havia o Jogo Real de Ur. Tais jogos, além do entretenimento, possuíam função simbólica e religiosa.
Outros exemplos de jogos antigos são o Go, jogado no Japão desde 2000 a. C., os dados, os jogos olímpicos na Grécia e um antepassado do xadrez, o indiano
Chaturanga.
Durante o século XIX, surgiram outros marcos para os jogos. Kriegsspiel, criado pelo tenente prussiano Georg von Reisswitz em 1824, apresentava situações complexas e tornou-se popular no exército da Prússia. Nos Estados Unidos, em 1843, foi lançado o jogo de tabuleiro The Mansion of Happiness. Já no século XX, Monopólio, lançado na década de 1930, teve um sucesso sem precedentes.
Importante também foi o surgimento dos role-playing games (RPGs) no início da década de 1970, inspirados pelos wargames (jogos de guerra) popularizados na década anterior e pela literatura fantástica, especialmente por O Senhor dos Anéis, de J. R. R. Tolkien.
Lançado em 1974, Dungeons & Dragons deu origem a inúmeros outros RPGs. Nele, os jogadores escolhiam a raça a que seus personagens pertenceriam e participavam de aventuras em que enfrentavam criaturas segundo as regras do jogo, acumulando pontos de experiência. O jogador responsável por ser o mestre interpretava as regras e descrevia as cenas para que os outros jogadores tomassem decisões, cujos resultados eram determinados por dados. A ambientação e os princípio s de
Dungeons & Dragons e RPGs posteriores iriam influenciar os video games, que ganhariam um gênero próprio também chamado RPG.

15

2.1 Video games

Juul (2005) define video games como jogos que usam poder computacional, em que o computador detém as regras e que são jogados através do uso de um dispositivo de vídeo.
Podemos examinar as regras como são encontradas mecanicamente no programa do jogo ou no manual de um jogo de tabuleiro, ou podemos examinar as regras como algo que os jogadores negociam e aprendem e nas quais eles gradualmente melhoram sua habilidade. Podemos também tratar o mundo fictício como um conjunto de sinais fixos que o jog o apresenta e podemos tratá-lo como algo que o jogo deixa o jogador
4
imaginar e que então os jogadores imaginam de maneiras próprias
(JUUL, 2005, p.2, tradução nossa).

Já Zylda (2005, pp. 25-32, tradução nossa) propõe que video game é ―uma competição mental, jogada com um computador, de acordo com certas regras, por diversão, recreação ou para se ganhar uma aposta.‖ 5
―O video game é agora considerado como tudo desde o ergódico (trabalho) ao lúdico
(jogo); como narrativa, simulação, espetáculo, reparo e arte [...]‖

6

(WOLF, Mark J.

P.; PERRON, Bernard, 2003, p. 2, tradução nossa).
De acordo com Juul (2005), o provável primeiro video game foi Spacewar!, porém existiram antecessores, como um aparelho patenteado em 1948 por Thomas T.
Goldsmith Jr. e Estle R. Mann com a descrição ―Cathode-Ray Tube Amusement
Device‖, isto é, ―Dispositivo de Entretenimento de Tubo de Raios Catódicos‖ em que alvos eram colocados sobre a tela, em vez de serem gráficos desenhados nela.

4

―In addition, we face a choice between a focus on the game itself or on the player of the game: We can examine the rules as they are found mechanically in the game program or in the manual of a board game, or we can examine the rules as something that players negotiate and learn, and at which they gradually improve their skill. We can also treat the fictional world as a fixed set of signs that the game presents, and we can treat the fictional world as something that the game cues the player into imagining and that players then imagine in their own ways.‖
5
―[Video game:] a mental contest, played with a computer according to certain rules for amusement, recreation, or winning a stake.‖
6
―The video game is now considered as everything from the ergodic (work) to the ludic (play); as narrative, simulation, performance, remediation, and art [...]‖

16

Outros antepassados dos video games foram o computador Nimrod, apresentado em 1951 na Exibição de Ciência do Festival of Britain, que usava o antigo jogo Nim para demonstrar seu poder de processamento; e uma versão eletrônica do jogo da velha criada em 1952 por Alexander S. Douglas chamada OXO, que tinha como objetivo ilustrar a interação entre humanos e máquinas.
Assim, podemos dizer que, tanto o Nimrod quanto OXO foram criados não como diversão, mas como meios para a comprovação de algo, não sendo assim jogos propriamente ditos.
Por outro lado, Tennis for Two, criado pelo físico William Higinbotham e apresentado em 1958 para os visitantes do Brookhaven National Laboratory, está mais próximo dos video games por alguns motivos. O aparelho usava um osciloscópio para mostrar uma quadra de tênis vista de lado — formada apenas por um traço horizontal e outro vertical — e um ponto brilhante que representava a bola. Os jogadores usavam controles com botões e dials para direcionar a bola com trajetória desejada. Pode-se afirmar que nem Tennis for Two nem os jogos mencionados anteriormente são, na realidade, video games, uma vez que não utilizavam um sinal de vídeo.
Porém, Tennis for Two aproximou-se mais dos video games ao mostrar objetos gráficos móveis e por ter sido criado precisamente como uma forma de entretenimento, ao contrário de Nimrod e OXO.
Anos depois, em 1966, Ralph Baer desenvolveu uma série de sete protótipos, cada um com um jogo, que eram ligados em televisões. O último protótipo, Brown Box, foi construído em 1968 e então lançado pela Magnavox em 1972 com o nome Odyssey, tornando-se dessa maneira o primeiro console doméstico. Também em 1972, foi lançado pela Atari o conhecido Pong, baseado no jogo Tennis, de Ralph Baer
(PONG-STORY,1999).
Desde então, os video games passaram por diversas transformações. Conforme surgiram inovações tecnológicas e novas idéias, uma indústria se desenvolveu.
Variadas plataformas foram usadas para jogar, como consoles, arcades, mainframes, computadores pessoais, e, atualmente, mesmo celulares. Dessa forma, os video games também se dividiram em diversos gêneros, tendo como exemplos

17

jogos de plataforma, tiro, estratégia e RPGs, entre muitos outros. Esses gêneros por vezes se misturaram, dando origem a novas possibilidades.

2.2 Serious games

Serious games, ou jogos sérios, são jogos cujo propósito não é exclusivamente o entretenimento, podendo, por exemplo,

ser usados com fins educacionais e de

treinamento.
Zylda (2005, pp. 25-32, tradução nossa) define serious game como
[...] uma competição mental, jogada com um computador de acordo com regras específicas, que usa o entretenimento para promover objetivos de treinamento governamental ou corporativo, educação, saúde, políticas
7
públicas e comunicação estratégica.

Essa definição parece pressupor que os serious games estejam ligados indissociavelmente aos computadores, entretanto esse termo já era usado antes de se referir a um tipo de vídeo game.
―Preocupamo-nos com jogos sérios no sentido de que esses jogos têm um propósito educacional explícito e cuidadosamente pensado e não sã o intencionados para serem jogados primariamente por diversão‖

8

(Abt, Clark C., 1987, p. 9,

tradução nossa).

2.3 Role-playing games

―Role-playing games requerem que os jogadores assumam papéis de acordo com o

7

―[Serious game:] a mental contest, played with a computer in accordance with specific rules, that uses entertainment to further government or corporate training, education, health, public policy, and strategic communication objectives.‖
8
―We are concerned with serious games in the sense that these games have an explicit and carefully thought-out educational purpose and are not intended to be played primarily for amuseme nt.‖

18

tempo e lugar específicos determinados para o mundo do jogo‖

9

(ESKELINEN;

TRONSTAD, 2003, p. 204, tradução nossa).
Os role-playing games (RPGs) de tabuleiro inspiraram a princípio jogos de computador como Adventure, de Will Crowther, totalmente baseados em texto, em que as cenas eram descritas para o jogador, que, então, interagia pela digitação de comandos breves.
Em conjunto com Dungeons & Dragons, Adventure, por sua vez, influenciou Rogue, desenvolvido por Michael Toy e Glenn Wichman, que utilizava caracteres para representar cenários, personagens e itens, criados aleatoriamente. Rogue gerou todo um gênero, os chamados roguelikes. A influência desses jogos se estende até hoje nos RPGs em computadores e consoles.
Role-playing game significa ―jogo de interpretação de papéis‖, e essa é a sua idéia básica. Nos RPGs de mesa, os jogadores interpretam seus personagens em histórias passadas em mundos fantásticos que são, como foi dito acima, narradas pelo mestre, tomando decisões segundo um sistema pré-estabelecido. Cada personagem possui um conjunto de atributos, como força, resistência, etc., que influenciam o jogo.
Os RPGs em computadores e consoles deixam de lado a interpretação, contudo também são chamados de RPGs por terem herdado suas principais características de sua contraparte de mesa. Essas características são, de forma básica, a ambientação fantástica, os atributos, os níveis de experiência, e o combate baseado em turnos.
RPGs eletrônicos também possuem subgêneros, como RPGs de ação, que abandonam o sistema de combate em turnos em favor de combates em tempo real.
O subgênero em maior evidência, porém, é o chamado Massively multiplayer online role-playing game (MMORPG), em que milhares de pessoas jogam simultaneamente pela Internet em um mesmo mundo virtual.

9

―Role-playing games require that the players assume roles in accordance with the specific time and place that is assigned to the game-world.‖

19

2.4 Desenvolvimento de jogos eletrônicos

Basicamente, Bethke (2003) divide o processo de desenvolvimento de jogos comerciais em partes relacionadas a design, código, arte, áudio, gestão, garantia de qualidade, beta testing, negócio e pós-lançamento, entre outras. As subdivisões de cada uma dessas partes são responsabilidade dos profissionais das áreas respectivas, que formam a equipe de desenvolvimento.
Jogos que têm uma metodologia de desenvolvimento ruim (ou nenhuma) levam muito mais tempo do que deveriam, atropelam o orçamento e tendem a ser injustificadamente defeituosos. A maioria dos jogos
10
comerciais falha em gerar lucro (BETHKE, 2003, p. 3, tradução nossa).

O design envolve o designer chefe, que coordena a equipe de design, e os designers responsáveis pelas regras do jogo e pelos níveis e missões, além dos escritores da história e dos diálogos.
Em seguida, o código é criado pelos programadores, que se dividem em várias especialidades. São liderados pelo programador chefe e supervisionados pelo diretor técnico. Outras áreas dos programadores incluem: as regras do jogo, gráficos
3D, inteligência artificial, interface do usuário, programação de áudio, ferramentas, editor de níveis e redes.
A equipe de arte é supervisionada pelo diretor de arte. Os profissionais que compõem essa equipe são os artistas conceituais, artistas de 2D e designers de interfaces, modeladores de 3D, modeladores de personagens, artistas de texturas, animadores e desenhistas de storyboard.
A área de áudio divide-se em efeitos sonoros, música e voz. Cada uma dessas divisões tem seus próprios profissionais, como engenheiros de som, compositores e músicos. 10

―Games that have a poor development methodology (or none at all) take much longer than they should, run over budget, and tend to be unreasonably buggy. The majority of commercial games fail to turn profit.‖

20

―A gestão de projeto de jogo é o componente ma is crítico em minha experiência‖

11

(BETHKE, 2003, p. 50, tradução nossa). A gestão do projeto de jogo é compartilhada pelo line producer, que coordena tarefas que, individualmente, são pequenas; pelo produtor associado, que ajuda na comunicação entre equipes, entre outras tarefas; pelo produtor executivo e pelo chefe do estúdio, responsáveis por planejar e executar o projeto de maneira lucrativa; e pelo produtor, que em estúdios maiores administra o projeto.
O componente de garantia de qualidade trata do apontamento de defeitos para correção. Não há um processo unificado e empresas menores muitas vezes não possuem uma equipe em tempo integral com esse propósito.
A área de garantia de qualidade é composta, além do chefe, por diversas equipes: a principal, que monitora o progresso do jogo; a equipe de multiplayer, que testa especificamente os aspectos dos jogos direcionados para jogadore s simultâneos; a equipe de compatibilidade jogos em diferentes sistemas; e a equipe de localização, comprometida com a adaptação dos jogos para outros mercados.
Beta testing é o nome dado ao teste realizado por voluntários como preparação para o lançamento de um jogo. A comunicação com os testadores é feita através do gestor do programa de beta testing.
A parte do negócio envolve outras áreas, cada uma com seus respectivos profissionais: desenvolvimento de negócios, licenciamento e promoção, compra e venda. Ligados ao desenvolvimento de negócios, estão os executivos de desenvolvimento de negócios, que aprovam jogos para o lançamento; os CEOs de publicadoras, os chefes de estúdio e os advogados. A parte de licenciamento trata tanto de jogos baseados em licenças quanto das licenças geradas pelos próprios jogos. Isso pode ser administrado pelo executivo de desenvolvimento de negócio ou por um funcionário em tempo integral. A parte de promoção, compra e venda envolve executivos de vendas, agentes de varejo, relaç ões com a imprensa, eventos, etc.

11

―Management of a game is the most critical component in my experience.‖

21

Há também a área do negócio que se refere aos manuais e guias de estratégia. Os manuais podem

ser

escritos

por

um

profissional

contratado

ou

pelos

desenvolvedores. Os guias são escritos durante o processo de desenvolviment o do jogo com base em versões preliminares, de forma que podem existir discrepâncias.
Outras partes são as de manufatura, relacionada com as etapas finais de lançamento do jogo, e fabricantes de hardware. Os fabricantes de consoles têm os direitos de aprovação do jogo. Com fabricantes de hardware, é possível obter equipamentos grátis para testes.
Por fim, o pós-lançamento está ligado a atualizações, patches (arquivos de correções) e assistência.

2.5 Java

Antes de serem levadas em consideração as questões rela cionadas ao uso de Java no desenvolvimento de jogos, serão apresentados os conceitos ligados à própria linguagem que serão necessários para o entendimento do próximo capítulo, tomando por base Caelum (2008).
A linguagem Java foi originalmente desenvolvida pela Sun Microsystems para ser utilizada em dispositivos pequenos, entretanto teve seu foco mudado.
Em outras linguagens, o código fonte de um programa é compilado para uma plataforma específica, sendo preciso que isso ocorra para também para outros sistemas operacionais após terem sido feitas as alterações necessárias. O Java, entretanto, utiliza uma máquina virtual, chamada Java Virtual Machine (JVM), que age como intermediária entre a aplicação e o sistema operacional de maneira a permitir que um mesmo código possa ser executado em diferentes sistemas sem modificações. 22

Quando se compila um programa em Java, é gerado um código chamado bytecode, que é executado pela JVM. O programa roda, então, não no sistema operacional, mas na JVM.
Para que aplicações em Java sejam executadas, é necessário o Java Runtime
Environment (JRE) — ambiente de execução Java — que contém, além da JVM, as bibliotecas usadas pelo Java.
O desenvolvimento de aplicações em Java, por sua vez, é feito com o Java
Development Kit (JDK).

2.5.1 Orientação a objetos básica em Java

A orientação a objetos busca modelar o mundo real por meio de classes e objetos, e, sendo Java uma linguagem orientada a objetos, quaisquer programas desenvolvidos nela também o serão. A seguir, serão apresentados alguns conceitos básicos da programação orientada a objetos, uma vez que esta é indissociável da linguagem Java.
Serão apresentados diagramas de classes da notação Unified Modeling Language
(UML) como forma de representar os exemplos dados.

2.5.1.1 Classes

Classes são especificações ou estruturas de objetos. Elas possuem a definição de um conjunto de atributos e comportamentos ou operações que seus objetos têm em comum. Em Java, uma classe é criada de acordo com o Quadro 1.

23

public class Pessoa { private String nome; public void setNome(String nome){ this.nome = nome;
}
public String getNome() { return nome;
}
}
Quadro 1 – Classe Pessoa

Essa classe possui o atributo nome e operações para dar e retornar esse nome.
Na UML, classes são representadas por um retângulo divido horizontalmente em três partes, nas quais ficam, de cima para baixo, o nome da classe, seus atributos e seus métodos. A Figura 1 apresenta a representação da classe Pessoa pela UML.

Figura 1 – Classe Pessoa

2.5.1.2 Objetos

Enquanto uma classe se trata, na verdade, de um projeto, um objeto é aquilo que se pode construir com tal projeto. No exemplo anterior, a classe Pessoa é uma especificação segundo a qual uma pessoa tem nome; as pessoas propriamente ditas seriam os objetos instanciados a partir dessa classe, ca da uma possuindo seu próprio nome.
O Quadro 2 mostra a criação de objetos em Java.

24

Pessoa joao = new Pessoa();
Pessoa maria = new Pessoa();
Quadro 2 – Criação de objetos

Tanto joao quanto maria são objetos da classe Pessoa e, portanto, ambos possuem o atributo nome e as operações para que esse nome seja definido e retornado, que foram especificados em Pessoa.

2.5.1.3 Métodos

Os métodos são os comportamentos que a classe tem ou as operações que ela realiza. No exemplo dado, setNome() é o método que passa um nome para o objeto, enquanto getNome() retorna esse nome. Poderiam existir inúmeros outros métodos e atributos nessa classe.
Uma classe Conta, por exemplo, que tivesse atributos como número, nome do titular e saldo teria métodos para depositar e sacar, que modificariam o saldo.
A palavra chave void é usada para indicar que o método não envia qualquer informação de volta. Métodos que retornam algo, entretanto, devem declarar o tipo do retorno, isto é, se o valor a ser retornado é do tipo int, float, boolean, etc. Esse retorno é indicado pela palavra chave return.
As variáveis entre parênteses são os argumentos ou parâmetros que o método recebe e que irá utilizar. Em setNome(), o parâmetro recebido pelo método é nome, que é atribuído à propriedade da classe também chamada nome.
Em Java, as aplicações começam sempre pelo método chamado main().

25

Os construtores são semelhantes aos métodos, mas são declarados com o mesmo nome de sua classe e não têm retorno. Quando um objeto é instanciado, por meio da palavra chave new, o construtor da classe é executado. Se um construtor não for declarado, será criado um padrão, que não recebe parâmetros e tem o corpo vazio.
O Quadro 3 apresenta um construtor para o exemplo dado e a criação de um objeto com esse construtor. Em lugar de setNome(), o nome do objeto é passado como parâmetro para o construtor. public class Pessoa { private String nome; public Pessoa (String nome){ this.nome = nome;
}
public String getNome() { return nome;
}
}
Pessoa joao = new Pessoa(“João”);
Quadro 3 – Construtor

2.5.1.4 Modificadores de acesso

Modificadores de acesso definem quais classes podem acessar determinados atributos ou métodos. A fim de se evitar que atributos sejam modificados incorretamente, deve-se marcá-lo como privado utilizando-se a palavra chave private. Dessa forma, o atributo assim marcado pode ser alterado somente dentro da própria classe. Para que outra classe o altere, um método público deve ser usado.
No exemplo da classe Pessoa, o nome pode ser obtido por outra classe, apenas por meio do método getNome(). Por tratar-se de um exemplo simples, não fica aparente uma necessidade real de se esconder o atributo nome, mas há casos em que valores não podem ser modificados de qualquer maneira.

26

O modificador public permite que qualquer classe modifique um atributo marcado dessa maneira.
A UML representa o modificador private como um sinal de menos precedendo os atributos e métodos. O modificador public, por sua vez, é representado por um sinal de mais.

2.5.1.5 Herança

Na herança, uma classe herda os atributos e métodos de outra classe. Usa -se esse tipo de relacionamento entre classes em que uma é um subtipo ou especialização de outra. Assim, não é necessário que todo o código de uma classe seja copiado para outra, além de possibilitar uma melhor organização.
A palavra chave usada em Java para a herança é extends. Ainda no exemplo da classe Pessoa, uma classe Funcionario poderia ser sua filha, como pode ser observado no Quadro 4: public class Funcionario extends Pessoa { private double salario;
}
Quadro 4 – Subclasse

Essa nova classe herda o atributo nome e os métodos da superclasse e p ode possuir seus próprios atributos e métodos específicos. É possível, também, sobrescrever métodos herdados para alterar seu comportamento.
Uma mesma classe pode ter várias classes filhas, mas pode apenas ter uma mãe, ou seja, pode haver apenas uma herança simples, pois o Java não suporta herança múltipla. A Figura 2 representa o exemplo de herança acima segundo a notação UML.

27

Figura 2 – Relacionamento de herança

2.5.1.6 Polimorfismo

Polimorfismo é o nome dado a capacidade que um objeto tem de poder ser referenciado de várias formas. No exemplo de herança dado, um objeto de
Funcionario pode ser referenciado como Pessoa. Isso ocorre porque um Funcionario é uma Pessoa. Assim, é possível atribuir um objeto de Funcionario a uma referência de Pessoa, como pode ser visto no Quadro 5:
Funcionario f = new Funcionario(“João”);
Pessoa p = f;

Quadro 5 – Polimorfismo

Essa capacidade permite que um método que receba como parâmetro um objeto de
Pessoa também possa receber um objeto de Funcionario.

28

2.5.1.7 Interfaces

Interfaces funcionam como contratos que definem o que as classes devem fazer.
Nelas, podem ser definidas apenas assinaturas de métodos e constantes.
Determina-se apenas o que a classe deve fazer, mas não como deve ser feito.
Deste modo, o comportamento do método deve ser escrito em cada classe que implemente a interface.
São usadas interfaces em classes que, mesmo que não tenham um relacionamento de herança, compartilham um comportamento.
Em Java, utiliza-se a palavra chave implements para que uma interface seja implementada, conforme é apresentado no Quadro 6: interface Autenticavel {
Boolean autentica(int senha);
}
class Gerente extends Funcionario implements Autenticavel {
//Atributos
public boolean autentica(int senha) {
//Código
}
}
Quadro 6 – Interface

Dessa maneira, outras classes que necessitassem do método autentica() teriam somente que implementar a interface Autenticavel.
Interfaces são representadas na UML por meio do estereótipo , como se vê na Figura 3:

Figura 3 – Interface

29

2.5.2 Threads

Threads são linhas de execução paralelas. São empregadas em momentos em que é necessário que, em um mesmo programa, duas ou mais coisas sejam executadas simultaneamente. A classe Thread é usada em Java para a criação de threads, recebendo como parâmetro o objeto que deverá ser executado em paralelo. O método start() inicia a execução. Para que as threads sejam usadas, entretanto, as classes dos objetos que serão executados devem implementar a interface Runnable, que possui apenas o método run(). O método sleep() de Thread é responsável por fazer a thread ficar inativa por um dado período de milissegundos passado como parâmetro.

2.5.3 Exceções

Erros ou exceções que possam ocorrer são tratados em Java por meio das cláusulas try e catch. O código passível de erros é colocado após a cláusula try e, caso ocorra uma exceção, esta é apanhada, de forma a não comprometer a execução do programa.

30

2.5.4 JARs

Um Java Archive (JAR) é um arquivo comprimido contendo o código e os recursos
— como imagens e sons — de uma aplicação em Java, permitindo uma maior facilidade de transporte.

2.5.5 Uso de Java no desenvolvimento de jogos

Java não é uma linguagem geralmente usada para o desenvolvimento de jogos.
Davison (2005) aponta que as objeções feitas à linguagem são as de que o Java é lento demais para a programação de jogos, possui vazamentos d e memória, é de alto nível em demasia, a instalação de suas aplicações é difícil, não é suportado em consoles, não é usado para a programação de jogos de verdade e, por fim, que a
Sun Microsystems não tem interesse em apoiar jogos em Java.
A maior parte dessas objeções está relacionada com a criação da linguagem no final da década de 1990. Desde então, o Java tornou-se consideravelmente mais sofisticado e rápido, além de possuir uma grande quantidade de bibliotecas.
A objeção de que o Java é lento demais para a programação de jogos tinha validade nos primeiros anos da linguagem quando sua velocidade era 20 a 40 vezes inferior às do C e C++. Contudo, o Java agora é comparável em velocidade a essas linguagens. Já quanto ao problema dos vazamentos de memória, é possível evitá-lo com boa programação. Sobre o fato de o Java ser de alto nível em demasia, isto é, de possuir uma alta abstração que o afasta da linguagem de máquina, deve-se levar em conta as vantagens trazidas pela vasta biblioteca de classes e pela orientação a objeto s.
Além disso, o Java pode utilizar o Java Native Interface (JNI) para, por meio de C ou
C++, se comunicar com o hardware.

31

Acerca da dificuldade de instalação das aplicações Java, o uso de bons softwares de instalação pode sanar esse problema.
A falta de suporte ao Java em consoles, entretanto, realmente é verdade , restringindo o desenvolvimento de jogos nessa linguagem a computadores e dispositivos móveis.
Com relação à objeção de que a linguagem Java não é usada para o desenvolvimento de jogos de verdade, ainda que a quantidade de jogos em Java seja muito inferior daqueles escritos em C ou C++, ela tem crescido. Diversos jogos foram escritos completa ou parcialmente em Java.
A última das objeções mencionadas por Davison (2005), a de que a Sun
Microsystems não tem interesse em apoiar jogos em Java, também não tem fundamento, uma vez diversos recursos úteis para a programação de jogos têm sido introduzidos a cada nova versão, como capacidades de áudio e vídeo melhoradas e modo de tela cheia.

32

3 DESENVOLVIMENTO DE UM JOGO EM JAVA

Neste capítulo serão apresentadas as etapas do desenvolvimento de um jogo simples em duas dimensões (2D) na linguagem Java, com base em Davison (2005).
O gênero definido para o jogo é o RPG, especialmente da variedade geralmente ligada a consoles, em lugar daquela típica dos computadores. Isso poderá ser observado em elementos como o controle realizado pelo teclado, em oposição ao controle feito por meio do mouse; a perspectiva aérea; e o sistema de combate por turnos, entre outros.
Uma vez que se trata de um jogo simples, sua complexidade será mantida em um nível baixo; serão utilizadas em sua maior parte apenas as soluções mínimas requeridas pelo programa. Ademais, a reprodução de sons não será levada em consideração. O objetivo do jogo consiste basicamente em mover um personagem pelo mapa a fim de alcançar um baú em uma câmara. Essa câmara, entretanto, é protegida por uma porta trancada. Dessa forma, deve-se antes obter a chave da porta, que é guardada por um inimigo, o qual deve ser derrotado. Outro inimigo guarda o caminho para a porta. A Figura 4 mostra o jogo em seu estado inicial.

33

Figura 4 – Estado inicial do jogo

3.1 Estrutura do jogo

A classe principal, Jogo, é responsável por iniciar o programa. A classe PainelJogo, uma subclasse de JPanel, contém o laço da animação, o mapa e a lógica do jogo, assim como métodos para o carregamento de imagens e fontes, além de funcionar como a superfície em que todo o jogo é desenhado . A classe Entidade representa de maneira geral os sprites do jogo, possuindo as subclasses Heroi, Inimigo, Bloco e
Objeto. A classe Heroi representa o personagem controlado pelo usuário; Inimigo se refere aos inimigos enfrentados; Bloco é a representação das tiles, isto é, as unidades que formam o mapa; e Objeto especifica os artefatos com os quais o personagem interage. O diagrama de classes do jogo feito a partir da engenharia reversa do código é apresentado na Figura 5.

34

Figura 5 – Diagrama de classes do jogo

O jogo é executado em uma janela com tamanho fixo de 500 por 500 pixels. A classe Jogo cria essa janela e o objeto de PainelJogo. Esse objeto então é colocado na janela e o jogo tem início. O Quadro 7 apresenta o código da classe Jogo.

35

public class Jogo { public static void main(String[] args) {
JFrame jan = new JFrame("Jogo");
Toolkit tk = Toolkit.getDefaultToolkit();
Dimension dimTela = tk.getScreenSize(); int larg = 500; int alt = 500;
PainelJogo pJogo = new PainelJogo(larg, alt); jan.setContentPane(pJogo); jan.pack(); jan.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); jan.setLocation(dimTela.width/2-larg/2, dimTela.height/2alt/2); jan.setResizable(false); jan.setVisible(true);
Thread thJogo = new Thread(pJogo); thJogo.start(); }
}
Quadro 7 – Classe Jogo

A classe Toolkit é usada para que a janela seja posicionada no centro da tela.
Largura e altura são passadas para PainelJogo; o método pack() se encarrega de dimensionar a janela de acordo com o painel.
É em PainelJogo, no entanto, que se encontram as partes mais importantes do jogo.
Os atributos dessa classe podem ser vistos no Quadro 8, enquanto o Quadro 9 apresenta seu construtor.

36

public class PainelJogo extends JPanel implements Runnable, KeyListener { private Image db; private Graphics2D dbg; private int tile; private private private private

ArrayList
ArrayList
ArrayList
ArrayList

blocos; sobreBlocos; fundo; entidades; private Heroi heroi; private int base[][]; private String DIR_IMAGENS = "Imagens/"; private String heroiNomes[][] = {
{"Heroi_f_2.gif","Heroi_f_3.gif","Heroi_f_1.gif"},
{"Heroi_c_2.gif","Heroi_c_3.gif","Heroi_c_1.gif"},
{"Heroi_e_2.gif","Heroi_e_3.gif","Heroi_e_1.gif"},
{"Heroi_d_2.gif","Heroi_d_3.gif","Heroi_d_1.gif"}
};
private String entidadesNomes[] = {
"Inimigo_e.gif","Inimigo_d.gif","BauPequeno.gif",
"BauGrande.gif"
};
private String muros[] = {
"Topo.gif", "Piso.gif", "Parede.gif", "Porta.gif"
};
private Font fonte; private int deslocX; // Deslocamento do mapa; private int deslocY; // Deslocamento do mapa; private int xJan, yJan; // Para posicionar as telas e o texto private private private private private private

BufferedImage
BufferedImage
BufferedImage
BufferedImage
BufferedImage
BufferedImage

private private private private private private boolean boolean boolean boolean boolean boolean chave; telaPausa; telaInicial; telasCombate[]; telaGameOver; telaFinal; rodando; pausado; gameOver; jogoIniciado; combate; pressionado; int imagemCombate = 0;
}
Quadro 8 – Atributos da classe PainelJogo

37

public PainelJogo(int larg, int alt) { super.setPreferredSize(new Dimension(larg, alt)); pausado = false; gameOver = false; jogoIniciado = false; combate = false; pressionado = false; blocos = new ArrayList(); sobreBlocos = new ArrayList(); fundo = new ArrayList(); entidades = new ArrayList(); tile = 56; // Para que as tiles tenham tamanho fixo deslocX = 0; deslocY = 0; fonte = carregaFonte("retganon.ttf"); criaMapa(base, muros); heroi = new Heroi(carregaPersonagem(heroiNomes),100,100); distribuiEntidades(entidadesNomes); chave = carregaImagem("Chave.gif"); telaPausa = carregaImagem("Pausado.gif"); telaInicial = carregaImagem("TelaInicial.gif"); telasCombate = new BufferedImage[2]; telasCombate[0] = carregaImagem("TelaCombate1.gif"); telasCombate[1] = carregaImagem("TelaCombate2.gif"); telaGameOver = carregaImagem("TelaGameOver.gif"); telaFinal = carregaImagem("TelaFinal.gif"); db = null; dbg = null; setFocusable(true); addKeyListener(this); requestFocus(); setIgnoreRepaint(true);
}
}
Quadro 9 – Construtor da classe PainelJogo

A classe PainelJogo possui os seguintes atributos: a imagem em que o jogo é desenhado e o contexto gráfico do painel; o tamanho dos blocos que formam o mapa; as listas em que as entidades são armazenadas; o objeto de Heroi; a matriz que servirá de base para a formação do mapa, a qual foi suprimida acima, mas será mostrada adiante; vetores com os nomes das imagens que serão usadas para representar as entidades; a fonte que será usada para o texto; variáveis i nteiras para

38

posicionamento; as telas apresentadas em momentos específicos; booleanos para controles diversos; e o índice das imagens usadas durante o combate.
O construtor de PainelJogo, após receber a largura e a altura passadas, determina os valores iniciais das variáveis, instancia os objetos e chama os métodos para que a fonte e as imagens sejam carregadas, para o mapa seja criado e para as entidades sejam distribuídas. Solicita-se o foco ao painel, adiciona-se o KeyListener, para que haja interação pelo teclado, e, por último, o método setIgnoreRepaint() é utilizado para não haja chamadas do método paint(), devido à renderização ativa, que será explicada adiante.
Os métodos de PainelJogo serão apresentados e explicados ao longo deste capítulo, em suas seções correspondentes.

3.2 Sprites

Cada entidade no jogo é representada por um sprite. Segundo Davison (2005, p.
270, tradução nossa), um sprite é ―um objeto gráfico móvel, que pode representar o jogador [...] ou pode acionado por código ‗inteligente‘ no jogo.‖ 12
Neste jogo, todos os sprites são representados por subclasses da classe Entidade.
Ao contrário da definição de Davison (2005), as entidades estáticas — classes
Objeto e Bloco — também são consideradas sprites e, portanto, também são subclasses de Entidade.
Todas as imagens utilizadas foram criadas com o programa de edição de imagens
Paint.NET.

12

―[...] a moving graphical object, which may represent the player […] or may be driven by ―intelligent‖ code in the game.‖

39

3.2.1 Entidades

A classe Entidade é uma especificação geral para os sprites. Seus atributos são: a imagem — ou imagens — que a representa; as coordenadas x e y para seu posicionamento; sua largura e altura; e o HP, do inglês health points (pontos de saúde), termo comumente usado em RPGs para se referir à ―vida‖ dos personagens.
O HP representa a energia dos personagens por meio de um número inteiro que decresce conforme eles sofrem danos. Há também um atributo que indica se a
Entidade está viva ou não. O HP é utilizado somente pelo herói e pelos inimigos.
O herói possui certa quantidade de imagens para ser representado dependendo de sua direção e de seu movimento. Todas as outras entidades, inclusive os inimigos, possuem apenas uma imagem. Os inimigos poderiam ter, assim como o herói, imagens variadas, entretanto, como uma forma de simplificar o jogo, eles permanecerão imóveis, necessitando assim de apenas uma imagem.
A classe Entidade tem métodos para que os objetos de suas subclasses sejam desenhados, movidos, para que testem colisões, decrementem seu HP, etc.
Há dois construtores nessa classe, um para entidades com apenas uma imagem e o outro, utilizado pelo herói, para várias imagens, como pode ser visto no Quadro 10.

40

public class Entidade { private BufferedImage imagem; private BufferedImage imagens[][]; private private private private private int int int int int

x; y; largura; altura; hp;

private boolean vivo; public Entidade(BufferedImage im,int x,int y,int larg,int alt){ this.x = x; this.y = y; imagem = im; largura = larg; altura = alt; vivo = true;
}
public Entidade(BufferedImage[][] imagens, int x, int y) { this.x = x; this.y = y; this.imagens = imagens; int ultimaIm = imagens[0].length-1; largura = imagens[0][ultimaIm].getWidth(); altura = imagens[0][ultimaIm].getHeight(); vivo = true
}
// Métodos
}
Quadro 10 – Classe Entidade

O segundo construtor recebe uma matriz de imagens do tipo BufferedImage. A largura e altura padrões da Entidade ficam determinadas como sendo as da última imagem da primeira linha, o que será mais bem explicado a seguir.

3.2.2 Herói

O herói do jogo, representado pela classe Heroi, possui entre seus atributos números inteiros que se referem à direção que ele está encarando, o qu adro de sua animação, sua velocidade e quantidade de passos dados. Além desses, há um

41

booleano que determina se o herói possui a chave usada no decorrer do jogo e outro que determina se o personagem está cansado . Ainda outro atributo, tempoAntigo, será tratado mais adiante.
A classe Heroi lida com aspectos relacionados ao movimento, animação e combate.
Seu construtor pode ser visto no Quadro 11. public Heroi(BufferedImage[][] imagens, int x, int y) { super(imagens, x, y); possuiChave = false; cansado = false; setHP(10); direcao = 0; quadro = imagens[0].length - 1; velocidade = 6; passos = 0;
}
Quadro 11 – Construtor da classe Heroi

São recebidas a matriz de imagens individuais e as coordenadas em que o personagem será primeiramente desenhado. Após isso, seu estado inicial é determinado. O herói começa imóvel, sem a chave, com um HP de valor 10 e velocidade igual a 6. Essa velocidade especifica que, quando o persona gem se mover, sua posição será atualizada de 6 em 6 pixels.
Os atributos direcao e quadro se referem à animação do personagem. A matriz recebida pelo construtor contém 12 imagens, distribuídas em 4 linhas e 3 colunas.
Conforme mostra a Figura 6, cada linha corresponde a uma direção: na primeira, o personagem está olhando para baixo; na segunda, para cima; na terceira, para a esquerda; e, na quarta, para a direita. Assim, cada coluna corresponde a um quadro da animação do herói, sendo que a última imagem de cada coluna representa o herói parado na direção correspondente. Devido a essa disposição, quando o herói é criado, seu quadro inicial é a última imagem da primeira coluna. Assim, para imagem inicial, o atributo direcao é igual a 0, enquanto quadro tem o valor 2.

42

Figura 6 – Matriz de imagens do herói

Como definido no Quadro 12, o herói sobrescreve o método desenha(), herdado de
Entidade, para ser desenhado. public void desenha(Graphics g) {
g.drawImage(getImagem(direcao, quadro), getX(), getY(), getLargura(), getAltura(), null);
}
Quadro 12 – Método desenha() da classe Heroi

O método getImagem(), de Entidade, recebe como argumentos os atributos direcao e quadro e retorna a imagem na posição requisitada da matriz.
Para que o personagem se mova, é usado o método testaDirecao(), no Quadro 13.

43

public void testaDirecao() { if (acima) { setDirecao(1); setY(getY() - vel);
}
if (abaixo) { setDirecao(0); setY(getY() + vel);
}
if (esq) { setDirecao(2); setX(getX() - vel);
}
if (dir) { setDirecao(3); setX(getX() + vel);
}
if (passos >= 50) { cansado = true;
}
else { cansado = false;
}
}
Quadro 13 – Método testaDirecao()

Cada direção é testada, e, depois de ter sido atribuído o valor apropriado a direcao, as coordenadas do personagem são incrementadas ou decrementadas, dependendo de sua direção. Enquanto o personagem anda, a variável passos é incrementada e, caso seu valor chegue a 50, cansado passa a ser verdade. Isso é utilizado durante o combate. A animação do herói é realizada com método anda(), apresentado no Quadro 14, e terminada com o método para(). Entretanto, para que seja mostrada da forma adequada, a animação depende do atributo tempoAntigo. public void anda() { if ((System.currentTimeMillis() - tempoAntigo) > 100) { quadro = (quadro + 1) % 2; passos++; tempoAntigo = System.currentTimeMillis();
}
}
Quadro 14 – Método anda()

44

Uma vez que as imagens usadas para o movimento do herói são as duas primeiras de cada linha da matriz, a animação é feita pela circulação entre essas imagens.
Isso pode ser conseguido da seguinte maneira: soma -se 1 ao valor do quadro atual; após isso, é obtido o resto da divisão do valor resultante por 2, dado que são duas imagens. Dessa maneira, o valor de quadro será sempre 0 ou 1.
Depois de realizada a mudança de quadro, atribuí-se a tempoAntigo o tempo atual do sistema. Essa variável é usada pelo método anda() para que seja controlada a velocidade da animação. Sem ela, o personagem seria animado com rapidez demasiada. Nesse método, passos é incrementada. Como pode ser visto no Quadro
15, também se usa tempoAntigo no método para(). public void para() { if ( (System.currentTimeMillis() - tempoAntigo) > 100 ) { quadro = 2; if (passos > 0) { passos--; }
}
}
Quadro 15 – Método para()

O método para() determina que quadro seja igual a 2, para que seja usada uma das imagens com o herói parado. Porém, para que isso aconteça, a diferença entre o tempo atual do sistema e tempoAntigo deverá ser maior que 100 milissegundos. Isso é necessário, pois a chamada do método para() depois do método anda() em atualiza() acontece de forma rápida demais, fazendo quadro receber o valor 2 mesmo enquanto o personagem anda. A variável passos é decrementada enquanto tiver valor maior ou igual a zero.
O ataque do herói aos inimigos é realizado por ataca(), visto no Quadro 16.

45

public void ataca(Inimigo i) { if (cansado) {
i.retiraHP(1);
} else {
i.retiraHP(2);
}
}
Quadro 16 – Método ataca()

Caso o estado de cansado seja verdadeiro, o herói causará danos inferiores aos inimigos. 3.2.3 Inimigos

Como dito anteriormente, os inimigos permanecerão imóveis, necessitando apenas de uma imagem para representá-los. A classe pode ser vista no Quadro 17. public class Inimigo extends Entidade { public Inimigo(BufferedImage im,int x,int y,int larg, int alt) { super(im, x, y, larg, alt); setHP(6); } public void verificaVida() { if (getHP() = 0) deslocX = 0; if (deslocX = 0 deslocY = 0; if (deslocY