Posts Tagged ‘Tile’

Papervision MovieMaterial

maio 4, 2009

moviematerial

Clique na imagem para testar

Olá pessoal , para dar continuidade ao nosso estudo sobre papervision, hoje vamos falar sobre mais um tipo de material que podemos utilizar nos nosso objetos primitivos a textura MovieMaterial. Antes de começamos a falar sobre esse material vamos falar sobre um problema que ocorria com a classe MovieAssetMaterial.

Quando aprendemos sobre MovieAssetMaterial, passávamos uma string como parâmetro e importávamos de nossa biblioteca um movieclip onde o valor da propriedade linkage era igual da string referida. Mas a classe MovieAssetMaterial não aceita importar um movieclip que tenha come base uma classe que necessite de um parâmetro.

A classe MovieMaterial utiliza como parâmetro a instanciação de um movielip ao invés de uma string referindo sua propriedade linkage, com isso seu movieclip padrão não necessariamente precisa estar na bibliote, você pode trabalhar com um movieclip já instanciado, assim você pode utilizar o método gotoAndStop para indicar outro frame antes de ter instanciado ele como material..Outra vantagem é a possibilidade de utilizar um movieclip da biblioteca que tenha como base uma classe que exija parâmetro.

Construtor

Para criarmos um MovieMaterial devemos instanciar um objeto do tipo MovieMaterial.
Nosso único parâmetro obrigatório é um do tipo DisplayObject que é a referencia de nossa textura.

var  material:MovieMaterial =  new MovieMaterial(movieAsset);

movieAsset (DisplayObject): Referencia de um movieclip existente carregado na memória ou no stage.
Transparent (Boolean): Define se a textura possuirá transparência. [opcional]
Animated (Boolean): Define se o movieclip sera animado [opcional]

Tutorial

Neste tutorial eu quis brincar um pouco e mais uma vez dou uma demonstração de tile system com papervison, mas desta vez vamos ter uma classe que se comportará como movieclip aonde receberá como parâmetro um número que definirá qual vetor vai utilizar para criar o cenário, depois utilizaremos como material nosso cenário, A parte relacionada a papervision não terá mistério nenhum pois estarei usando a estrutura do tutorial anterior relacionado a materiais.

Arquivos

Neste tutorial trabalharemos com os seguintes arquivos:
1- MovieMaterial.fla
2- main.as
3- faceField.as: Classe que criará um cenário tile system para se comportar como material

MovieMaterial.fla:

obtile

1- faceField: Movieclip
2- obTile:MovieClip
3- main (definir como classe principal)

obs: para criar um movirclip vazio basta segurar ctrl + F8.

faceField.as

Esta classe não existe mistério nenhum, seu construtor recebe um numero como parâmetro e se for 1 desenha o vetor map1 e se for outro desenha o vetor map2. Em seguida percorre a seqüência de loops para desenhar o tile.

package
{
    import flash.display.MvieClip;
    public class faceField extends MovieClip
    {
        public var map1:Array = [
        [1,1,1,1,1,1,1,1,1,1,1],
        [1,0,0,0,0,0,0,0,0,0,1],
        [1,0,0,0,0,1,0,0,0,0,1],
        [1,0,0,0,1,1,0,0,0,0,1],
        [1,0,0,0,0,1,0,0,0,0,1],
        [1,0,0,0,0,1,0,0,0,0,1],
        [1,0,0,0,0,1,0,0,0,0,1],
        [1,0,0,0,0,1,0,0,0,0,1],
        [1,0,0,0,1,1,1,0,0,0,1],
        [1,0,0,0,0,0,0,0,0,0,1],
        [1,1,1,1,1,1,1,1,1,1,1],
        ];
        public var map2:Array = [
        [1,1,1,1,1,1,1,1,1,1,1],
        [1,0,0,0,0,0,0,0,0,0,1],
        [1,0,0,0,1,1,1,0,0,0,1],
        [1,0,0,1,0,0,0,1,0,0,1],
        [1,0,0,1,0,0,0,1,0,0,1],
        [1,0,0,0,0,0,1,0,0,0,1],
        [1,0,0,0,0,1,0,0,0,0,1],
        [1,0,0,0,1,0,0,0,0,0,1],
        [1,0,0,1,1,1,1,1,0,0,1],
        [1,0,0,0,0,0,0,0,0,0,1],
        [1,1,1,1,1,1,1,1,1,1,1],
        ];
        public function faceField (n:Number)
        {
            for (var j =0; j<11; j++)
            {
                for (var i=0; i<11; i++)
                {
                    var t:MovieClip = new obTile();
                    addChild (t);
                    t.x = i * 20;
                    t.y = j * 20;
                    if (n==1)
                    {
                        t.gotoAndStop(map1[j][i]+1);
                    }
                    else
                    {
                        t.gotoAndStop(map2[j][i]+1);
                    }
                }
            }
        }
    }
 }

main.as

Nossa classe principal não possui nenhum mistério, utilizamos a estrutura do tutorial papervision materiais.

Utilizamos apenas MovieMaterial para formação das faces do cubo, com a diferença apenas na maneira de que são chamadas desta apenas uma fogem do padrão.

    skinTile1.gotoAndStop(1);
    skinTile2.gotoAndStop(2);
    faceMovTile1 =  new MovieMaterial(skinTile1);
    faceMovTile2 =  new MovieMaterial(skinTile2);

Apesar dos objetos terem sidos criados no começo da classe só neste ponto que instanciamos os objetos para se portar como material, desta maneira garante que os moviesclips vão estar em seus respectivos frames antes de instanciarmos os materiais.

package
{
    //flash
    import flash.display.Sprite;
    import flash.display.MovieClip;
    import flash.events.Event;
    //papervision
    import org.papervision3d.scenes.Scene3D;
    import org.papervision3d.view.Viewport3D;
    import org.papervision3d.cameras.Camera3D;
    import org.papervision3d.render.BasicRenderEngine;
    //Material
    import org.papervision3d.materials.utils.MaterialsList;
    import org.papervision3d.materials.MovieMaterial;
    // objeto
    import org.papervision3d.objects.primitives.Cube;
    public class main extends Sprite
    {
        public var cena:Scene3D;
        public var viewport:Viewport3D;
        public var camera:Camera3D;
        public var renderer:BasicRenderEngine;
        //Material
        public var skinMaterial1:MovieClip = new faceField(1);
        public var faceMov1:MovieMaterial = new MovieMaterial(skinMaterial1);
        public var skinMaterial2:MovieClip = new faceField(2);
        public var faceMov2:MovieMaterial = new MovieMaterial(skinMaterial2);
        public var skinTile1:MovieClip = new obTile();
        public var skinTile2:MovieClip = new obTile();
        public var faceMovTile1:MovieMaterial;
        public var faceMovTile2:MovieMaterial;
        //objetos Primitivos
        public var obCube:Cube;
        public function main ()
        {
            Set ();
            Objetos ();
        }
        public function Set ():void
        {
            viewport = new Viewport3D(400,300,true,false,true,true);
            addChild (viewport);
            cena = new Scene3D ;
            renderer = new BasicRenderEngine ;
            camera = new Camera3D ;
            camera.focus = 600;
            camera.zoom = 1;
        }
        public function Objetos ():void
        {
            skinTile1.gotoAndStop(1);
            skinTile2.gotoAndStop(2);
            faceMovTile1 =  new MovieMaterial(skinTile1);
            faceMovTile2 =  new MovieMaterial(skinTile2);
            //Cube
            obCube = new Cube(
                new MaterialsList(
                {front: faceMov1,
                 back: faceMov1,
                 left: faceMovTile1,
                 right: faceMovTile2,
                 top: faceMov2,
                 bottom: faceMov2}
                )
            ,220,220,220,1,1,1);
            cena.addChild (obCube);
            addEventListener (Event.ENTER_FRAME,Loop,false, 0, true);
        }
        public function Loop (e:Event):void
        {
            obCube.yaw (-4);
            obCube.pitch (-2);
            renderer.renderScene (cena,camera,viewport);
        }
    }
}

Espero que tenham gostado do tutorial, apesar de MovieMaterial ser uma textura bem útil não devemos esquecer das outras texturas, é sempre bom usar a textura certa para cada momento assim deixa o programa mais leve. Ao que parece vocês já devem estar enjoados de exemplos com cubo, por isso tentarei mudar um pouco de objeto para o próximo tutorial, estou dando uma olhada em coisas interessantes com o objeto “Plane” quem sabe ele não vira tema do nosso próximo tutorial de papervision. Obrigado pela visita e volte sempre.

Anúncios

Papervision Tile

abril 2, 2009

Olá pessoal, estava me preparando para montar um novo tutorial sobre tile system, já estou a algum tempo uma atualização para a estruturação de cenários isométricos, mas eu pensei “por que não criar um cenário 3D tile?”

swf

Clique na imagem para testar.

Gostou, este será o nosso produto final, pois bem vamos seguir com o tutorial.

Lógica:

A lógica é bem simples, usaremos 2 vetores diferentes, um deles será para mostrar qual será o tile que usaremos na posição e o outro vetor que indicara a altura. Criaremos os loops para percorrer o vetor e criar cubos num plano 3D. Como termos alguns cubos suspensos, completaremos os espaços vazios com cubos, e colocaremos uma função para rotacionar nosso Field.

Tiles:

linkage

Estes sãos os movieclips que usaremos no nosso arquivo .fla, todos eles com exceção do water são estáticos, não possuem nenhum freme alem do desenhado, já o water eu coloquei uma pequena movimentação para dar um efeito de água se movendo. Todos os movieclips estão com a propriedade linkage definidos.

Usaremos a classe MovieAssetMaterial para importarmos cada movieclip para um material diferente

 public var matGrass:MovieAssetMaterial = new MovieAssetMaterial("grass");
 public var matBase0:MovieAssetMaterial = new MovieAssetMaterial("base0");
 public var matBase1:MovieAssetMaterial = new MovieAssetMaterial("base1");
 public var matFlower:MovieAssetMaterial = new MovieAssetMaterial("flower");
 public var matWater:MovieAssetMaterial = new MovieAssetMaterial("water", true);

Tiles x Materiais

materiaislist

Como vocês podem ver na imagem acima montaremos cubos para usarmos como tile, por enquanto vamos nos focar em criar as listas de materiais para as respectivas faces dos cubos.

 public var w:MaterialsList = new MaterialsList(
    {front: matWater, back: matWater, left: matWater,
     right: matWater,  top: matWater,  bottom: matWater});
 public var g:MaterialsList = new MaterialsList(
    {front: matBase1,  back: matBase1,  left: matBase1,
     right: matBase1,  top: matGrass,  bottom: matBase1});
 public var f:MaterialsList = new MaterialsList(
    {front: matBase1,  back: matBase1,  left: matBase1,
     right: matBase1,  top: matFlower,  bottom: matBase1});
 public var b:MaterialsList = new MaterialsList(
    {front: matBase0,  back: matBase0,  left: matBase0,
     right: matBase0,  top: matBase0,   bottom: matBase0});

Assim nosso Tile ficara formatado da seguinte forma.

 public var arrayTile:Array = [
  [w,w,w,w,w,w,w,w,w,w],
  [w,w,w,g,g,g,g,w,w,w],
  [w,g,g,g,g,g,f,w,w,w],
  [w,f,g,f,g,g,g,g,w,w],
  [w,g,g,g,f,g,g,g,w,w],
  [w,w,g,g,w,g,g,g,w,w],
  [w,w,w,g,g,f,g,g,w,w],
  [w,w,w,g,g,g,g,w,w,w],
  [w,w,f,g,g,f,w,w,w,w],
  [w,w,w,w,w,w,w,w,w,w]];

Tile x Altura

Para não poluir o vetor de tile decidi usar um vetor separado para mostrar o posicionamento do bloco no plano R3.

 public var arrayTileHeight:Array = [
  [0,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,2,2,3,0,0,0],
  [0,3,2,0,1,1,2,0,0,0],
  [0,2,1,1,1,1,2,0,0,0],
  [0,0,1,1,1,1,1,0,0,0],
  [0,0,0,1,1,0,0,0,0,0],
  [0,0,0,0,1,0,0,0,0,0],
  [0,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,0,0,0,0,0,0]];

Nós usaremos cada cubo com o tamanho 30x30x30 analogamente para subir um nível os blocos temos que multiplicarmos a posição demonstrada no vetor por 30.

espaco

Com isso acabamos criando espaços vagos.para resolvermos isso criaremos um loop que criará blocos do tipo base da altura 0 ate a altura definida.

Criando Tiles

A diferença dos tiles que vimos em R2 para o R3 é que alteramos a propriedades x e z com os loops ao invés de (x,y) a propriedade y utilizamos para altura.

public function Objetos () {
  for (var i = 0; i < arrayTile.length; i++) {
      for (var j = 0; j <  arrayTile[0].length; j++) {
          //Criando blocos extras na altura
          if (arrayTileHeight[i][j]>0) {
             for (var k=0; k< arrayTileHeight[i][j]; k++){
                var obCubeb:Cube = new Cube(b,30,30,30);
                cena.addChild (obCubeb);
                obCubeb.x = i * 30 -150;
                obCubeb.z = j * 30 -150;
                obCubeb.y = k * 30;
             }
          }
          //Criando bloco Tile
          var obCube:Cube = new Cube(arrayTile[i][j],30,30,30);
          cena.addChild (obCube);
          obCube.x = i * 30 -150;
          obCube.z = j * 30 -150;
          obCube.y = arrayTileHeight[i][j] * 30;
      }
    }
    addEventListener (Event.ENTER_FRAME,Loop,false, 0, true);
 }

Código extra: Movimentando a câmera

Para fazer a movimentação da câmera utilizei a seguinte lógica, criei um objeto do tipo plano no centro de nosso cenário, e travei a câmera nele com o método.

obcamera.lookAt (centro);

Assim independente o posicionamento do x, y e z da câmera, ele sempre terá como foco o centro do mapa. Agora podemos movimentar o x e z da câmera para circular o cenário que ele nunca mudara seu foco.

A cada frame colocaremos as propriedades x e z somarem um valor, valor este que estará armazenado em um vetor. Se sempre somarmos valores nossa câmera sempre se afastará, com as possibilidades definidas em um vetor podemos manipular para ele alem de somar subtrair também para trazer a câmera de voltar.

Código Completo

Arquivo main.as

package {
   //flash
   import flash.display.MovieClip;
   import flash.events.*;
   //Papervision
   import org.papervision3d.objects.primitives.Plane;
   import org.papervision3d.objects.primitives.Cube;
   import org.papervision3d.scenes.Scene3D;
   import org.papervision3d.render.BasicRenderEngine;
   import org.papervision3d.cameras.Camera3D;
   import org.papervision3d.view.Viewport3D;
   import org.papervision3d.materials.MovieAssetMaterial;
   import org.papervision3d.materials.utils.MaterialsList;
   public class main extends MovieClip {
      //papervision
      public var cena:Scene3D;
      public var viewport:Viewport3D;
      public var camera:Camera3D;
      public var renderer:BasicRenderEngine;
      public var centro:Plane;
      //material
      public var matGrass:MovieAssetMaterial = new MovieAssetMaterial("grass");
      public var matBase0:MovieAssetMaterial = new MovieAssetMaterial("base0");
      public var matBase1:MovieAssetMaterial = new MovieAssetMaterial("base1");
      public var matFlower:MovieAssetMaterial = new MovieAssetMaterial("flower");
      public var matWater:MovieAssetMaterial = new MovieAssetMaterial("water", true);
      public var w:MaterialsList = new MaterialsList(
         {front: matWater, back: matWater, left: matWater,
          right: matWater, top: matWater, bottom: matWater});
      public var g:MaterialsList = new MaterialsList(
         {front: matBase1, back: matBase1, left: matBase1,
          right: matBase1, top: matGrass, bottom: matBase1});
      public var f:MaterialsList = new MaterialsList(
         {front: matBase1, back: matBase1, left: matBase1,
          right: matBase1, top: matFlower, bottom: matBase1});
      public var b:MaterialsList = new MaterialsList(
         {front: matBase0, back: matBase0, left: matBase0,
          right: matBase0, top: matBase0, bottom: matBase0});
       //tiles
       public var arrayTile:Array = [
        [w,w,w,w,w,w,w,w,w,w],
        [w,w,w,g,g,g,g,w,w,w],
        [w,g,g,g,g,g,f,w,w,w],
        [w,f,g,f,g,g,g,g,w,w],
        [w,g,g,g,f,g,g,g,w,w],
        [w,w,g,g,w,g,g,g,w,w],
        [w,w,w,g,g,f,g,g,w,w],
        [w,w,w,g,g,g,g,w,w,w],
        [w,w,f,g,g,f,w,w,w,w],
        [w,w,w,w,w,w,w,w,w,w]];
       public var arrayTileHeight:Array = [
        [0,0,0,0,0,0,0,0,0,0],
        [0,0,0,0,0,0,0,0,0,0],
        [0,0,0,0,2,2,3,0,0,0],
        [0,3,2,0,1,1,2,0,0,0],
        [0,2,1,1,1,1,2,0,0,0],
        [0,0,1,1,1,1,1,0,0,0],
        [0,0,0,1,1,0,0,0,0,0],
        [0,0,0,0,1,0,0,0,0,0],
        [0,0,0,0,0,0,0,0,0,0],
        [0,0,0,0,0,0,0,0,0,0]];
       //Camera
       public var cam:int = 0
       public var a:int = 0;
       public var arrayCam:Array = [[-45,0],[0,-45],[45,-0],[0,45]];
       public function main () {
          Set ();
          Objetos ();
       }
       public function Set ():void {
          viewport = new Viewport3D(400,300,true,false,true,true);
          addChild (viewport);
          cena = new Scene3D ;
          renderer = new BasicRenderEngine ;
          camera = new Camera3D ;
          camera.focus = 100;
          camera.zoom = 10;
          camera.x = 650;
          camera.z = 450;
          camera.y = 700;
          centro = new Plane();
          centro.y = 0;
          centro.z = 0;
          centro.x = 0;
      }
      public function Objetos ():void {
          for (var i = 0; i < arrayTile.length; i++) {
             for (var j = 0; j <  arrayTile[0].length; j++) {
                //Criando blocos extras na altura
                if (arrayTileHeight[i][j]>0) {
                    for (var k=0; k< arrayTileHeight[i][j]; k++){
                       var obCubeb:Cube = new Cube(b,30,30,30);
                       cena.addChild (obCubeb);
                       obCubeb.x = i * 30 -150;
                       obCubeb.z = j * 30 -150;
                       obCubeb.y = k * 30;
                    }
                }
                //Criando bloco Tile
                var obCube:Cube = new Cube(arrayTile[i][j],30,30,30);
                cena.addChild (obCube);
                obCube.x = i * 30 -150;
                obCube.z = j * 30 -150;
                obCube.y = arrayTileHeight[i][j] * 30;
             }
          }
          addEventListener (Event.ENTER_FRAME,Loop,false, 0, true);
      }
      public function Loop (e:Event):void {
          a++ ;
          rotaionCamera (camera,arrayCam[cam][0],arrayCam[cam][1])
          if (a % 30 == 0){
             nextCamera()
          }
          renderer.renderScene (cena,camera,viewport);
      }
      public function nextCamera():void{
          cam= cam+1
          if (cam>=4){
             cam = 0
          }else if (cam<=-1){
             cam = 3
          }
      }
      public function rotaionCamera (obcamera:Camera3D,newx,newz):void {
          obcamera.x+= newx;
          obcamera.z+= newz;
          obcamera.lookAt (centro);
      }
   }
}

Obs: Lembrando que estamos fazendo um aplicativo utilizando as classes do papervision, não podemos esquecer-nos de importalas.

Tile System [Enemy]

novembro 19, 2008

今日は皆-さん. Em fim dificuldade no nosso game, mas eu não estou falando de códigos avançados e complexos que vocês não entenderão, eu estou falando de inimigos. Como nosso grande amigos Ratysu (Dados Sujos) costumava dizer “A dificuldade valoriza o cumprimento da missão”. Pois bem um jogo com inimigos ganha muito mais emoção. E hoje daremos continuidade ao nosso tutorial tile system com a implementação de inimigos.

ssemeny

Clique aqui para jogar

Criando MovieClip Enemy:

Nosso movieclip enemy seguirá as mesmas proporções do player, com a diferença nos sprites e a propriedade linkage será definida como “Enemy”.

linkageenemy

Tipos de Inimigos:

Em nosso tutorial aprenderemos a montar 2 tipos de inimigos: os burros e os menos burros.

Burros: São aqueles inimigos que não se cansam de mover de um lado para o outro, anda anda anda , bate na parede, volta volta volta. Em nosso código chamaremos de inimigos tipo “Flip”.

Menos Burros: São aqueles inimigos que ao encostar em uma parede, escolhe uma direção aleatoriamente e segue ate o encontro da próxima parede. Chamaremos eles de tipo “Choose”.

Criando os objetos:

Nossos inimigos assim como criamos o jogador usaremos objetos com algumas propriedades pré definidas.

Enemy1 = {xtile:2, ytile:3, speed:2, enemy:true,  dirx:0, diry:-1, Type:"Flip"};
  • xtile,ytile (Number): Posição x e y inicial no tile system.
  • speed (Number): Velocidade do inimigo
  • enemy (Boolean): Esta propriedade especificara que o objeto é um inimigo, devemos implementar essa propriedade ao objeto Player também marcando como false.
  • dirx, diry (Number): Indica qual é a direção que nosso inimigo começará a percorrer. Seguindo as combinações:[1,0] direita, [-1,0] esquerda, [0,1] cima, [0,-1] baixo e [0,0] parado.
  • Type (“Choose” ou “Flip”): Indicará qual é o tipo do nosso inimigo

Junto com a criação dos objetos criaremos um vetor que armazenará todos os nosso objetos de inimigos. O código das declarações ficará mais ou menos assim:

char = {xtile:1,  ytile:1, speed:2, enemy:false};
Enemy1 = {xtile:2,  ytile:3, speed:2, enemy:true, dirx:0, diry:-1, Type:"Flip"};
Enemy2 = {xtile:6,  ytile:8, speed:2, enemy:true, dirx:-1, diry:0, Type:"Choose"};
Enemy3 = {xtile:2,  ytile:6, speed:2, enemy:true, dirx:0, diry:-1, Type:"Flip"};
arrayEnemy = [Enemy1, Enemy2, Enemy3];

Criando os MovieClips:

O processo de criação dos inimigos no field seguirá o mesmo padrão dos itens. Criaremos um loop que para cada índice fará referencia a um vetor para pegar as informações referentes as propriedades e logo em seguida substituirá o objeto do vetor pelo movieclip.

for (i = 0; i <  arrayEnemy.length; i++) {
  _root["Field"].attachMovie("Enemy","Enemy"  + i,5001 + i);
  _root["Field"]["Enemy"  + i]._x = arrayEnemy[i].xtile * TileP + 10;
  _root["Field"]["Enemy"  + i]._y = arrayEnemy[i].ytile * TileP + 10;
  _root["Field"]["Enemy"  + i].height = 7.5;
  _root["Field"]["Enemy"  + i].speed = arrayEnemy[i].speed;
  _root["Field"]["Enemy"  + i].enemy = arrayEnemy[i].enemy;
  _root["Field"]["Enemy"  + i].dirx = arrayEnemy[i].dirx;
  _root["Field"]["Enemy"  + i].diry = arrayEnemy[i].diry;
  _root["Field"]["Enemy"  + i].Type = arrayEnemy[i].Type;
  arrayEnemy[i] =  _root["Field"]["Enemy" + i];
}

Movendo os Inimigos:

O que difere os inimigos dos Playes? Ao meu ponto de vista o players você comanda e os inimigos andam sozinho. Vamos relembrar o funcionamento da estrutura de movimentação do Player.

Nos temos um loop que verifica quando pressionamos um botão. Depois se pressionarmos algo ele chama uma função passando os parâmetros da direção que o player vai ter que seguir. Na função armazenamos os valores de posicionamento em uma variável imagem fazemos cálculos com a velocidade, verificamos se depois do calculo se o tile no qual ele esta se dirigindo é walkable, senão deixamos o personagem parado.

Basicamente nosso inimigo também faz tudo isso com algumas mudanças, ao invés do jogador definir a direção com um botão, nosso inimigo já sabe qual é a direção que ele tem que seguir (dirx e diry), e ao invés dele ficar parado quando o destino não é permitido ele muda sua direção e segue o trajeto.

Pois bem no nosso loop criaremos um loop que percorrerá o vetor de inimigos e pedirá para todos andem suas respectivas direções, também aproveitaremos o loop para verificar se nosso player encostou em nosso inimigo, para o teste ficar perceptível colocaremos apenas para ele receber alpha 50 ao encostar. E na nossa função de movePlayer adicionaremos a verificação, se o objeto for encostar na parede ele criará uma variável wall e retornará true especificando o toque. Depois nós verificaremos. Se for um inimigo e encostou na parede mude de direção.

LoopFrame(){
   ..
 for (i in arrayEnemy) {
   movePlayer  (arrayEnemy[i],arrayEnemy[i].dirx,arrayEnemy[i].diry);
   if (arrayEnemy[i].hitTest  (Player)) {
     Player._alpha = 50;
   }
 }
 ..
..movePlayer (ob, dx, dy){
   ..
   if (_root["Field"][tileName].walk) {
     if ((dx == 1) or (dx == -1)) {
       ob._x += ob.speed * dx;
     }
   if ((dy == 1) or (dy == -1)) {
       ob._y += ob.speed * dy;
     }
   } else {
     hitwall = true;
   }
   ...

Nesta parte do código verificaremos se o inimigo é do tipo “Flip” ou “Choose”. Quando ele é Flip apenas multiplicamos as direções por -1 e quando for choose criamos um vetor com as 4 próximas possibilidades de movimento e usamos uma simples estrutura de random para escolher.

if (hitwall && ob.enemy) {
   if (ob.Type == "Flip")  {
     movePlayer (ob,dx * -1,dy *  -1);
     ob.dirx *= -1;
     ob.diry *= -1;
   } else if (ob.Type ==  "Choose") {
   var arraydir:Array = [[0, 1],  [1, 0], [0, -1], [-1, 0]];
   var rnddir = Math.round  (Math.random () * 4);
   movePlayer (ob,arraydir[rnddir][1],arraydir[rnddir][1]);
   ob.dirx = arraydir[rnddir][0];
   ob.diry = arraydir[rnddir][1];
   }
}

Código Final:

Agora vamos ver como ficou todo o código do na integra.

stop ();
arrayField = [[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
              [2, 0, 0, 0, 0, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2],
              [2, 0, 0, 1, 0, 0, 0, 0, 0, 2, 0, 0, 1, 2, 2],
              [2, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 2, 2],
              [2, 2, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 2, 2],
              [2, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 2, 2],
              [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2],
              [2, 0, 0, 0, 1, 2, 0, 1, 0, 0, 2, 2, 2, 2, 2],
              [2, 2, 0, 0, 2, 2, 0, 0, 0, 2, 2, 2, 2, 2, 2],
              [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]];
itens = [[1, 2], [2, 8], [5, 6], [8, 7], [11, 4], [8, 4], [5, 1]];
var pontos:Number = 0;
_root.createEmptyMovieClip ("Field",1);
char = {xtile:1, ytile:1, speed:2, enemy:false};
Enemy1 = {xtile:2, ytile:3, speed:2, enemy:true, dirx:0,  diry:-1, Type:"Flip"};
Enemy2 = {xtile:6, ytile:8, speed:2, enemy:true, dirx:-1,  diry:0, Type:"Choose"};
Enemy3 = {xtile:2, ytile:6, speed:2, enemy:true, dirx:0,  diry:-1, Type:"Flip"};
arrayEnemy = [Enemy1, Enemy2, Enemy3];
Tile0 = {walk:true, frame:1};
Tile1 = {walk:false, frame:2};
Tile2 = {walk:false, frame:3};
TileP = 20;
indice = 0;
for (i = 0; i < arrayField[0].length; i++) {
  for (j = 0; j <  arrayField.length; j++) {
    indice += 1;
    newName =  "Tile_" + j + "_" + i;
    _root["Field"].attachMovie  ("Tile",newName,indice);
    _root["Field"][newName]._x = i * TileP;
    _root["Field"][newName]._y = j * TileP;
    _root["Field"][newName].walk = _root["Tile" + arrayField[j][i]].walk;
    _root["Field"][newName].gotoAndStop  (_root["Tile" + arrayField[j][i]].frame);
  }
}
for (i = 0; i < itens.length; i++) {
  var itemName =  "item_" + itens[i][1] + "_" + itens[i][0];
  _root["Field"].attachMovie  ("itens",itemName,i + 200);
  _root["Field"][itemName]._x  = itens[i][0] * TileP + 10;
  _root["Field"][itemName]._y  = itens[i][1] * TileP + 10;
}
_root["Field"].attachMovie  ("Player","Player",5000);
_root["Field"]["Player"]._x = char.xtile * TileP +  10;
_root["Field"]["Player"]._y = char.ytile * TileP +  10;
_root["Field"]["Player"].height = 7.5;
_root["Field"]["Player"].speed = char.speed;
_root["Field"]["Player"].enemy = char.enemy;
_root["Field"]["Player"].enemy = char.enemy;

for (i = 0; i < arrayEnemy.length; i++) {
  _root["Field"].attachMovie  ("Enemy","Enemy" + i,5001 + i);
  _root["Field"]["Enemy"  + i]._x = arrayEnemy[i].xtile * TileP + 10;
  _root["Field"]["Enemy"  + i]._y = arrayEnemy[i].ytile * TileP + 10;
  _root["Field"]["Enemy"  + i].height = 7.5;
  _root["Field"]["Enemy"  + i].speed = arrayEnemy[i].speed;
  _root["Field"]["Enemy"  + i].enemy = arrayEnemy[i].enemy;
  _root["Field"]["Enemy"  + i].dirx = arrayEnemy[i].dirx;
  _root["Field"]["Enemy"  + i].diry = arrayEnemy[i].diry;
  _root["Field"]["Enemy"  + i].Type = arrayEnemy[i].Type;
  arrayEnemy[i] =  _root["Field"]["Enemy" + i];
}

function loopFrame () {
  var Player =  _root["Field"]["Player"];
  if (Key.isDown  (Key.RIGHT)) {
    movePlayer  (Player,1,0);
  } else if  (Key.isDown (Key.LEFT)) {
    movePlayer  (Player,-1,0);
  } else if  (Key.isDown (Key.DOWN)) {
    movePlayer  (Player,0,1);
  } else if  (Key.isDown (Key.UP)) {
    movePlayer  (Player,0,-1);
  }
  for (i in itens)  {
    var  itemName = "item_" + itens[i][1] + "_" + itens[i][0];
    if  (_root["Field"][itemName].hitTest (Player)) {
      _root["Field"][itemName].removeMovieClip  ();
      pontos  += 100;
    }
  }
  for (i in  arrayEnemy) {
    movePlayer  (arrayEnemy[i],arrayEnemy[i].dirx,arrayEnemy[i].diry);
    if  (arrayEnemy[i].hitTest (Player)) {
      Player._alpha  = 50;
    }
  }
}
function movePlayer (ob, dx, dy) {
  var hitwall:Boolean  = false;
  ob.x = ob._x;
  ob.y = ob._y;
  ob.xtileIm =  Math.floor ((ob.x += ((ob.speed + ob.height) * dx)) / TileP);
  ob.ytileIm =  Math.floor ((ob.y += ((ob.speed + ob.height) * dy)) / TileP);
  var tileName:String  = "Tile_" + (ob.ytileIm) + "_" + (ob.xtileIm);
  if  (_root["Field"][tileName].walk) {
    if ((dx == 1) or  (dx == -1)) {
      ob._x  += ob.speed * dx;
    }
    if ((dy == 1) or  (dy == -1)) {
      ob._y  += ob.speed * dy;
    }
  } else {
    hitwall = true;
  }
  ob.xtile =  Math.floor (ob._x / TileP);
  ob.ytile =  Math.floor (ob._y / TileP);
  ob.xtileIm =  ob.xtile;
  ob.ytileIm =  ob.ytile;
  if (hitwall  && ob.enemy) {
    if (ob.Type ==  "Flip") {
      movePlayer  (ob,dx * -1,dy * -1);
      ob.dirx  *= -1;
      ob.diry  *= -1;
    } else if  (ob.Type == "Choose") {
      var  arraydir:Array = [[0, 1], [1, 0], [0, -1], [-1, 0]];
      var  rnddir = Math.round (Math.random () * 4);
      movePlayer  (ob,arraydir[rnddir][1],arraydir[rnddir][1]);
      ob.dirx  = arraydir[rnddir][0];
      ob.diry  = arraydir[rnddir][1];
    }
  }
}

Como vocês podem ver o código está bem rústico, quando eu tive a idéia de montar este tutorial era para seguir de maneira simples e pratica a criação de um jogo. Não me preocupei muito com modulação e estruturação. Por isso este será o tema do nosso próximo tutorial tile system. Vamos organizar este código e depois migrar para actionscript 3.0.até a próxima. Cya. また見てね.

Tile System [Itens]

setembro 5, 2008

今日は皆-さん Devota ao nosso tutorial system. Hoje nós implementaremos um sistema de itens muito simples. Um sistema de criar itens dentro do cenário tile, verificar se o player pegou o item e contagem simples de pontos. Vejam como ficará nosso arquivo.

Download

Como vocês podem ver, nosso cenário está um pouco diferente do que fizemos no tutorial passado, as mudanças no código são poucas o que deu o charme mesmo foi o gráfico que deu uma melhorada, se vocês baixarem o arquivo vejam o quão simples foi fazer essas mudanças^^

Mudando o código:

Tirando a Matriz que monta o cenário, nós adicionamos um contador para criar o depths de cada tile, fazendo com que o índice todos os depths de cenário fiquem entre 1 e 150, assim você vai se certificar e sempre vai criar um item na camada acima do cenário.

Outra mudança foi nos loops de construção do cenário, nos tutoriais anteriores nós usavamos cenrário quadrado. por isso podíamos usar uma variável limitadora do total para ambos os lados. agora vamos usar a largura do primeiro vetor que fica dentro de arrayField.

...
indice = 0;
for (i = 0; i < arrayField[0].length; i++) {
  for (j = 0; j < arrayField.length; j++) {
    indice += 1;
    newName = "Tile_" + j + "_" + i;
    _root["Field"].attachMovie("Tile",newName,indice);
...

Criando MovieClip Item:

Vamos usar como item uma estrela. Ela deverá ser criada no centro no movieclip e a propriedade linkage denominada “itens”

Array Itens:

Assim como no cenário montaremos um vetor para armazenar o posicionamento de cada item. E criaremos uma variável para armazenar os pontos.

itens = [[1, 2], [2, 8], [5, 6], [8, 7], [11, 4], [8, 4], [5, 1]];
var pontos:Number = 0;

Criaremos um loop que irá de 0 ao tamanho do vetor itens para ir criando cada item no cenário, lembrando que usaremos a mesma estrutura que usamos para criar o jogador no cenário (cordenadax* TileP + 10) e (cordenadax* TileP + 10);

for (i = 0; i < itens.length; i++) {
  var itemName = "item_" + itens[i][1] + "_" + itens[i][0];
  _root["Field"].attachMovie("itens",itemName,i + 200);
  _root["Field"][itemName]._x = itens[i][0] * TileP + 10;
  _root["Field"][itemName]._y = itens[i][1] * TileP + 10;
}

Player vs Itens:

Na função loop criaremos um loop for in em item, Assim a cada movimento do nosso player faremos uma consulta verificando se o nosso player encostou em algum item da tela. Se tiver encostado ele vai remover o item e adicionar um valor para pontos

for (i in itens) {
  var itemName = "item_" + itens[i][1] + "_" + itens[i][0];
  if (_root["Field"][itemName].hitTest(Player)) {
    _root["Field"][itemName].removeMovieClip();
    pontos += 100;
  }
}

Para cada i em itens ele vai construir uma variável com o nome do item correspondente no loop e verificar se encostou no player ou não.

Com isso nosso tutorial tile system item está pronto, agora vocês podem usar a imaginação da maneira que vocês quiserem para montar um joguinho simples de coleta de itens. No próximo tutorial, não tenho certeza ainda mas provavelmente aprenderemos a estruturar inimigos burros no nosso cenário^^ Bem pessoal espero que tenham gostado e até a próxima. CYA, また見てね.

Tile System – Tutorial [Part 3][ActionScript]

maio 30, 2008

今日は皆-さん Olá pessoal dando continuidade ao nosso tutorial do tile system hoje vocês começaram a programar^^ Mas antes de começarmos a colocar o código vamos criar nosso movieclip base.

Tile Base

Abra o Flash crie um arquivo 200 x 200. Antes de criarmos o tile base vamos entender como funcionar. O movieclip Tile ele será a base da construção do cenário, cada frame desse movieclip representará um bloco colorido diferente. (vocês lembram na parte 2 que tínhamos 3 cores diferentes)

Vocês podem criar o tile de diversos tamanhos diferentes, eu optei por usar 20×20.

1.passo: vamos desenhar um quadrado 20×20 verde. Em qualquer parte do palco. Selecione–o e aperte F8 aparecerá essa tela.

Caso esteja aparecendo uma tela com menos opões clique no botão advanced. Coloque o nome do movieclip como “Tile” marque como movieclip. Em identifier coloque “Tile” marque as opções igual a imagem. Com essas opções poderemos criar um arquivo via actionscript puxando diretamente da biblioteca. Delete o quadrado do palco agora porque não iremos precisar dele ai só usaremos a da biblioteca

2.passo: Pressione F11 para aparecer a sua biblioteca.

De um duplo clique no tile para ele ser visualizado sozinho na tela. Crie mais 2 Keyframes. No segundo frame pinte o quadrado de branco e no terceiro frame pinte o quadrado de azul.

Crie um novo layer (ainda no movieclip Tile) nomeie como action. Pressione F9 para aparecer a caixa de Actions e digite:

stop();

Com isso sua tela deve ficar mais ou menos assim.

ActionScript da Parte 2

Observe a imagem acima a existência de um botão chamado Scene 1 clique nele para poder ir para o palco principal. No palco principal clique no primeiro frame e pressione F9 para abrir a janela de actions. Insira o código que aprendemos no tutorial anterior (esse código é referente ao posicionamento dos blocos).

stop();
arrayField = [
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
[ 2, 0, 0, 0, 0, 0, 0, 0, 0, 2],
[ 2, 0, 1, 1, 1, 1, 1, 0, 0, 2],
[ 2, 0, 1, 0, 0, 0, 0, 1, 0, 2],
[ 2, 0, 1, 0, 0, 0, 0, 1, 0, 2],
[ 2, 0, 1, 1, 1, 1, 1, 0, 0, 2],
[ 2, 0, 1, 0, 0, 0, 0, 1, 0, 2],
[ 2, 0, 1, 0, 0, 0, 0, 1, 0, 2],
[ 2, 0, 0, 0, 0, 0, 0, 0, 0, 2],
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
];

Funões actionScripts.

Para prosseguirmos vamos da uma pincelada rápida em 2 funções actionscripts que usaremos.

createEmpytClip(Nome,Deph); Essa função cria um movie clip vazio com o nome e índice que você definir.

_root.createEmptyMovieClip("Field", 1);

attachMovie(Link,nome, Deph);Essa função copia um movieclip da biblioteca para o palco, você se lembra quando agente criou o nosso movieclip Tile que nós definimos um nome para a propriedade Linkage, esse é o nome que usamos para o link. Resumindo se agente for chamar aquele nosso tile da biblioteca usamos assim:

_root.attachMovie("Tile","NovoTile",2);

gotoAndStop(posiçao): Envia animaçao para posição indicada. No nosso exemplo estamos enviando animçao para o frame 3

_root.gotoAndStop(3);

Loop

Vamos criar a estrutura do loop que irá gerar dinamicamente os movieclips em suas devidas posições. Recapitulando a estrutura da visualização da matriz:

arrayField[Linha][Coluna];

Então teremos que criar um loop que percorra cada linha e dentro desse loop montar um loop que percorra todas as colunas.

Loop percorrendo linha
.     loop percorrendo todas as colunas
.     .    Cria o movieclip
.     .    Posiciona o movie clip
.     .    Posiciona o frame na posição correta.
.     .
.     .fim do loop de colunas
.
.fim do loop de linhas

Essa é a nossa estrutura agora vamos converter para código Completo. (Todo código abaixo deve ser inserido no primeiro frame)

stop();
arrayField = [
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
[ 2, 0, 0, 0, 0, 0, 0, 0, 0, 2],
[ 2, 0, 1, 1, 1, 1, 1, 0, 0, 2],
[ 2, 0, 1, 0, 0, 0, 0, 1, 0, 2],
[ 2, 0, 1, 0, 0, 0, 0, 1, 0, 2],
[ 2, 0, 1, 1, 1, 1, 1, 0, 0, 2],
[ 2, 0, 1, 0, 0, 0, 0, 1, 0, 2],
[ 2, 0, 1, 0, 0, 0, 0, 1, 0, 2],
[ 2, 0, 0, 0, 0, 0, 0, 0, 0, 2],
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
];
_root.createEmptyMovieClip("Field", 1);
for (i = 0; i < arrayField.length; i++) {
    //percorre um loop de colunas
    for (j = 0; j < arrayField.length; j++) {
        newName = "Tile_" + j + "_" + i;
        _root["Field"].attachMovie("Tile", newName, i * 100 + j * 2);
        _root["Field"][newName]._x = j * 20;
        _root["Field"][newName]._y = i * 20;
        _root["Field"][newName].gotoAndStop(arrayField[i][j]+1);
    }
}

Recapitulando o funcionamento do código.

Definimos uma Matriz para podermos criar o cenário, Criamos um movieclip vazio para inserirmos nele os moviesclips tile que está na biblioteca, Fizemos um loop para criar 1 Tile para cada posicionamento da matriz, criamos uma variável chamada “newName” para podermos manipular melhor o nome de cada objeto novo criado. Usamos uma equação para definir o dephs (indice de posicionamento de layer) de cada objeto criado i * 100 + j * 2″ com isso todo objeto criado não corre o risco de ter o mesm dephs. E por ultimo jogamos o frame de cada objeto criado para o numero da matriz +1 (não existe frame 0 né^^).

No proximo tutorial nós aprenderemos a validadar quais locais o personagem poderá andar ou não, e vamos criar também nosso personagem no cenário.

Bem pessoal espero que estejam gostando do tutorial, como eu disse no anterior qualquer duvida postem ou me procurem no msn, eu ajudarei na boa. até a proxima pessal, CYA.また見てね.

Tile System – Tutorial [Part 2][Matriz Cenário]

maio 24, 2008

今日は皆-さん Dando continuidade ao nosso tutorial do Tile System. Nesse tutorial vamos finalmente por a mão na massa e entender como criamos um cenário tile system baseando em uma matriz.

Esse será o nosso cenário de estudo

Mas antes vamos entender como funciona uma matriz 2×2 para isso vamos montar uma matriz letras x números.

A = [A1, A2, A3];
B = [B1, B2, B3];
C = [C1, C2, C3];

Com isso nois temos as 3 vetores diferentes cada um representando uma linha diferente agora se agruparmos eles dessa forma:

Field = [A,B,C];

Eu prefiro desenhar a matriz desse jeito:

Field = [
[A1, A2, A3],
[B1, B2, B3],
[C1, C2, C3]
];

Para acessarmos cada valor do vetor acima devemos usar os index da seguinte forma:

Field[Linha][Coluna];

Analogamente para acessarmos cada valor da matriz faremos assim^^

Field[0][0] = A1
Field[0][1] = A2
Field[0][2] = A3
Field[1][0] = B1
Field[1][1] = B2
Field[1][2] = B3
Field[2][0] = C1
Field[2][1] = C2
Field[3][2] = C3

Bem isso é algo meio complexo de se entender de começo mas logo logo você pega o jeito. Agora vem a pergunta pra que eu tive que entender isso? o que isso vai ser útil para criar o cenário. Bem muito simples por que o código abaixo será o nosso cenário^^

arrayField = [
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
[ 2, 0, 0, 0, 0, 0, 0, 0, 0, 2],
[ 2, 0, 1, 1, 1, 1, 1, 0, 0, 2],
[ 2, 0, 1, 0, 0, 0, 0, 1, 0, 2],
[ 2, 0, 1, 0, 0, 0, 0, 1, 0, 2],
[ 2, 0, 1, 1, 1, 1, 1, 0, 0, 2],
[ 2, 0, 1, 0, 0, 0, 0, 1, 0, 2],
[ 2, 0, 1, 0, 0, 0, 0, 1, 0, 2],
[ 2, 0, 0, 0, 0, 0, 0, 0, 0, 2],
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
];

Se vocês prestarem atenção com calma nos números 1 espalhado pela matriz forma exatamente um R. ohhhhh agora vocês lembram que o nosso cenário tem um R branco exatamente aonde esta os 1 e uma borda azul que esta exatamente aonde você esta vendo o numero 2 e analogamente aonde o 0 esta verde nosso cenário. Para ficar mais claro vamos rever a figura do nosso cenário com a matriz por cima

Bem pessoal vou dar um tempo para vocês assimilarem o novo conhecimento adquirido com esse post e no próximo post nois finalizamos o nosso cenário com o desenvolvimento do actionsctipt que gerará o nosso cenário. Mas se vocês quiserem ir se adiantando vou dar a dica do que faremos no próximo post.

Próximo post:

• Criemos um movieclip aonde cada frame vai representar um quadrado de cor diferente.
• Faremos um loop que percorrera nossa matriz e no lugar de cada numero criará um movieclip diferente
• Depois mandaremos nossos movieclip exibirem a imagem correta baseado nos números da matriz

Espero que esteja sendo claro, pois eu nunca tinha escrevido nada antes para ensinar alguém^^ qualquer duvida postem aqui ou podem me procurar no msn (esta do lado direito junto o meu auto retrato^^) nos veremos no próximo post pessoal. Até mais, CYA, また見てね.

Tile System – Tutorial [Part 1]

maio 16, 2008

今日は皆さん Desculpe-me a demorar em fazer o post, mas eu perdi muito tempo tentando elaborar um desculpa convincente para o atraso e não bolei nenhuma maneira. ^^

Tenho atraído visitas de muitas pessoas que não estão aqui só para jogar, dentre outros motivos que um ser em sã consciência visita meu blog é para entender a criação de um game e hoje vou estrear a minha primeira matéria voltada a esse pessoal que quer aprender umpouco sobre construção de jogos.

No post de hoje não mencionarei nenhum código só teoria. Espero que gostem.

TILE SYSTEM (Vulgo Sistema de Azulejos)

Imagina que você precisa fazer um jogo com gráfico bonito e que seja leve. De uma olhada na nessa imagem.

Imagem 1 Imagem2

Reparem que a primeira imagem é apenas uma tela azul e a segunda é um monte de quadradinhos azuis preenchendo a tela. Agora imagine que eu vou continuar colocando vários quadradinhos na segunda imagem para ficar tudo azul igual à primeira. Eu poderia escrever diversos parágrafos para explicar o ocorrido, mas vou simplificar de uma maneira clara para todos.

É muito mais rápido você fazer uma imagem pequena e repetir em todos os lugares. Do que fazer uma imagem grande para cenário. Agora prestem atenção na próxima imagem.

É imaginação minha ou os blocos se repetem em diversas partes do mapa. Presta atenção nas cores correspondentes a cada bloco. Se você picotar a imagem você encontrar muito mais blocos repetidos.

Esse sistema também foi e ainda é muito usado em jogos de aventura. Repare como os blocos circulados repetem em um monte de lugares do cenário.

Preciso dizer mais alguma coisa para vocês entenderem o que é o tile system?

Resumindo:

Tile System: é um sistema de criação e estruturação de cenários baseando-se em junções de diversos mini blocos. Fazendo com que o game fique mais rápido para ser processado.

  • Vantagem: Rápido processamento na hora de carregar as imagens. Um simples bloco pode ser usado em diversos cenários diferentes e você não precisa redesenhar todo o cenário para mudar um pequeno detalhe.
  • Desvantagem: Complexidade de programação.

Para quem conhece RPG Maker (programa para criar jogos de rpgs simples). O sistema de cenários do programa é baseado em tile sistem. Dêem uma olhada no chipset de cenário utilizado pelo programa.

ChipSet RPG maker

Esse Chipset é baseado no game The Legend of Zelda a Link to the Past (SNES). Um bom exemplo que Tile System sempre esteve em sua vida e você nunca percebeu. Vejam essas imagens tirada do game Goof Troop (SNES) ambas as imagensforam tiradas de um emulador a diferença que eu fiquei pressionando os botões de configurações de tela.

Bem pessoal espero que tenham gostado do primeiro tutorial de desenvolvimento de jogos da HamisterTower. Na proxima parte vamus abordar a construção inicial da progamação nesse sistema. Fiquem atento virão muitos outros tutoriais de flash por ai. vlw pessoal até a próxima, CYA, また見てね.