MXStudio » Flash » Criação de Games – Megaman Parte 2

Criação de Games – Megaman Parte 2


Criação de games – Megaman Parte 2

Olá comunidade,

Estou de volta trazendo a continuação do tutorial de criação de games – Megaman, tendo como foco a criação de um game de plataforma. Na primeira parte do tutorial, Criação de Games – Megaman parte 1, aprendemos algumas técnicas como a utilização de sprites, fizemos uma simulação do pulo do personagem, o tão prucurado scrolling da tela que cuja a idéia é bem tranquila e os princípios básicos de construção de jogos de plataforma. Portanto, assumo desde de já que você já possui os pré-requisitos listados abaixo.

Pré-requisitos:

Conhecimento básico em ActionScript
Macromedia Fireworks 8
Macromedia Flash 8
Recomenda-se que você tenha visto a coluna de movimentação básica de personagens e princípios básicos de games de plataforma, caso não tenha acesse:

Criação de Games
Criação de Games – Megaman parte 1

Objetivo:

O abjetivo desta segunda parte é a inclusão de novos elementos dentro do nosso joguinho, lembrando que é o básico, use sua imaginação para deixar o joguinho ainda mais interessante. Como o interesse aqui é puramente o aprendizado, não estamos desenvolvendo um jogo comercial que necessita de mais otimizações. No entanto, uma vez que assimilado todos os conceitos apresentados, conseguirá facilmente desenvolver seus jogos de forma comercial. A construção das animações é feita ação a ação do personagem, para cada ação um movie clip diferente, é claro que é possivel criar um único mc que pode ser controladoo via Action Script, mas vamos aprender uma coisa de cada vez. Veja o jogo pronto:

Conceitos:

Apresentarei neste artigo noções legais como como fazer o tiro que o Megaman vai disparar, a temporização destes tiros, um timer para marcar o tempo de jogo, a inclusão de inimigos no cenário e um pouquinho sobre IA em games. Logo nosso jogo estará completo com os itens básicos para este tipo de game.

Conteúdo

Já vou supor que você tenha visto o artigo anterior caso não tenha acesse (Criação de Games – Megaman parte 1), agora iremos adicionar ao projeto anterior, os elementos mencionados acima (tiro, timer, inimigos…). Para isso, abra o arquivo do jogo que fizemos no último artigo e vamos lá!

Primeiramente, vamos construir os tiros que serão dados tanto pelo megaman quanto pelos seus inimigos. Insira um novo símbolo do tipo movie clip, chame-o de tiro_mega, ao fim deste tutorial segue um link para que baixem as imagens que utilizei ou clique aqui para baixar. Da mesma forma que o outro artigo monte a animação do tiro baseado na folha de sprites abaixo:

entrada do jogo
Figura 1 – Folha de sprites para o tiro_mega.

Depois do movie clip pronto, volte para a cena e arraste-o da library, se ela não estiver aparecendo aperte CTRL + L. Iremos implementar as ações do tiro semelhante ao que eu fiz no meu primeiro turorial, aquele da nave. Então, devemos posicionar esse tiro fora do stage, redimensione o seu tamanho para 15px de altura e 15px de largura, chame essa instância de tiro_mc. Veja abaixo como posicionei no stage.

entrada do jogo
Figura 2 – Posição inicla adequada para o tiro_mega.

Agora vamos programar as ações desse tiro. Selecione o movie clip tiro_mc e aperte F9 para editar seu Action Script onde os inimigos que estão sendo referenciados no código serão criados nos passos seguintes, o código segue abaixo:

onClipEvent( enterFrame )
{
if(_name != “tiro_mc”)
{
//verifica colisão com inimigo 1
if(this.hitTest(_root.terreno_mc.inimigo_1_mc))
{
_root.terreno_mc.inimigo_1_mc.barra_mc._xscale -= 5;
this.removeMovieClip();
}
else
{
if(direcao == “direita”)
this._x += 25;
else
this._x -= 25; if(this._x >2000 || this._x < -5)
this.removeMovieClip();
}
}
}

Também precisaremos de um tiro que será dado por um dos inimigos do megaman que será feito mais a frente. O processo é o mesmo, pegue a folha de sprites, insira um novo movie clip vazio e chame-o de tiro_2, depois da animação pronta, volte à cena e arraste-o da library para o stage e dê o nome de instância de tiro_fogo_mc. Veja abaixo como ficou:

entrada do jogo
Figura 3 – Folha de sprites para tiro_2.

entrada do jogo
Figura 4 – Veja o posicionamento na cena.

O código para este tiro segue abaixo com algumas modificações para testar a colisão com o megaman em vez do inimigo, claro. E se o life do megaman chegar ao fim vai para frame 3 ou frame de Game Over. Eu chamei de gameOver o último frame da layer terreno.

onClipEvent( enterFrame )
{
if(_name != “tiro_fogo_mc”)
{
if(_root.life_mc._xscale <= 0)
{
_root.gotoAndStop(“gameOver”); }
if(this.hitTest(_root.megaman_mc))
{
_root.life_mc._xscale -= 5;
this.removeMovieClip();
}
else
{
if(direcao == “direita”)
this._x += 25;
else
this._x -= 25;

if(this._x >2000 || this._x < -5)
this.removeMovieClip();
}
}
}

Note que existe uma variável direcao que não foi declarada em lugar nenhum e está sendo usada em nosso AS dos dois tiros, ela foi criada no arquivo Megaman.as. Portanto, abra-o e insira o seguinte código nas linhas iniciais onde são declaradas as variáveis utilizadas no nosso game, aproveite e declare variáveis de controle que servirão para controlar o número de tiros e o tempo de intervalo entre cado tiro, veja abaixo como ficou.

stop();
/* Variáveis globais
* Aqui estão presentes as variáveis que fazem o
* controle dos estados
* em que o jogo se encontra
*/
var velSaltar:Number = 20;
var velAndar:Number = 0;
var pulando:Boolean = false;
var caindo:Boolean = false;
var morreu:Boolean = false;
var velMax:Number = 10;
var direcao:String = “”;
var entrada:Boolean = true;
var contTiros:Number = 0; /*Contador de tiros*/
var tiroInterval:Number = getTimer(); /*utilizada para calcular o intervalo dos tiros*/
/*adiciona à classe MovieClip um atributo que indica a direção para onde está indo*/
MovieClip.prototype.direcao = “esquerda”;
.
.
.

Agora vamos construir um timer que ficará contando o tempo, vai ser um timer bem simples em termos de beleza, mas que você poderá facilmente customizá-lo a seu gosto. Primeiramente insira um campo texto na parte superior central do nosso stage, sinta-se à vontade em colocar onde achar mais adequado dentro do stage a localização não vai influenciar, e mude suas propriedades para que seja um campo texto do tipo dinâmico. Mais algumas linhas serão adicionadas no arquivos Megaman.as, como já temos o tiro em mãos e uma variável que controla o intervalo de tempo dos tiros, podemos implementar a ação de disparar tiros. Abaixo está o código que implementa o disparo.

.
.
.
//só pula se não tiver pulando, claro
if ( Key.isDown(Key.SPACE) && !pulando )
{
pulando = true; /*mostra a animação pulando para direita se o personagem
* está indo para a direita, caso contrário para a esquerda
*/

if(direcao == “direita”)
megaman_mc.gotoAndStop(“pulando_dir”);
else
megaman_mc.gotoAndStop(“pulando_esq”);
}
/*########### Novas Linhas adicionadas ##########*/
tempo = Math.round(getTimer()/1000);
_root.tempo_txt.text = tempo;

if( Key.isDown( Key.CONTROL) && (getTimer() – tiroInterval) > 200 )
{
_root.contTiros++;
_root.tiro_mc.duplicateMovieClip(“tiro”+_root.contTiros,_root.contTiros,_root.contTiros); //duplicamos o tiro
if(direcao == “direita”)
{
if(!Key.isDown( Key.RIGHT) )
this.gotoAndStop(“atirando_dir”);
_root["tiro"+_root.contTiros]._y = this._y+35;
_root["tiro"+_root.contTiros]._x = this._x+50;

}
else
{
if(!Key.isDown( Key.LEFT) )
this.gotoAndStop(“atirando_esq”);
_root["tiro"+_root.contTiros]._y = this._y+35;
_root["tiro"+_root.contTiros]._x = this._x-10;
}

tiroInterval = getTimer();

/*atribuindo direcao para o tiro*/
_root["tiro"+_root.contTiros].direcao = direcao;
atirando = true;

}
/*#################################################*/
if( Key.isDown( Key.LEFT) )

.
.
.

Agora vamos adicionar os inimigos. Neste artigo vou adicionar apenas 2 inimigos para que você tenha uma noção de como implementar uma pequena Inteligência Artificial (IA) nos seus inimigos, a implementação de IA em games pode ser feita de diversas formas, aqui apresentarei uma idéia bem simples onde você poerá usar sua criatividade e implementá-la de uma forma mais rebuscada.

O primeiro Inimigo está representado no gif abaixo:

entrada do jogo
Figura 5 – Primeiro inimigo.

Uma forma de utilizar sprites foi visto na último artigo, era baseada na folha de sprites onde tinhamos que colocar um a um os sprites em cada frame. Agora veremos outra forma de usar sprites a partir de gif’s animados. Com uma imagem gif pronta é fácil obter seus sprites pelo flash que fará sozinho o processo da passagem da animação para o timeline. Primeiro vamos criar um movie clip vazio e chame-o de inimigo1. Agora vá no menu arquivo ->import ->import to stage ou simplesmente CTRL + R e selecione o arquivo img3.gif que forneci no link ao fim deste artigo. Clique em abrir e automaticamente o flash fará o milagre de colocar cada quadro da animação no seu respectivo frame. Que bacana hein!.

Timeline e o stage depois do import.
Figura 6 – Timeline e o stage depois do import.

Vamos criar agora o outro inimigo, volte ao stage e insira um novo movie clip chamado inimigo2, abaixo segue a imagem do nosso inimigo número 2:

inimigo número 2
Figura 7 – Segundo inimigo.img5.gif

Depois que ocoreu o import seu time e stage devem ficar assim:

Timeline e o stage depois do import.
Figura 8 – Timeline e o stage depois do import da segunda imagem.

Agora com as animações bases prontas iremos criar o mc que iremos controlar via Action Script. Portanto, na cena principal insira um novo mc chamado inimigo_1. Neste mc, crie duas layers uma chamada barra e outra chamada imagem. Na layer imagem, no primeiro frame desta layer coloque o mc que fizemos agora pouco chamado inimigo1 chame este primeiro frame de esquerda (aperte F9 neste frame e coloque um stop(); no Action Script) e o segundo desta mesma layer de direita e o terceiro frame chame de morto, este último indica o estado de quando sua barra de força chegar ao fim. O mc inimigo1 já está direcionado para a esquerda, como foi visto no artigo anterior basta usar a ferramenta Free Transform Tool para inverter a direção. Para mais detalhes veja o artigo anterior, e no frame morto não coloque nada deixe-o em branco sem nada no stage. Fica aqui como um teste criar uma animação de explosão ou qualquer coisa que pareça que o inimgo explodiu.

Agora vamos construir a barra de life do inimigo_1, na sua layer barra, usando a ferramenta Rectangle Tool desenhe um retângulo acima da cabeça do personagem de forma que esse desenho pertença à layer barra, transforme essa barra em mc apenas selecionando e apertando F8 chamando-a de barra_life. Por fim dê o nome de instância de barra_mc. Depois de todo esse processo com o primeiro frame selecione aperte F6 para criar um key Frame cópia do primeiro. Após todo esse processo veja como ficou:

Inimigo 1 no stage.
Figura 9 – Inimigo 1 no stage e seus respectivos frames.

Para fazer o outro inimigo você vai aplicar o mesmo processo, volte à cena principal e crie um movie clip chamado inimigo_2, crie as mesma layers e dê o mesmo nome pra elas. Utilize o mc inimigo2 para fazer a animação para a esquerda e inverta o mc para fazer a animação para direita. Coloque também o stop() no primeiro frame da layer imagem e barra de life não precisa fazer por que ela já está pronta na library. Basta arrastá-la para o primeiro frame da layer barra e dar o nome novamente de intância de barra_mc e apertar F6 com o primeiro frame selecionado para fazer uma cópia para o segundo.

Depois de criado esses dois mc’s volte para a cena principal e dê um duplo clique no mc terreno_mc, assim ele será aberto para edição e é aqui que vamos colocar nossos inimigos. Mas você poderia ter imaginado colocá-los diretamente na cena criando uma nova layer, por exemplo chamada de inimigos; isso sim é possível mas é inviável dependendo do número de inimigos no cenário por que será complicado aplicar o scrolling em todos esses objetos. Continuando, com o terreno_mc aberto para edição arraste o mc inimigo_1 da library para o stage. Dê o nome de instância de inimigo_1_mc. A posição onde vai ficar o seu inimigo depende de como você vai programar seu Action Script de modo que ele não ultrapasse barreiras que ele não possa ou estipular limites até onde possa ir, eu estipulei um valor máximo e um valor mínimo para que o personagem possa andar no eixo x. Dê um clique seu inimigo_1_mc e com ele selecionado aperte F9 para programá-lo com o código abaixo:

onClipEvent(load)
{
/*velocidade inicial do inimigo_1_mc*/
var speed = 2;
}onClipEvent(enterFrame)
{
/*não tem mais barra de life, então morreu*/
if(this.barra_mc._xscale <=0)
this.gotoAndStop(“morto”);
else
{
/*pequena simulação de inteligência artificial*/
atack = Math.random();
if(this.hitTest(_root.megaman_mc))
_root.life_mc._xscale -= .5;
/*realiza um ataque se o número randômico for divisível por 15*/
if(Math.round(atack*10000) % 15 == 0)
speed = 10;
/*persegue o megaman*/
if(_root.megaman_mc._x > _root.terreno_mc._x+this._x)
{
this.gotoAndStop(“direita”);
this._x +=speed;
}
else
{
this.gotoAndStop(“esquerda”);
this._x -=speed;
}
if(this._x < 100)
this._x +=speed;
else if(this._x > 600)
this._x -=speed;
speed = 2;

if(speed > 100)
speed = 0;
}
}

No código acima fiz com que o inimigo fique fazendo umas aceleradas para frente como se fosse um ataque e o código também faz com o inimigo fique sempre andando atrás do megaman se este estiver na sua linha de ataque. Cada vez que o inimigo_1_mc encosta no megaman ele tira 0.5 do life.

Para o inimigo_2_mc algumas adaptações são necessárias no código acima, primeiro eu admiti que não vou diminuir o life do megaman quando encostar neste inimigo só o tiro que este dará que vai diminuir, o intervalo x que o inimigo_2_mc pode andar também é diferente eu o coloquei na parte final da fase. E também atualizo a variável direcao para eu saber para onde este inimigo vai atirar. A imagem de como fica no stage depois desse processo de montagem das animações do personagem e o código seguem abaixo:

Inimigo 2 no stage.
Figura 10 – Inimigo 2 no stage e seus respectivos frames.

onClipEvent(load)
{
/*velocidade inicial do inimigo_2_mc*/
var speed = 2;
}onClipEvent(enterFrame)
{
/*não tem mais barra de life, então morreu*/
if(this.barra_mc._xscale <=0)
this.gotoAndStop(“morto”);
else
{
/*pequena simulação de inteligência artificial*/
atack = Math.random();
if(this.hitTest(_root.megaman_mc))
_root.life_mc._xscale -= .5;
/*realiza um ataque se o número randômico for divisível por 15*/
if(Math.round(atack*10000) % 15 == 0)
speed = 10;
/*persegue o megaman*/
if(_root.megaman_mc._x > _root.terreno_mc._x+this._x)
{
this.gotoAndStop(“direita”);
direcao = “direita”;
this._x +=speed;
}
else
{
this.gotoAndStop(“esquerda”);
direcao = “esquerda”;
this._x -=speed;
}
if(this._x < 1446)
this._x +=speed;
else if(this._x > 2040)
this._x -=speed;
speed = 2;

if(speed > 100)
speed = 0;
}
}

Vale ressaltar que o código das ações desses inimigos são os que podem mais serem implementados de forma diferente, eu optei para as ações da forma que está acima codificada, o inimigo_1_mc com o corpo e inimigo_2_mc ataca com um tiro de fogo. Lembre-se que ambos estão no mc terreno_mc.

Por fim vamos fazer a personagem que voa disparar o tiro de fogo que fizemos acima, vá a sua library e procure pelo mc inimigo2 que está na figura 8. Insira o código abaixo no frame 25, mas por que no frame 25? Se você observar a animação é nesse frame que a personagem sofre uma espécie de solavanco devido a um tiro que de forma imaginária ela tenha dado.

_root.contTiros++; _root.tiro_fogo_mc.duplicateMovieClip(“tiro”+_root.contTiros,_root.contTiros,_root.contTiros); //duplicamos o tiro

x_terreno = _root.terreno_mc._x;
x_inimigo = _root.terreno_mc.inimigo_2_mc._x;

/*Verifica para onde ela está olhando e atira*/
if(_root.terreno_mc.inimigo_2_mc.direcao == “direita”)
{
_root["tiro"+_root.contTiros].direcao = “direita”;
_root["tiro"+_root.contTiros]._y = _root.terreno_mc.inimigo_2_mc._y+58;
_root["tiro"+_root.contTiros]._x = x_terreno + x_inimigo+90;
}
else
{
_root["tiro"+_root.contTiros].direcao = “esquerda”;
_root["tiro"+_root.contTiros]._y = _root.terreno_mc.inimigo_2_mc._y+58;
_root["tiro"+_root.contTiros]._x = x_terreno + x_inimigo+10;
_root["tiro"+_root.contTiros]._xscale = – 2*_root["tiro"+_root.contTiros]._width;
}

Você conseguiu entender a linha 17 deste código? Sim? Não? O que ela faz? Até agora quando a gente desejava que um personagem ficasse virado para os dois sentidos criávamos duas frames e depois utilizando a ferramenta Free Transform Tool invertia o sentido da figura da esquerda para a direita ou vice e versa. Agora fizemos essa inversão via Action Script com uma linha de código, o mais impressionante é que funciona.

Falei muito de uma tal barra de life do megaman mais ainda não fizemos. Então, vá ao stage da cena e cria um retângulo da cor que quiser parecido com o que foi feito para os inimigos, transforme em movie clip chamando-o de barra dê o nome de instância de life_mc. Posicione no topo um pouco à direita perto do timer e se prefeir coloque uma imagem do megaman que você desejar ao lado do life só pra ficar claro que aquele life é do megaman. Veja como ficou:

entrada do jogo
Figura 11 -Posição do life e o primeiro inimigo.

Por último só falta fazer as animação do megaman atirando e o código que fará ele disparar os tiros. Para fazer a animação vamos usar o arquivo de imagens que segue logo ao fim desse artigo. Lá tem várias imagens do megaman atirando correndo e tudo mais. Acredito que você já está ficando bom nesse processo de copiar e colar para montar animações. Use a folha de sprite abaixo, OBS: eu não usei toda a sequência de animação para fazer ele atirando, usei apenas os prites que estão abaixo.

entrada do jogo
Figura 12 – Folha de sprites para atirando parado.

entrada do jogo
Figura 13 – Folha de sprites para atirando correndo.

Os dois mc’s vazios que você irá criar para fazer as animações vão se chamar respectivamente atirando e atirando_correndo. Agora iremos incorporar esses mc’s ao megaman propriamente dito que é aquele que está no stage e que estamos controlando via Action Script e que se chama megaman_mc. Portanto, vá à cena principal e dê um duplo clique no megaman_mc e adicione mais 4 frames aos frames existentes e chame-os respectivamente de: atirando_dir, atirando_esq, correndo_atirando_dir e correndo_atirando_esq. Cuidado com esses nomes sempre utilizo para referenciá-los no Action Script. As animações para os frames atirando_dir e correndo_atirando_dir já estão pronta (atirando e atirando_correndo), ou seja, a direção em que o personagem está olhando já está correta. Para fazer as animações para esquerda será usada a mesma técnica que consistia em usar a ferramenta Free Transform Tool para inverter o sentido da animação que já está pronta, se tiver ainda dúvidas quanto a esta parte consulte novamente a parte 1 deste artigo.

Depois de cada coisa no seu lugar, você agora precisa apenas colocar o seguinte código no último frame do mc atirando para que quando você atirar saiba para que lado deva parar e de tirar :

_root.atirando = false;
if(_root.direcao == “direita”)
_parent.gotoAndStop(“parado_dir”);
else
_parent.gotoAndStop(“parado_esq”);

E para o mc atirando_correndo coloque no último frame:

_root.atirando = false;
É moçada, agora falta apenas o código do coração do nosso game com as novas modificações e com a parte de tiros, com a possibilidade de correr atirando e pular atirando todas já incorporadas no código, então aí está:

stop();
/* Variáveis globais
* Aqui estão presentes as variáveis que fazem o
* controle dos estados
* em que o jogo se encontra
*/
var velSaltar:Number = 20;
var velAndar:Number = 0;
var pulando:Boolean = false;
var caindo:Boolean = false;
var morreu:Boolean = false;
var atirando:Boolean = false;
var velMax:Number = 10;
var direcao:String = “”;
var entrada:Boolean = true;
var contTiros:Number = 0; /*Contador de tiros*/
var tiroInterval:Number = getTimer(); /*utilizada para calcular o intervalo dos tiros*/
/*adiciona à classe MovieClip um atributo que indica a direção para onde está indo*/
MovieClip.prototype.direcao = “esquerda”; /*fazemos com que as layers que representam as paredes
* e a plataforma não apareçam na hora que
* o jogo for executado
*/
plataforma_mc._visible = false;
paredes_mc._visible = false;

/* Todo o controle do personagem Megaman*/
megaman_mc.onEnterFrame = function()
{
//verifica se ainda não acabou a entrada do Megaman
if(entrada)
return;

if(this._y > 350)
_root.gotoAndStop(“gameOver”);
/*verifica colisão com alguma parede do lado direito ou esquerdo
* Se houve colisão faz uma anulação do passo que ele deu para frente
*/
if( colisao_paredes(_root.paredes_mc, this, velAndar))
this._x-=velAndar;
/* simples simulação de gravidade
* Se ele não tiver em cima da plataforma então ele vai caindo
* sem aceleração
*/

if ( !colisao_plataforma(_root.plataforma_mc, this) && !pulando)
this._y += 6;

//se velocidade positiva estou andando para a
//direita senão estou indo para esquerda
if (velAndar>0)
direcao = “direita”;
else if (velAndar<0)
direcao = “esquerda”;

//só pula se não tiver pulando, claro
if ( Key.isDown(Key.SPACE) && !pulando )
{
pulando = true;

/*mostra a animação pulando para direita se o personagem
* está indo para a direita, caso contrário para a esquerda
*/

if(direcao == “direita”)
megaman_mc.gotoAndStop(“pulando_dir”);
else
megaman_mc.gotoAndStop(“pulando_esq”);
}

if( Key.isDown( Key.CONTROL) && (getTimer() – tiroInterval) > 200 )
{
_root.contTiros++;
_root.tiro_mc.duplicateMovieClip(“tiro”+_root.contTiros,_root.contTiros,_root.contTiros); //duplicamos o tiro
if(direcao == “direita”)
{
if(!Key.isDown( Key.RIGHT) )
this.gotoAndStop(“atirando_dir”);
_root["tiro"+_root.contTiros]._y = this._y+35;
_root["tiro"+_root.contTiros]._x = this._x+50;

}
else
{
if(!Key.isDown( Key.LEFT) )
this.gotoAndStop(“atirando_esq”);
_root["tiro"+_root.contTiros]._y = this._y+35;
_root["tiro"+_root.contTiros]._x = this._x-10;
}

tiroInterval = getTimer();

/*atribuindo direcao para o tiro*/
_root["tiro"+_root.contTiros].direcao = direcao;
atirando = true;

}

if( Key.isDown( Key.RIGHT) && atirando)
{
if( velAndar < velMax )
velAndar++;
if(!pulando)
megaman_mc.gotoAndStop(“correndo_atirando_dir”);
}
else if( Key.isDown( Key.LEFT) && atirando)
{
if ( velAndar > -velMax ) //não deixa o personagem acelerar muito
velAndar–;
if(!pulando)
megaman_mc.gotoAndStop(“correndo_atirando_esq”);
}
else if( Key.isDown( Key.RIGHT))
{
if( velAndar < velMax )
velAndar++;
if(!pulando)
megaman_mc.gotoAndStop(“correndo_dir”);
}
else if( Key.isDown( Key.LEFT) )
{
if ( velAndar > -velMax ) //não deixa o personagem acelerar muito
velAndar–;
if(!pulando)
megaman_mc.gotoAndStop(“correndo_esq”);
}
else if(!pulando && !entrada && !atirando)

{
//se não tiver acontecendo nada ele fica parado
if(direcao == “direita”)
megaman_mc.gotoAndStop(“parado_dir”);
else
megaman_mc.gotoAndStop(“parado_esq”);
velAndar = 0;
}

/* nosso personagem não é carro mas tem aceleração, que é .85
* mude para um valor alto e veja o resultado
*/
velAndar *= .85;

/*esta função faz o bendito scrolling*/
movimento(this, terreno_mc, plataforma_mc, paredes_mc, velAndar);

if( pulando )
{
/* mais física aqui, veja na figura 9 o que acontece aqui*/
this._y -= velSaltar;
velSaltar -= 1.8;
if (velSaltar<0)
caindo = true;
if (velSaltar <-15)
velSaltar = -15;
}

/* indica que o personagem emcima da plataforma, logo ele não está
* caindo e nem pulando é claro! E setamos novamente
*/
if ( colisao_plataforma( _root.plataforma_mc, this) && caindo)
{
velSaltar = 20;
pulando = false;
caindo = false;
}
};

function colisao_plataforma(obj1:Object, obj2:Object)
{
return obj1.hitTest(obj2._x, obj2._y+60, true);
}

function colisao_paredes(obj1:Object, obj2:Object, vel:Number)
{
return (obj1.hitTest(obj2._x-5, obj2._y+60, true) or obj1.hitTest(obj2._x+40, obj2._y+60, true))
}

function movimento(personagem_obj:Object, terreno_obj:Object,

limite_obj:Object,paredes_obj:Object, velocidade:Number)
{
if(direcao == “direita”)
{
/*se obedecer a condição abaixo, quem anda é o cenário*/
if(personagem_obj._x > 200 and terreno_obj._x >=-1853)
{
terreno_obj._x -= velocidade;
limite_obj._x -= velocidade;
paredes_obj._x -= velocidade;
}
else
personagem_obj._x += velocidade;
}

if(direcao == “esquerda”)
{
if(personagem_obj._x < 100 and terreno_obj._x < 0)
{
terreno_obj._x -= velocidade;
limite_obj._x -= velocidade;
paredes_obj._x -= velocidade;

}
else
personagem_obj._x += velocidade;
}
}

Considerações Finais

Bom pessoal, então isso. espero que tenham gostado fiz o máximo par ser claro e objetivo, dificilmente vocês encontraram um tutorial completo e comentado passo-a-passo de como contruir uma fase inteira de um game. Claro que poderiam ser abordados ainda mais assuntos, mas seria muito trabalho repetido e estenderia muito este artigo. Procurei abordar o que é necessário para se criar um game deste gênero. Agora coloque sua imaginação e criatividade e modfique o quanto quiser e aperfeiçoe para fique ainda melhor, como havia dito antes quero que entendam a técnica e não apenas aprender a fazer o jogo do “Megaman”, o meu intuito é que possam criar qualquer jogo com uma folha de sprites na mão e muita criatividade.

O Frame gameover eu não fiz por que fica a seu cargo decidir o que acontecer depois que o jogo acaba, no meu caso mostrei apenas meu nome e enderço de email com o título do artigo. O barulho que você ouve no início do jogo é apenas um arquivo inicio.wav que coloquei no primeiro frame do megaman_mc só pra dar mais emoção. Pra utilizá-lo basta importá-lo para a biblioteca via menu file->import->to library.

Se encontrarem problemas, vocês terão em mãos o mesmo código que usei para o exemplo funcional que está no início deste artigo. Olhe com cuidado cada etapa pois são muitos detalhes onde a falta de um causará um erro no game. Creio que não seja facil para quem está começando, mas estude bem os artigos anteriores para que se familiarize com a forma de como se programa um game. Fáça várias vezes se possível, a prática estimula a compreensão.


Espero que tenham gostado. Até a próxima.

Autor: Márcio Silva – Colunista de Flash & ActionSctipt MXSTUDIO.

Download dos arquivos

Qualquer dúvida envie um e-mail para marciosilva@mxstudio.com.br ou acesse nosso fórum


5 Comments to Criação de Games – Megaman Parte 2

  1. Giba's Gravatar Giba
    Abril 9, 2008 at 4:53 pm | Permalink

    classe a
    parabens Márcio

  2. gilmar's Gravatar gilmar
    Outubro 24, 2008 at 1:47 pm | Permalink

    muito bom otimoooo !!!! flash e demais!!!

  3. cavernoso's Gravatar cavernoso
    Novembro 5, 2008 at 3:04 pm | Permalink

    alguem sabe como fazer prá ele ir a outra fase…

  4. Felipe's Gravatar Felipe
    Julho 19, 2009 at 12:56 pm | Permalink

    legal, mas como seria para fazer a sintaxe para adcionar caso eu criasse uma animação do megaman usando uma espada e se o inimigo fosse atigido (o megaman é claro que não ia perder vida) e perdesse life?

  5. George Lucas's Gravatar George Lucas
    Abril 3, 2010 at 3:10 pm | Permalink

    O tutorial é show!!! Mas alguém faz idéia de como fazer ele carregar o tiro?

Deixe um Comentario

You can use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong> <pre lang="" line="">

Marcio Silva

Formado em Ciência da Computação pela Universidade Federal de Mato Grosso do Sul (UFMS) em 2007. Atualmente faz o curso de mestrado em Ciência da Computação na UFMS. Atua como Analista de Sistemas, fundador do Creative Render, portal voltado para o mundo 3D (www.creativerender.com).

Últimos Artigos do Autor