[diммy Flαรн.єxє]

Antes de começar a rolar, temos de fazer uma coisa muito clara. Flash é lento. O flash é extremamente lento. Rolagem significa centenas de peças em movimento na tela e isso deve acontecer 20-30 vezes em segundo. Muitas telhas de rolagem Flash cant significa desenhá-los no tempo e fica mais lento. Seu jogo vai rastejar como um caracol de dormir.



Você pode fazer telhas de rolagem, mas você deve ser cuidadoso para não fazer a rolagem área muito grande e não para se deslocar telhas demais. Quão grande é muito grande e quantos é demais, as respostas que você tem que descobrir sozinho. Lembre-se, que os jogos são disputados na maior parte do Flash no navegador, provavelmente muitas janelas são abertas ao mesmo tempo, muitos programas estão sendo executados em segundo plano e os jogadores sempre têm computadores doesnt últimas poder. Teste o jogo em computadores antigos crappy e se sente a abrandar, torná-la menor.





Teoria
Na foto à esquerda não é jogo de rolagem. Move Hero direita, tudo o resto permanece onde estava. Agora, na imagem da direita temos a rolagem jogo. Hero também é supor para mover para a direita, mas para torná-lo parecido com o deslocamento, nós realmente mantê-herói em sua posição atual e passar tudo para a esquerda.



Assim, a teoria é fácil: quando o herói é supor para mover, mover todas as telhas na direção oposta. Mas já que temos utilizado para colocar o herói dentro do clipe de filme de azulejos com todas as telhas de fundo, o herói que se movem em sentido contrário com eles. Para corrigi-lo, ainda mover tudo no sentido oposto e vamos passar quantidade mesmo herói na direção correta.

Tempo, por exemplo. Scrolling game. Herói é supor para mover 10 pixels a direita. Primeiro, passamos todas as peças (incluindo herói) deixados por 10 px, e mover para a direita herói por 10 px. No final, parece que o herói tenha permanecido no local, mas outras peças têm rolado esquerda.

Maneira mais fácil de percorrer telhas, é colocar todas as peças na tela, mas para mostrar apenas uma pequena parte deles, então nós simplesmente movê-los todos ao redor. Isso pode tornar o jogo muito lento, já que milhares de telhas de fora da área visível ainda precisam de recursos. Próximo idéia é remover as telhas quando vão para fora da área visível e anexar telhas quando vêm visível novamente. Isso é melhor, mas Flash gasta muito tempo remover / ligar clipes de filme.

Nossa última esperança é o único lugar telhas visível no palco e quando vão para fora, passamos as mesmas peças para o lado oposto, renomeá-los e reutilizar clipes de filme mesmo. Isso é chamado de "gotoAndStop"



telha quando sai da direita, passamos a telha para a esquerda. Nós também temos que mudar o nome do clipe de filme, já que todos os filmes aqui têm nomes como "t_3_4" o que significa que é colocado no y = 3, x = 4. E azulejo na nova posição, provavelmente, tem que mostrar outro quadro (gráfico), por isso precisamos de enviá-lo para corrigir quadro com gráfico correto e é por isso esse método é chamado de "gotoAndStop".

Preparando-se para se deslocar
Na maioria dos jogos de rolagem, o herói é sempre ficar no centro da tela.



Você pode ver como número de telhas da esquerda herói é igual ao número de telhas direito dele. Isso significa que o número de colunas é 3,5,7,9,11, etc, mas nunca 2,4,6,8. Mesmo vale para as linhas também.

Permite declarar objectivo do jogo:

game = (tileW: 30, tileH: 30, currentMap: 1, VISX: 7, visy: 5, centerx: 120, centery: 90);
propriedade VISX é o número de colunas visíveis e visy é o número de linhas. Precisamos também de propriedades centerx / centery para marcar ponto central do nosso filme.

Quando rolar a azulejos, poderemos ter de mostrar peças que não são declarados na matriz mapa. Como quando o herói caminha alegremente para a esquerda até que ele fica no azulejo à esquerda declarada com matriz do mapa, ainda temos algumas telhas esquerda dele para mostrar. Para esses tipos de telhas, criamos tipo de telha nova, sem gráficos para mostrar (para tornar mais fácil para o Flash). No clipe de filme telhas fazer novo quadro-chave vazio no quadro 20. Adicione o código para declarar este tipo de telha:

CÓDIGO

game.Tile4 = function () ();
game.Tile4.prototype.walkable = false;
game.Tile4.prototype.frame = 20;

Você pode também querer cobrir algumas telhas em parte ouside de área visível. Para esse efeito, fazer novo clipe de filme com o nome de ligação "frame", que tem buraco no meio, mostrando apenas as telhas por aquele buraco.

Construir o mundo de rolagem
Vamos começar com a função buildMap.

CÓDIGO

buildMap função (mapa) (
   _root.attachMovie ( "vazia", "tiles", 1);
   game.halfvisx = int (game.visx / 2);
   game.halfvisy = int (game.visy / 2);

Vamos calcular 2 novas propriedades para o objeto do jogo. halfvisx e halfvisx manterá informações sobre o número de colunas e linhas a partir da posição chars para a borda da área visível. Quando o número total de colunas VISX = 5, então halfvisx = 2, ou seja, 2 colunas são direito de herói, 2 colunas estão à esquerda e 1 é reto no centro com o herói.

CÓDIGO

game.clip = _root.tiles;
game.clip._x = game.centerx-(char.xtile game.tileW *)-game.tileW / 2;
game.clip._y = game.centery-(char.ytile * game.tileH)-game.tileH / 2;

Temos que colocar clipe de filme segurando todas as telhas eo herói baseado em 2 variáveis: ponto central de The Game declarada no objeto jogo centerx / centery e posição do herói declarada no objeto char por xtile / ytile. Quando o herói é colocado sobre a coordenada x (char.xtile game.tileW *) + game.tileW / 2, em seguida, telhas mc tem que ser na direção oposta, de que é por isso que subtraia esse número do centerx.

CÓDIGO

for (var y = char.ytile game.halfvisy; y <= char.ytile + game.halfvisy 1; + + y) (
   for (var x = char.xtile-game.halfvisx; x <= char.xtile game.halfvisx + +1; + + x) (
     var name = "t_" + y +"_"+ x;
     if (y> = 0 e x> = 0 e y <= map.length-1 e x <= map [0]. length-1) (
       game [name] = new game [ "Tile" + map [y] [x ]]();
     ) else (
       game [name] = new game.Tile4 ();
     )
     game.clip.attachMovie (telha ", nome, 1 + y * 100 + x * 2);
     game.clip [nome]. _x = (x game.tileW *);
     game.clip [nome]. _y = (y * game.tileH);
     game.clip [nome]. gotoAndStop (game [name]. frame);
   )
)

Este laço cria todos os objetos visíveis e azulejo também atribui clipes do filme para as telhas. Como você pode ver, o início doesnt loop de 0 anymore, ele começa a partir do ytile-halfvisy. Da mesma forma que a faz funcionar até ao final do array do mapa, ele vai até ytile + halfvisy 1. A condição se verifica então se o azulejo a ser criada é a matriz do mapa. Se ele ficar fora do mapa, usamos o azulejo branco da tile4 modelo.

A fim de criar deslocamento contínuo, temos de usar uma linha extra e uma coluna extra de azulejos na direita e borda inferior. Essas telhas garantir que, mesmo quando passamos a metade de telha para o outro lado, não haverá nenhum espaço vazio.

CÓDIGO

_root.attachMovie ( "frame", "frame", 100);

Última linha atribui uma moldura para cobrir áreas de filme que você não quer ser visto.

CÓDIGO

char.clip = game.clip.char;
char.x = (char.xtile game.tileW *) + game.tileW / 2;
char.y = (char.ytile game.tileW *) + game.tileW / 2;
char.width = char.clip._width / 2;
char.clip._height char.height = / 2;
char.clip._x = char.x;
char.y char.clip._y =;
char.frame (char.clip.gotoAndStop);
char.xstep = char.x;
char.y char.ystep =;

O char é criado exatamente da mesma maneira como antes. Somente a diferença são de 2 xstep novas propriedades e ystep, que iremos usar mais tarde para buscar por tempo certo para movimentar linhas ou colunas de azulejos para o outro lado.

Scroll! Scroll!
Agora que criámos o mundo, nós precisamos realmente é de deslocamento. No final da função moveChar depois de ter calculado o ob.xtile / ob.ytile para o herói, adicione código para se deslocar:

CÓDIGO

game.clip._x = game.centerx-ob.x;
game.centery game.clip._y =-ob.y;
if (ob.xstep <ob.x-game.tileW) (
   xtile var = Math.floor (ob.xstep / game.tileW) + 1;
   xnew var = xtile game.halfvisx + 1;
   xold var = xtile-game.halfvisx-1;
   for (var i = ob.ytile-game.halfvisy-1, i <= ob.ytile game.halfvisy + 1; + + i) (
     changeTile (xold, i, xnew, i, _root [ "myMap" + game.currentMap]);
   )
   ob.xstep ob.xstep = + game.tileW;
) Else if (ob.xstep> ob.x) (
   xtile var = Math.floor (ob.xstep / game.tileW);
   xold var = xtile game.halfvisx + 1;
   xnew var = xtile-game.halfvisx-1;
   for (var i = ob.ytile-game.halfvisy-1, i <= ob.ytile game.halfvisy + 1; + + i) (
     changeTile (xold, i, xnew, i, _root [ "myMap" + game.currentMap]);
   )
   ob.xstep ob.xstep =-game.tileW;
)
if (ob.ystep <ob.y-game.tileH) (
   ytile var = Math.floor (ob.ystep / game.tileH) +1;
   ynew var = ytile game.halfvisy + 1;
   Yold var = ytile-game.halfvisy-1;
   for (var i = ob.xtile-game.halfvisx-1, i <= ob.xtile game.halfvisx + 1; + + i) (
     changeTile (i, Yold, i, ynew, _root [ "myMap" + game.currentMap]);
   )
   ob.ystep ob.ystep = + game.tileH;
) Else if (ob.ystep> ob.y) (
   ytile var = Math.floor (ob.ystep / game.tileH);
   Yold var = ytile game.halfvisy + 1;
   ynew var = ytile-game.halfvisy-1;
   for (var i = ob.xtile-game.halfvisx-1, i <= ob.xtile game.halfvisx + 1; + + i) (
     changeTile (i, Yold, i, ynew, _root [ "myMap" + game.currentMap]);
   )
   ob.ystep ob.ystep =-game.tileH;
)
return (true);

Primeiro vamos mover game.clip detentora da totalidade das telhas e do herói para a nova posição com base no ponto central e as coordenadas do herói. Então nós temos 4 blocos semelhantes de código, 1 para cada direção. Quando o herói mudou mais do que o tamanho das telhas, as linhas de chamada de função com as variáveis changeTile correta. Quando o circuito foi encerrada e as telhas foram movidos / renomeado / mudou, nós atualizamos ystep / propriedades xstep.

Agora vamos fazer essa função changeTile:

CÓDIGO

changeTile função (xold, Yold, xnew, ynew, mapa) (
var nameold = "t_" + Yold +"_"+ xold;
namenew var = "t_" + ynew +"_"+ xnew;
if (ynew> = 0 e xnew> = 0 e ynew <= map.length-1 e xnew <= map [0]. length-1) (
jogo [namenew] = new game [ "Tile" + map [ynew] [xnew ]]();
game.clip [nameold]. _name = namenew;
game.clip [namenew]. gotoAndStop (game [namenew]. frame);
game.clip [namenew]. _x = (xnew game.tileW *);
game.clip [namenew]. _y = (ynew * game.tileH);
) else (
jogo [namenew] = new game.Tile4 ();
game.clip [nameold]. _name = namenew;
game.clip [namenew]. gotoAndStop (game [namenew]. frame);
)
)

Então, vamos receber 2 anos e 2 novas coordenadas para a nossa telha. Para verificar se a telha é ainda array do mapa dentro, também passaram no mapa. nome "nameold" será o nosso azulejos antigos e "namenew" será o novo nome. Depois que criamos objeto azulejo novo com nome novo e fresco, a linha:

CÓDIGO

game.clip [nameold]. _name = namenew;

renomeia clipe de filme telhas. Quando o novo clipe de filme está vazia, então não precisamos colocá-lo à nova _x / _y, ele pode permanecer na sua posição de idade.