Game design - Experimentar novos cenários

Postado: na M.Cassab
Estado: falta muito para as 17h30 ?
Escutando: Deep Purple - Highway Star

Atribuição: Uso Não-Comercial

O conteúdo desta página foi baseado nos tutoriais contidos no site Tile based games, autorizado sob a licença Creative Commons e não pode ser utilizado para fins comerciais.

A tradução e adaptação dos textos, códigos ActionScripts e todas as outras obras originais criadas por Tonypa foram autorizada é são de propriedade dele.

Attribution: Noncommercial

The content on this page was based tutorials in the site Tile based games, licensed under a Creative Commons License and you may not use this work for commercial purposes.

The translation and adaptation of text, ActionScripts codes and all other original works created by Tonypa were authorized is are his property.

No conteúdo anterior (Criando cenário), você viu que as propriedades de um objeto são declarados pela seguinte função:

game.Tile0= function () {};
game.Tile0.prototype.walkable=true;
game.Tile0.prototype.frame=1;

Isto permite criar várias funções diferentes, declarando propriedades específicas para cada tipo de objeto em jogo.

No exemplo acima, declaramos que o objeto permite que o personagem caminhe por cima (walkable=true) e que sua imagem está no frame 1.

Anteriormente, declaramos que a parede, um objeto que obstrui o caminho do personagem, possui usa imagem no frame 2.

Digamos que você planeja usar uma montanha no cenário. Para isso, criou um movieClip com 50 frames, contendo todas as imagens que compõe o jogo.

Como a montanha também obstrui a movimentação do personagem, basta declarar essa informação, mais o número do frame onde a imagem está localizada... digamos que seja no quadro 20.

game.Tile20= function () {};
game.Tile20.prototype.walkable=false;
game.Tile20.prototype.frame=20;

Sendo assim, traçamos um padrão para declarar as propriedades de cada objeto no cenário. Basta utilizar o fantástico recurso "CopyCola" (também conhecido como CTRL+C e CTRL+V) e trocar as propriedades desejada.

Porém, isso não é algo muito prático de fazer. Veja o exemplo abaixo:

01: //propriedades da parede
02: game.Tile0= function () {};
03: game.Tile0.prototype.walkable=false;
04: game.Tile0.prototype.frame=2;
05:
06: //propriedades da montanha
07: game.Tile20= function () {};
09: game.Tile20.prototype.walkable=false;
10: game.Tile20.prototype.frame=20;

Olhe com atenção e notará que as linhas declaradas são exatamente iguais, mudando apenas o valor da linha 4 e da linha 10.

Do ponto de vista da programação, isso é um desperdício de processamento, pois estamos usando umas 6 linhas, sendo quase a metade está fazendo o mesmo processo repetidamente.

Sendo assim, podemos verificar o que é padrão nos objetos e resumir, deixando para declarar apenas aquilo que é individual de cada elemento e o que for comum a todos ficará agrupado de alguma forma.

Aqui as opiniões podem se divergir, pois cada um deve ter um método preferencial. Uma das opções praticadas poderia ser agrupar as propriedades comuns em um novo objeto (AS.1) ou em uma classe (AS.2).

Como já comentei anteriormente, para facilitar a vida de todos (e a minha também) vou optar por agrupar por objeto.

Primeiro, vamos mudar um pouco a função, apenas alterando o nome do objeto dentro de "game":

game.TileClass = function () {};
game.TileClass.prototype.walkable=false;
game.TileClass.prototype.frame=2;

Criamos uma função dentro do objeto TileClass que transmitirá exatamente as propriedades que são comuns aos demais objetos do cenário.

A lógica é bem simples, dois corpos não ocupam o mesmo espaço no mesmo local ao mesmo tempo. Logo, todo objeto obstrui o caminho do personagem (walkable=false).

No caso da imagem, a lógica é mais fácil ainda. Se você está jogando Mário e está nas fases da Vila Cogumelo, a maior parte do chão não é grama?

Quando você está andando com o Link dentro de um castelo, a maior parte do chão não é piso?

Logo, basta definir qual de imagem o padrão por fase. Assim, o cenário será montado basicamente pela imagem padrão, alterando apenas as excessões (lembra do exemplo das árvores?).

Agora, vamos utilizar um conceito que os programadores chamam de herdar.

Temos um objeto padrão. O que vamos fazer é que os objetos criados herdem as propriedades padrão, alterando apenas as características específicas.

Vamos ao método Teletubies (também conhecido como passo a passo). A primeira coisa é declarar uma função em nosso objeto, como fizemos até agora.

game.Tile0 = function () {};

Depois, vamos criar um objeto chamado __proto__ para carregar as propriedades padrões, que estão dentro TileClass.

game.Tile0.prototype.__proto__ = game.TileClass.prototype;

Isso carregará as propriedades que declaramos lá em cima. Se o objeto carregado possuísse as mesmas propriedades, terminaríamos o código aqui. Em vez de digitarmos 6 linhas, resolvemos tudo com apenas 5... faça as contas de quantas linhas economizaria em um código com 80 elementos, lembrando de que um jogo normal tem bem mais do que isso.

Por exemplo, ao criar um cenário contendo o chão (frame 1), a parede (frame 2), uma coluna (frame 3) e um piso liso (frame 4), as funções seriam declaradas assim:

//objeto padrão
game.TileClass = function () {};
game.TileClass.prototype.walkable=false;
game.TileClass.prototype.frame=2;

//propriedades do chão
game.Tile0 = function () {};
game.Tile0.prototype.__proto__ = game.TileClass.prototype;
game.Tile0.prototype.walkable=true;
game.Tile0.prototype.frame=1;

//propriedades da parede
game.Tile1 = function () {};
game.Tile1.prototype.__proto__ = game.TileClass.prototype;

//propriedades da coluna
game.Tile2 = function () {};
game.Tile2.prototype.__proto__ = game.TileClass.prototype;
game.Tile2.prototype.frame=3;

//propriedades do piso
game.Tile2 = function () {};
game.Tile2.prototype.__proto__ = game.TileClass.prototype;
game.Tile0.prototype.walkable=true;
game.Tile2.prototype.frame=4;

Note que, para a coluna, foi declarado apenas o frame em que a imagem se encontra e nem isso foi preciso informar para a parede.

No caso do chão e do piso, eles herdaram as propriedades padrões, mas como declaramos novamente, as antigas foram substituídas pelas novas.

Dessa forma, você economizará mais tempo ao digitar o código e dependendo de menos processamento de máquina.

Se quiser, volte ao índice para ver a lista completa do conteúdo.

Próximo assunto:
Inserindo um personagem