Crie seu propio jogo Java em poucas palavras...

por Coffman32 Dom 26 Fev 2012, 11:15 am

Plataforma de jogo básico

Desde que comecei a implementar J-Rio há um ano atrás, eu pensei em escrever um capítulo tutorial sobre os conceitos básicos de jogos de plataforma, mas até hoje eu nunca tive o tempo para fazê-lo. Mas, como muitos e-mails que recebi no ano passado incluiu questões sobre técnicas de J-rio e jogos de plataforma em geral, eu acho que esse capítulo poderia ser muito útil para alguns de vocês. Além disso, como eu não vou dar o código fonte do J-rio longe, as pessoas que me pediram o código-fonte ter com este capítulo a chance de dar uma olhada nos bastidores da minha implementação J-rio, porque o applet exemplo, vamos implementar neste capítulo é uma espécie de uma versão lite do J-rio. Bem, ok, espero que eu possa ajudá-lo um pouco com este capítulo e o nosso jogo de plataforma funcione bem, mas não vou falar sobre eles em detalhes mais. Você também deve baixar o código fonte do applet exemplo agora e trabalhar o código por enquanto você lê este tutorial. Este capítulo não vai lhe dar os detalhes de cada linha de código, mas vou me concentrar em três grandes problemas. Primeiro, vamos dar uma olhada no projeto de classe que escolhi para executar o jogo, em segundo lugar, vamos falar sobre os métodos e atributos da classe jogador onde vou me concentrar em coisas que estão relacionadas com o movimento de o jogador e por último mas não menos importante, vamos falar sobre a estrutura e função do nível de classe.
O projeto de classe do nosso jogo de plataforma

Quanto mais complexo um jogo (ou qualquer outro programa) recebe, mais importante torna-se um design de classe boa para permitir ao programador adicionar novas funções para o jogo facilmente. No nosso caso (ou no meu caso quando eu implementei J-rio), queremos ter a possibilidade de se adicionar novos inimigos e elementos de nível para o nosso jogo já lançado sem grandes alterações do código e ele também deve ser fácil de escrever novos níveis para o jogo. Eu acho que eu consegui esses problemas muito bem com o design de classe J-rio e por isso vou usá-lo no nosso caso também, embora não poderia ser mais simples, mas talvez não tão poderosas soluções (isto não significa que eu encontrei a única solução correta e pode não haver outros melhores do que o meu!). Por exemplo, é realmente fácil de adicionar novos níveis de J-Rio, basta dar uma olhada no editor de níveis J-rio.
. Se você baixou o código fonte deste capítulo e extraiu o zip * - arquivo que você vai encontrar as seguintes classes (Nota: o que se segue agora é apenas uma visão geral, muitos detalhes seguirão mais tarde):
A classe principal

Antes de toda a classe principal implementa o applet em si, o que significa que o init (), start (), stop (), destroy () e paint (Graphics g) - métodos e inclui a linha principal do jogo dentro do método run () de o Runnable interface. Ele também possui métodos para lidar com eventos do leitor (keyDown. ..) e dois atributos: um exemplo do jogador de classe e uma instância de uma classe filho do nível de classe (no nosso caso só LevelOne a classe). Em nossa run () - loop que gerir o jogo completo, o que significa chamar métodos para desenhar jogador e nível, para rolar o nível eo jogador se necessário, para testar colisões entre jogadores e elementos de nível e assim por diante. Por favor, note que a classe principal não implementar um desses métodos por conta própria, mas chama métodos no Player classes e Level.
O jogador de classe

Essa classe implementa o comportamento e os atributos do objeto jogador. Isto significa que mantém a informação sobre a posição do jogador no jogo, armazena as imagens jogador utilizados para animar o jogador e também é responsável para controlar o movimento do jogador (o que é explicado em detalhe mais tarde).
O LevelElement classe

Um jogo como J-rio consiste em muitos tipos diferentes de elementos de nível que têm atributos diferentes, comportamento e causar diferentes interações com o jogador. Existem, por exemplo, as "pedras de interrogação" que têm pelo menos dois estados diferentes, que são "atingidos" e "ainda não bateu", plataformas móveis e do elemento de nível mais simples, o elemento terra, que não tem um comportamento especial em tudo. E para este capítulo, vamos nos concentrar neste elemento muito simples implementado no chão da classe. Mas apesar dessas diferenças entre os diferentes tipos de elementos de nível que eles têm um pouco de comportamento comum, que é implementado no LevelElement classe, que é a classe básica para cada elemento de nível no nosso jogo de plataforma. Este bahaviour básico contém a posição do elemento de nível, um identificador exclusivo inteiro, um boolean variável "insight" que é usado para rolar e pintando o elemento de nível (veja o capítulo sobre a rolagem para mais detalhes), bem como uma Imagem - objeto para armazenar o GIF elemento de nível. Cada elemento do nível em J-rio estende o LevelElement classe e da estrutura de dados interna do Nível de classe contém apenas as instâncias das classes filho do LevelElement classe que são identificados pelo seu ID único inteiro.
The Ground classe

Esta classe representa exatamente uma classe como filho do LevelElement classe. Mas este tipo de LevelElement não tem um comportamento especial para que ele só chama o construtor da super em seu próprio construtor.
O nível de classe

O nível de classe abstrata é talvez a classe mais importante e complexa do jogo. A classe contém um método para traduzir a representação de string do nível (dado na LevelOne classe) para a representação de dados interno do nível que é uma matriz bidimensional de LevelElement - instâncias. Ele também possui métodos utilizados para controle de colisão entre o jogador e os elementos de nível. O que a representação interna parece, como ele é criado e como funciona o controle de colisão será explicado mais tarde neste capítulo.
A LevelOne classe

Esta classe contém nível definições específicas em particular a definição do nível de si consistindo de 25 strings representando 25 linhas de nível. A cor do fundo pode também ser manipulado usando o initializeColorArray () método do LevelOne classe.
Die Klasse C_Jump

Para fazer alterações do tamanho do jogo, tamanho levelelement ... mais fácil todas as constantes usadas no jogo são escritas em uma classe especial, em nosso caso no C_jump classe.
Como as classes de trabalhar em conjunto

Como eu já disse que a classe principal tem uma instância do Jogador - objeto, bem como uma instância de uma classe filha do nível de classe. Principal é também responsável pela gestão do jogo completo. O jogador de classe é usada para armazenar os atributos dos jogadores específicos e mover-se, desenhar, animar e percorrer o jogador corretamente, enquanto o nível de classe é usada para manter a representação interna do nível, para desenhar e para rolar a nível, bem como para testar de colisões entre o jogador e elementos de nível. Um nível é implementado por uma classe filho do nível de classe, no nosso caso pela LevelOne classe. Quando construímos uma instância da classe LevelOne, a representação de string do nível é traduzido para a matriz bidimensional de LevelElement - objetos, armazenados na classe pai de Nível LevelOne. Cada elemento de nível é uma classe filha de LevelElement, no nosso jogo de plataforma não é apenas terra da classe.
Espero que eu podia tornar claro agora, por que eu projetei as classes como eu fiz, se existem problemas deixados talvez você deveria dar uma olhada no capítulo editor de níveis, onde eu usei bastante o design do mesmo, mas talvez um pouco mais simples. Agora, vamos dar uma olhada no jogador classes e Level.
Detalhes do jogador de classe

O controle de animação e movimento do jogador é muito importante para o nosso jogo. Mas, para controlar o movimento do jogador em um jogo de plataforma não é tão simples como pode parecer, porque temos de tomar cuidado para que o nosso jogador tem que parar de andar ou saltar se ele atinge um muro, ele tem que cair de qualquer plataforma Se o fim é alcançado, tem de parar caia se aterra em uma plataforma e assim por diante. É por isso que eu vou explicar meu solotion para esses problemas na próxima parte deste capítulo.
Primeiro de tudo você tem que reconhecer que neste jogo de plataforma do movimento do jogador é controlado de forma indireta usando bandeiras booleanos. Em nosso jogador de classe / objeto do teclado de entrada do jogador humano e os resultados do controle de colisões em nível de classe só configurar valores booleanos de quatro bandeiras do movimento e não causam qualquer movimento do jogador por conta própria (o que significa que não fazer alterar o x de posições y). O run () - método da classe principal chama um método chamado playerMove () de nossa classe de jogador que leva agora o jogador de acordo com os valores das bandeiras do movimento. Vamos dar uma olhada mais de perto essas opções:
As quatro bandeiras do movimento e seu controle

Nosso objeto jogador como quatro, bandeiras do movimento, em parte, independentes:

walking_left: mostra se o jogador deve mover para a esquerda e é controlado principalmente pela entrada de teclado do jogador humano, portanto, seu valor é definido como verdadeiro se a chave de seta para a esquerda é pressionado e é definida como false se a tecla é liberada. Mas a bandeira também é influenciada pelo controle do nível de colisão, becaues nosso jogador tem que parar o movimento se atinge a parede na sua esquerda.

walking_right: o mesmo que a bandeira walking_left, só na outra direção (nenhuma surpresa eu acho ;-)

salto: este sinalizador indica que o nosso jogador tem que saltar. Mas as coisas são um pouco mais complicado aqui, porque por um lado, esse movimento é controlado por dois controladores: o jogador humano pressionar ou liberar o 'a' - chave eo controle de colisão do nível de classe (por exemplo, se o jogador franja sua cabeça contra a parede). Por outro lado, o jogador pode não ser capaz de saltar mais uma vez se ele já está pulando ou ele não pode saltar se ele está caindo e assim por diante, detalhes sobre esses problemas e sua solução seguir mais tarde.

queda: Esta bandeira só é controlada pelo controle de colisão do nível de classe (definido como verdadeiro se o jogador deixa uma plataforma ...). Aqui temos alguns truques também para parar o jogador direito sobre a superfície de uma nova plataforma (ou pelo menos para corrigir erros cometidos aqui) e assim por diante, os detalhes mais tarde.

O walking_left e walking_right, bem como as bandeiras de queda e saltar pode não ser verdade, ao mesmo tempo. Mas cair / pulando e walking_left / walking_right são completamente independentes um do outro para que eles possam ser verdadeiras ao mesmo tempo porque o nosso jogador deve ter a oportunidade de saltar para a esquerda ou a cair para o lado direito. As bandeiras do movimento são controlados a partir de dois lados diferentes: a entrada de teclado do jogador humano eo controle de colisão da classe nível, vamos discutir mais adiante neste capítulo. Mas agora vamos dar uma olhada no set - métodos para nossas bandeiras booleanos e o playerMove () - método que faz o trabalho de movimento para nós.

O conjunto - métodos para os valores walking_left e walking_right são muito simples, aqui está o código.

// Método define o valor de walking_left
public void playerWalkLeft(boolean value)
{

walking_left = value;

}

// Método define o valor de walking_right
public void playerWalkRight(boolean value)
{

walking_right = value;

}

No caso da bandeira pulando está ficando um pouco mais complicado porque temos que cuidar de mais algumas coisas, quando vamos definir o valor. Primeiro de tudo, o jogador só pode saltar, se ele não estiver caindo, o que significa que o valor de queda é falso e se o jogador não estiver pulando para o valor de outro jump_lock bandeira tem que ser falso também. Só mais uma coisa, é que nós vamos usar um contador para jump_counter contoll o comprimento do salto. Este contador deve ser reposto a 0 quando o jogador inicia um novo salto, o que significa que os valores das bandeiras são: salto = false, jump_lock = false eo valor é verdadeiro. Você vai encontrar alguns detalhes sobre a jump_counter mais adiante neste capítulo. Aqui vem o código:

// Método para definir o valor da bandeira saltando
public void playerJump(boolean value)
{

// redefinir jump_counter se o jogador inicia um novo salto
if(!jumping && !jump_lock && value)
{
jump_counter = 0; }

// o jogador só pode saltar, se ele não está já em queda
if(falling)
{
jumping = false; }
else
{
jumping = value; }

}

A última das quatro bandeiras é a bandeira cair. Com este indicador, é importante que se cair é definido como falso o que significa que as terras do jogador em uma plataforma, nós temos que acabar com um salto (jump_lock e saltar deve ser definida para false). Mais uma coisa é, que em alguns casos, o jogador não param de se mover direito sobre a superfície da plataforma, mas um pouco mais para baixo de modo que parece ser o jogador poderia estar de pé direito na plataforma. Então nós temos que corrigir os erros que acontecem aqui. Nós também temos que tomar cuidado para que o jogador não pode pular e cair ao mesmo tempo, mas isso é garantido em outro lugar (no playerMove método ()).

// Método para definir o valor cair
public void playerFall(boolean value)
{

// queremos parar de cair
if(!value)
{
// restaurar o salto para tornar possível novo salto
if(jump_lock)
{
jump_lock = false;
jumping = false; }

// we have to correct the player position so that the player always,
/ / fica sobre a superfície de uma plataforma. Neste caso, a parte inferior
/ / Posição do modulo jogador a altura de um elemento de nível
/ / É igual a 0. Se este não for o caso, o jogador é movido para cima
/ / Até que este é o caso e que o jogador fica na superfície!
while(y_pos_down%C_Jump.level_element_height != 0)
{
y_pos_down --;
y_pos_up--; }
}

// definir o valor de queda
falling = value;

}

Movimento e animação do jogador

Agora, como nós sabemos sobre as quatro bandeiras do movimento e como eles são definidos, vamos dar uma olhada no método que realmente move o jogador de acordo com os valores dos flags. Isto acontece no playerMove () - método, mas antes vamos dar uma olhada no código fonte do método que eu tenho que dizer alguma coisa sobre duas variáveis eu vou usar no método:

step_counter e picture_counter: Essas variáveis só são necessários para animar o jogador. Quando o jogador fez 15 "passos" que querem mudar a imagem do jogador e isso significa que temos de alterar o valor de picture_counter que conta a pintura () - método que imagem do jogador deve ser pintado na tela.

jump_counter: Este contador é usado para determinar o quão longe o jogador pode saltar e quando um salto de que o jogador pare. Se o valor jump_counter atinge um certo valor máximo, o valor da bandeira saltar é definido como falso.

// Este método move o jogador de acordo com os valores dos sinalizadores de circulação
public void playerMove()
{

// andar para esquerda retorna verdadeiro
if(walking_left)
{
// Alterar x - posição do jogador
x_pos_left -= walk_x_speed;
x_pos_right -= walk_x_speed;

// mudar a posição de jogo (importante para a rolagem)
game_x_position -= walk_x_speed;

// mudar a imagem do jogador após 15 passos
if (step_counter%15 == 0)
{
// alterar o valor do contador de imagem
picture_counter ++;

// redefinir contador se o valor é 2 (existem apenas 2 fotos)
if(picture_counter == 2)
{
picture_counter = 0; }

// redefinir contador de passos
step_counter = 1;
}
// aumentar o valor do contador de passos
else
{
step_counter ++; }

// dizer se o jogador olha para a esquerda (somente importante para a animação)
look_left = true;
}
// andar para direita é verdadeiro
else if(walking_right)
{
...... }

// Valor do salto é verdade
if(jumping)
{
// Esta variável existe para evitar que o jogador pode saltar mais uma vez
// if he's already jumping
jump_lock = true;

// Certifique-se que o valor de queda é falsa
// controle define o valor cair para verdadeiro mesmo se o jogador está saltando
falling = false;

// jump_counter ainda inferior a 30
if(jump_counter < 30)
{
// jogador salta por a velocidade de 2
y_pos_up -= jump_y_speed;
y_pos_down -= jump_y_speed;
jump_counter ++; }
// Se o valor do jump_counter é menor do que 30 mas maior do que
// 40 salto pela velocidade de 1
else if (jump_counter < 40)
{
y_pos_up -= jump_y_speed2;
y_pos_down -= jump_y_speed2;
jump_counter++; }
// Se o valor da jump_counter é maior do que 40, o jogador não pode
// saltar ainda mais, para definir o valor de saltar para false
else
{
jumping = false; }
}

// se o jogador está caindo jogador movimento para baixo
if (decrescente)
{
y_pos_up += fall_y_speed;
y_pos_down += fall_y_speed; }

}

Espero que eu poderia mostrar-lhe agora as partes mais importantes e de novo a rolagem classe jogador, e pintura do jogador não deve ser problema anymore. Mas acho que você deve realmente dar uma olhada no código fonte da classe para entender tudo, porque essa classe não é tão simples. Bem, ok, vamos começar com uma classe ainda mais complexo, o nível de classe
Estrutura e função do nível de classe

Nesta última parte do tutorial falaremos sobre o nível de classe e da LevelOne classes relacionadas e LevelElement. Primeiro de tudo vamos dar uma olhada na "linguagem de definição" de um nível de jogo de plataforma e vamos ver como esta linguagem de definição é traduzido para a representação de dados interna do nível. Essas são principalmente idéias que eu já introduzidas no capítulo sobre o editor de níveis, se você tiver quaisquer problemas, por favor leia este capítulo primeiro. Depois eu vou te mostrar alguns detalhes da colisão entre elementos de controle de nível e do jogador. Eu não vou falar sobre coisas como rolagem e pintura porque essas coisas devem ser claras agora (pelo menos assim espero).

Linguagem de definição e estrutura de dados interna de um nível

Um dos principais objetivos de nosso projeto de classe era permitir ourselfs para escrever novos níveis para o nosso jogo facilmente. Essa é a razão pela qual nós definimos os nossos níveis com uma "linguagem de definição de" certo que pode ser facilmente usado por seres humanos e então traduzir esta definição nível em uma nova estrutura de dados que pode ser usado pelo computador. Em nossa linguagem de design um nível consiste de 25 linhas representadas como 25 cordas. O comprimento das referidas cordas é variável, mas todos eles têm de ser do mesmo comprimento. Cada elemento do nível que queremos usar em nosso nível é implementado como uma classe filha de LevelElement, tem um identificador de caráter único e em cada posição onde este personagem aparece em nossas cordas definição do nível deste elemento de nível será gerada na estrutura de dados interna da nível. O analisador de nível de classe (método initializeLevel ()) tem que ser capaz de traduzir essas definições cordas na estrutura de dados interna do nosso nível. Esta estrutura de dados interna consiste de uma matriz bidimensional com ponteiros nulos em locais onde nenhum elemento de nível existe no nosso nível e instâncias de classes filho do LevelElement classe onde um elemento de nível existente no nível. Esta ideia é explicado em mais pormenor na aboue capítulo, o nível editor. Ok, antes de chegar ao controle de colisão, aqui vem o código fonte:

A definição de nível pode ser encontrada na LevelOne classe. Essa classe é usada para definir todas as coisas de nível específicos, como a cor de fundo, o próprio nível e assim por diante, onde a funcionalidade real do nível é implementado nos métodos herdados do nível da classe pai. Aí vem um nível na linguagem de definição de nível:

/**
Legend:
":": represents a position in the level where no element should be generated
"g": represents a position in the level where a ground element should be generated
*/

// Definição de String do nível
// linhas 1 - 10 estão faltando, porque não contêm todos os dados importantes
public static final String row11 = "::::::::::::::::::::::::::::::::::::::::g::";
public static final String row12 = ":::::::::::::::::::::::::::::::::::::::::::";
public static final String row13 = ":::::::::::::::::::::::::::::::::::::::::::";
public static final String row14 = "::::::::::::::::::::::::::::::::::::g::::::";
public static final String row15 = ":::::::::::::::::::::::::::::::::::::::::::";
public static final String row16 = ":::::::::::::::::::::::::::::::::::::::::::";
public static final String row17 = "::::::::::::gggg::::::::::::::::g::::::::::";
public static final String row18 = ":::::::::::::::::::::::::::::::::::::::::::";
public static final String row19 = ":::::::::::::::::::::::gggg::::::::::::::::";
public static final String row20 = ":::::::::::::::::::::::::::::::::::::::::::";
public static final String row21 = "::::::gggg:::::::::::::::::::::::::::::::::";
public static final String row22 = ":::::::::::::::::::::::::::::::::::::::::::";
public static final String row23 = ":::::::::::::::::::::::::::::::::::::::::::";
public static final String row24 = ":::::::::::::::::::::::::::::::::::::::::::";
public static final String row25 = "ggggggggggggggggggggggggggggggggggggggggggg";

Como você pode ver aqui é muito simples de definir novos níveis (veja a versão de editor nível de J-rio também). Mas como isso é simples definição traduzida para a representação interna de dados informático? Isso é implementado no initializeLevel método (String [] definições) do nível de classe. Esse método analisa as cordas de definição de nível e gera uma matriz bidimensional de elementos nível deles. Esta matriz é utilizada principalmente para o controle de colisão. Posteriormente todos os ponteiros para levelelements também são armazenados em um array de uma dimensão para fazer rolagem e pintura do nível mais eficiente.

// Método para analisar as seqüências de definição de nível e gerar matrizes 2D e 1D.
public void initializeLevel(String [] definitions)
{

// Inicializar matriz de colisão
collision_array = new LevelElement [C_Jump.number_of_level_lines] [definitions[0].length()];

// Inicializar algumas informações nível: nível comprimento e borda esquerda e direita
level_length = definitions[0].length() * C_Jump.level_element_width;
left_level_border = 0;
right_level_border = C_Jump.applet_width;

// Contador para contar o número de elementos de nível no nível, importante
// para a abertura do array 1D
int elements_counter = 0;

// Para todas as strings de definição de nível
for(int i=0; i {
// gerar uma matriz de char da string atual nível de definição
char [] definition_line = definitions[i].toCharArray();

// para todos os elementos do array de char fazer:
for(int j=0; j {
// Traduzir para os chars elementos de nível
if(definition_line[j] == ':')
{
collision_array[i][j] = null; }
// Gerar um elemento Ground
else if(definition_line[j] == 'g')
{
// Posição na definição de cadeia (i, j): Importante
// é traduzida para a posição de pixel de betão
Ground element = new Ground(j*C_Jump.level_element_width,
i*C_Jump.level_element_height, ground, parent, C_Jump.ground_id);
// Loja elemento na matriz de colisão
collision_array[i][j] = element;

// aumentar contador elemento
elements_counter ++; }
}
}

/ / Copiar ponteiros levelelement para array 1D
/ / Código da falta, porque nada de especial acontece

}

Teste para colisões entre jogadores e elementos de nível

Vamos chegar ao último tópico, e talvez mais abrangente deste capítulo. Todas as coisas que fizemos e falamos antes são importantes para o controle de colisão do jogo porque o controle de colisão tem bastante para a com o controle do movimento e da representação de dados interna do jogo.
Bem, a idéia é a seguinte: A única coisa que temos que fazer, quando queremos testar se os jogadores colide com qualquer elemento de nível é determinar a posição do jogador no conjunto de nível em 2D, o que significa que a linha de jogadores e coluna e teste, se houver um elemento de nível (o que significa que não um ponteiro nulo) ou se não houver nenhum elemento ist (= ponteiro nulo). Se encontrarmos um levelelement na posição de jogadores, temos que fazer algo com as bandeiras do movimento do jogador, no nosso caso temos que defini-las como false. Como você pode lembrar, temos quatro bandeiras do movimento por isso temos de testar por quatro colisões possíveis: colisão até (importante para saltar), colisão para baixo (importante para a queda), esquerda e direita colisão colisão. Por isso eu implementei alguns métodos. Os testForPlayerCollisions () método é usado para gerenciar o controle de colisão e decidir o que fazer quando uma colisão entre um certo elemento de nível eo jogador ocorre. Há também quatro métodos especializados (testCollisionUp,-Down, ...) que são usados para fazer uma pesquisa dentro da matriz 2D se um elemento de nível existe a uma posição do jogador dada ou não. Ok, aqui vem o código fonte dos testForPlayerCollisions método (o jogador jogador), bem como para o método testCollisionDown (como um exemplo para um desses métodos que o teste para a existência de um elemento de nível numa posição dada jogador e devolver este elemento para o chamando o método).

// testa método para as colisões entre jogadores e elementos de nível
public void testForPlayerCollisions(Player player)
{

// obter alguns jogadores específicos valores de posição
int player_game_pos = player.getGameXPosition();
int player_down_pos = player.getYPosDown();
int player_up_pos = player.getYPosUp();

int player_left = player_game_pos - (C_Jump.player_image_width/2);
int player_right = player_game_pos + (C_Jump.player_image_width/2);

// Teste de colisão para baixo
LevelElement down_element = testCollisionDown(player_game_pos, player_down_pos);

// Se houver um elemento abaixo do jogador, o jogador não cai
if(down_element != null)
{
player.playerFall(false); }
// se nulo é retornado o jogador está caindo
else
{
player.playerFall(true); }

// Teste de colisão até
LevelElement upper_element = testCollisionUp(player_game_pos, player_up_pos);

// parar de saltar se houver um elemento
if(upper_element != null)
{
player.playerJump(false); }

// Teste para colisões no lado esquerdo do jogador
LevelElement left_element = testCollisionLeft(player_left, player_down_pos);

// parar o movimento do jogador para a esquerda
if(left_element != null)
{
player.playerWalkLeft(false); }

// Teste para colisões no lado direito do jogador
LevelElement right_element = testCollisionRight(player_right, player_down_pos);

// interromper o movimento do jogador para a direita
if(right_element != null)
{
player.playerWalkRight(false); }

}

É isso aí!

Bem, aqui eu gostaria de terminar este capítulo e espero que eu possa ajudá-lo um pouco. Eu sei que este capítulo não é tão simples como alguns outros capítulos deste tutorial (não era nem fácil para mim escrever, nem fácil para você entender, eu acho), mas como o tópico não é tão simples isso não é tão grande surpresa. Também eu gostaria muito de ouvir o que era útil eo que não era com este capítulo, porque talvez eu deva explicar algumas coisas com mais detalhes ou assim. Por favor, escreva-me um e-mail se você usou este capítulo e me diga o que era útil e que era muito confuso (a palavra meu professor está sempre usando então eu queria usá-lo também uma vez em minha vida;-)! Pois bem, como sempre, você pode baixar o código fonte deste capítulo e você pode dar uma olhada na applet exemplo que acabamos de implementado, mas você pode jogar J-Rio, bem como, porque é "quase" o mesmo. Boa sorte com a implementação de seus próprios jogos de plataforma!

Sourcecode download