Códigos e Tuto de FLASH pra TETRIS

1- Crie um novo documento no FLASH ( Como são 10 por 20 blocos de 10 pixels, teriamos um documento de 200 por 400 pixels. Mas como vamos deixare um espaço na parte inferior da tela para exibir os numeros de linhas completadas e outras mensagens, acione o menu MODIFY.
> Docment e redimensione o arquivo para 200 por 430 pixels a taxa de 12 frames por segundo e clique OK>
2-Selecione a ferramente retângulo e desenhe um sobre o tamanho do coumento. NO painel de cores, clique no Fill Color, escolha um verde clarinho para o preenchimento. Selecione a linha de contorno e clique em Stroke color. Escolha um verde um pouco mais escuro, e aplique ao contorno. Salve o documento como jogodeblocos.fla.
3- Altere o nome da camada para script e no primeiro frame, acione a janela de ActionsScript (tecla f9 com o frame selecionado) para digitar o código. E acompanhe os passos a seguir:
4- Vamos começar o código definido a variavel que armazena o tamanho dos blocos em pixels:

var tamanhoBloco = 20;

E mais duas variaveis contendo os valores de maximo nuero de blocos possiveis, nas posições vertical e horizontal:

var maxBlocosVert = 20;
var maxBlocosHorz = 10;

Em seguida, incluimos mais uma serie de boleanas, iniciados com falso, e revertidas para verdadeiro conforme o desenho da peça

var formato_T = formato_L = formato_L_inv = formato_S = formato_Z = formato_linha = formato_quadrado = false;

Primeiro passo, concluido.
Em breve, o segundo

Eu só vou por os codigos agora:
var contador = O;
var velocidade = 10;
var nivelDeVelocidade = 8;
var contarFrame = 0;
var contarLinhas = 0;
var contaGiro = 0;
var ligado = false;
movieClipList = new Array();

Maiiss...

iniciaJogo = function ()
{
ligado = true;
contaLinhas = O;
velocidade = 10;
nivelDeVelocidade = 8;
contador = O;
criaNovoObjeto();
texto.text = contaLinhas+"linhas";
texto2.text =""';
};

reposiciona = function () {
blocos1._x = xx[O] * tamanhoBloco;
blocos2._x = xx[1] * tamanhoBloco;
blocos3._x = xx[2] * tamanhoBloco;
blocos4._x = xx[3] * tamanhoBloco;
};
criaNovoObjeto = function () {
// cada nova peça inicia-se com o contador de rotações zerado
contaGiro = O;
contador++;
var randa = (Math.floor(Math.random() *7));
formato_T = formato_ L = formato_L_inv = formato_S = formato_Z = formato_linha = formato_quadrado
= false;

0 - Linha
1 - L
2- L invertido
3- quadrado
4- S
5- Z
6- T

Refiz essa porra... ta aqui:
/*
1. O JOGO
Nosso jogo consiste num quadro onde cabem dez blocos na horizontal por vinte blocos na vertical. Do alto do quadro, caem peças formadas por quatro blocos, com diferentes combinações, que devem ser encaixadas de modo a completar linhas horizontais.
Quando uma linha horizontal é completada, ela é apagada da tela, e todos os blocos acima dela descem uma linha. O objetivo é formar o máximo de linhas possíveis. Se as linhas não forem completadas, as peças vão se empilhando. O jogo acaba quando a pilha de peças tocar a linha mais alta do quadro. Cada vez que uma linha é formada, somamos um ponto no escore.
O jogo é iniciado ao pressionarmos a barra de espaços. As peças são movimentadas no quadro para a direita ou para a esquerda, usando-se as respectivas teclas de seta. Cabe à seta para cima a tarefa de girar a peça, e à seta para baixo, a de acelerar a queda da peça.
São sete os desenhos das peças que caem, e elas serão desenhadas dinamicamente, pelos métodos de desenho do ActionScript, já associadas a um objeto do tipo movie clip, também criado dinamicamente. Para controlar o preenchimento do quadro, usaremos um array bidimensional, composto de 20 ocorrências, cada uma delas contendo outras 10 ocorrências, representando um espaço ocupado ou não por um bloco de peça. O desenho da peça é escolhido aleatoriamente entre os sete tipos e traçado com a informação de quais blocos devem ser preenchidos. Cada bloco tem o tamanho de 20 pixels.

2. A BASE
Crie um novo documento no Flash. Como são 10 por 20 blocos de 20 pixels, teríamos um documento de 200 por 400 pixels. Mas como vamos deixar um espaço na parte inferior da tela para exibir o número de linhas completadas e outras mensagens, acione o menu Modify > Document e redimensione o arquivo para 200 por 430 pixels a uma taxa de 12 frames por segundo. Clique OK.
3. O FUNDO
Selecione a ferramenta retângulo e desenhe um sobre e do tamanho do documento. No painel de cores, clique em Fill Color, escolha um verde clarinho para o preenchimento. Selecione a linha de contorno e clique em Stroke Color. Escolha um verde um pouco mais escuro e aplique ao contorno. Salve o documento como jogodeblocos.fla.

4. OS BLOCOS
Altere o nome da camada para Script e, no primeiro frame,
acione a janela de ActionsScript (tecle F9 com o frame selecionado) para digitar o código. Vamos começar definindo a variável que armazena o tamanho do bloco em pixels
*/
var tamanhoBloco = 20;
//e mais duas contendo os valores de máximo número de blocos possíveis na vertical e horizontal
var maxBlocosVert = 20;
var maxBlocosHorz = 10;
//Em seguida, incluímos mais uma série de boleanas, iniciadas com falso, e revertidas para verdadeiro conforme o desenho da peça.
var formato_T = formato_L = formato_L_inv = formato_S = formato_Z = formato_linha = formato_quadrado = false;

/* 5. OS CONTADORES
Agora, criamos um contador, que será usado para a criação de instâncias de movie clips e duas variáveis que serão usadas para controlar a velocidade com que a peça cai.
*/
var contador = 0;
var velocidade = 10;
var nivelDeVelocidade = 8;
//Para auxiliar no processamento, criamos mais três contadores: um de frames, um de linhas completadas e um de giro da peça.
var contaFrame = 0;
var contaLinhas = 0;
var contaGiro = 0;
//Criamos uma chave para saber se o jogo está correndo ou se está parado e um recipiente para guardarmos os movie clips usados numa partida, apenas para podermos limpá-los no reinício.
var ligado = false;
movieClipList = new Array();
/*6. AS POSIÇÕES
Vamos definir os dois arrays que conterão as posições dos quatro blocos que formam a peça. Ela terá os valores relativos à disposição de blocos dentro de uma grade de 4 por 4 blocos. Os valores iniciados aqui são equivalentes aos do formato linha:
*/
xx = new Array("1", "2", "3", "4");
yy = new Array("1", "1", "1", "1");
//Em seguida, definimos a tabela bidimensional, que é o mapa de como os blocos vão se dispor na tela, à medida que caem. Definimos também, dinamicamente, os campos de mensagem fora da área de jogo, atribuindo a ele um conteúdo inicial:

mapaDeBlocos = new Array();
for (var i = 0; i < maxBlocosHorz; i++) {
mapaDeBlocos[i] = new Array();
mapaDeBlocos[i][maxBlocosVert + 1] = 1;
}
createTextField("texto", 1000000, 0, 400, 200, 32);
createTextField("texto2", 1000001, 0, 413, 200, 32);
texto.text = contaLinhas + " linhas";
texto2.text = "Pressione a barra de espaços para jogar";

//Com esses procedimentos, criamos os alicerces sobre os quais o programa será construído.

/*7. AS INTERAÇÕES
O próximo passo é interceptar as interações do jogador, via teclado, e fazer com que o programa reaja de acordo com o solicitado. Para isso, criamos um objeto que vai “ouvir” o evento de tecla pressionada, e a ele associamos uma função.
*/
keyListener = new Object();
keyListener.onKeyDown = function() {
var k = Key.getCode();
//A variável boleana “ligado” recebe verdadeiro nos procedimentos de iniciação do jogo, e falso nos de finalização. Quando o jogo esta "desligado", qualquer tecla pressionada que não seja a barra de espaço é ignorada.
if ((!ligado) && (k != 32)) {
return
}
//Criamos então uma estrutura switch/case para agir conforme a tecla pressionada.
switch(k) {
// Se pressionada a barra de espaço,
case 32:
/* varre a tabela bidimensional com o mapa do quadro, limpando todas as 200 ocorrências de bloco possíveis. */
for (var i = 0; i <= maxBlocosVert; i++) {
for (var j = 0; j <= maxBlocosHorz; j++) {
mapaDeBlocos[j][i] = undefined;
}
}
for (var i = 0; i < movieClipList.length; i++) {
removeMovieClip(movieClipList[i]);
}
//Chamamos função para iniciar o jogo e saímos da estrutura switch/case. Se pressionada seta para cima, mudamos as coordenadas dos quatro blocos que cada peça, de modo a girá-la na tela.
iniciaJogo();
break;
case 38:
if (formato_linha) {
if (contaGiro == 0) {
if (mapaDeBlocos[xx[0] + 2][yy[0] - 1] == undefined && mapaDeBlocos[xx[1] + 1][yy[1]] == undefined && mapaDeBlocos[xx[2]][yy[2] + 1] == undefined && mapaDeBlocos[xx[3] - 1][yy[3] + 2] == undefined) {
//Caso exista espaço para a rotação da peça, as novas coordenadas são confirmadas, e o o contador de giros vai indicar a nova posição da peça.
xx[0] = xx[0] + 2;
yy[0] = yy[0] - 1;
xx[1] = xx[1] + 1;
yy[2] = yy[2] + 1;
xx[3] = xx[3] - 1;
yy[3] = yy[3] + 2;

contaGiro++;
}
} else {
//Todo o procedimento de teste e reposicionamento é feito para a nova posição desejada, o estado 1, deitado.
if (mapaDeBlocos[xx[0] - 2][yy[0] + 1] == undefined && mapaDeBlocos[xx[1] - 1][yy[1]] == undefined && mapaDeBlocos[xx[2]][yy[2] - 1] == undefined && mapaDeBlocos[xx[3] + 1][yy[3] - 2] == undefined && blocos1._x != 0 && blocos1._x != 20 && blocos1._x != 180) {
xx[0] = xx[0] - 2;
yy[0] = yy[0] + 1;
xx[1] = xx[1] - 1;
yy[2] = yy[2] - 1;
xx[3] = xx[3] + 1;
yy[3] = yy[3] - 2;
//O contador volta à posição original, como se a peça não houvesse sido girada.
contaGiro = 0;
}
}
//A seguir, invocamos a função de usuário para reposicionar os quatro blocos que formam a peça conforme a nova posição.
reposiciona();
/*Esse mesmo procedimento é repetido para todos os formatos, com exceção do formato quadrado, que se fosse girado teria a mesma forma.
O contador de giros é sempre usado para controlar o estado atual de rotação da peça, lembrando que as peças de formato linha, S e Z, têm apenas dois estados de rotação, de pé e deitado, enquanto que as outras têm quatro, exceto as de formato quadrado, que só tem um.
*/
} else if(formato_L) {
if (contaGiro == 0) {
if (mapaDeBlocos[xx[0] + 1][yy[0] - 1] == undefined && mapaDeBlocos[xx[2] - 1][yy[2] + 1] == undefined && mapaDeBlocos[xx[3]][yy[3] - 2] == undefined) {
xx[0] = xx[0] + 1;
yy[0] = yy[0] - 1;
xx[2] = xx[2] - 1;
yy[2] = yy[2] + 1;
yy[3] = yy[3] - 2;
contaGiro++;
}
} else if (contaGiro == 1) {
if (mapaDeBlocos[xx[0] - 1][yy[0] + 1] == undefined && mapaDeBlocos[xx[2] - 1][yy[2] - 2] == undefined && mapaDeBlocos[xx[3]][yy[3] + 1] == undefined && blocos1._x != 0) {
xx[0] = xx[0] - 1;
yy[0] = yy[0] + 1;
xx[2] = xx[2] - 1;
yy[2] = yy[2] - 2;
yy[3] = yy[3] + 1;
contaGiro++;
}
} else if (contaGiro == 2) {
if (mapaDeBlocos[xx[0]][yy[0] + 1] == undefined && mapaDeBlocos[xx[2] + 1][yy[2]] == undefined && mapaDeBlocos[xx[3] - 1][yy[3] + 1] == undefined) {
yy[0] = yy[0] + 1;
xx[2] = xx[2] + 1;
xx[3] = xx[3] - 1;
yy[3] = yy[3] + 1;
contaGiro++;
}
} else {
if (mapaDeBlocos[xx[0]][yy[0] - 1] == undefined && mapaDeBlocos[xx[2] + 1][yy[2] + 1] == undefined && mapaDeBlocos[xx[3] + 1][yy[3]] == undefined && xx[0] != {
yy[0] = yy[0] - 1;
xx[2] = xx[2] + 1;
yy[2] = yy[2] + 1;
xx[3] = xx[3] + 1;
contaGiro = 0;
}
}
reposiciona();
}
else if (formato_L_inv) {
if (contaGiro == 0) {
if (mapaDeBlocos[xx[0] + 1][yy[0] - 1] == undefined && mapaDeBlocos[xx[2] + 1][yy[2]] == undefined && mapaDeBlocos[xx[3]][yy[3] + 1] == undefined) {
xx[0] = xx[0] + 1;
yy[0] = yy[0] - 1;
xx[2] = xx[2] + 1;
yy[3] = yy[3] + 1;
contaGiro++;
}
} else if (contaGiro == 1) {
if (mapaDeBlocos[xx[0] - 1][yy[0] + 1] == undefined && mapaDeBlocos[xx[2] + 1][yy[2] - 1] == undefined && mapaDeBlocos[xx[3]][yy[3] - 2] == undefined && blocos1._x != 0) {
xx[0] = xx[0] - 1;
yy[0] = yy[0] + 1;
xx[2] = xx[2] + 1;
yy[2] = yy[2] - 1;
yy[3] = yy[3] - 2;
contaGiro++;
}
} else if (contaGiro == 2) {
if (mapaDeBlocos[xx[0]][yy[0] - 1] == undefined && mapaDeBlocos[xx[2] - 1][yy[2] + 1] == undefined && mapaDeBlocos[xx[3] - 1][yy[3]] == undefined) {
yy[0] = yy[0] - 1;
xx[2] = xx[2] - 1;
yy[2] = yy[2] + 1;
xx[3] = xx[3] - 1;
contaGiro++;
}
} else {
if (mapaDeBlocos[xx[0]][yy[0] + 1] == undefined && mapaDeBlocos[xx[2] - 1][yy[2]] == undefined && mapaDeBlocos[xx[3] + 1][yy[3] + 1] == undefined && xx[0] != {
yy[0] = yy[0] + 1;
xx[2] = xx[2] - 1;
xx[3] = xx[3] + 1;
yy[3] = yy[3] + 1;
contaGiro = 0;
}
}
reposiciona();
} else if (formato_S) {
if (contaGiro == 0) {
if (mapaDeBlocos[xx[0] + 1][yy[0] - 2] == undefined && mapaDeBlocos[xx[1] + 1][yy[1]] == undefined) {
xx[0] = xx[0] + 1;
yy[0] = yy[0] - 2;
xx[1] = xx[1] + 1;
contaGiro++;
}
} else {
if (mapaDeBlocos[xx[0] - 1][yy[0] + 2] == undefined && mapaDeBlocos[xx[1] - 1][yy[1]] == undefined && blocos1._x != 0) {
xx[0] = xx[0] - 1;
yy[0] = yy[0] + 2;
xx[1] = xx[1] - 1;
contaGiro = 0;
}
}
reposiciona();
} else if (formato_Z) {
if (contaGiro == 0) {
if (mapaDeBlocos[xx[0] + 1][yy[0]] == undefined && mapaDeBlocos[xx[1] + 1][yy[1]] == undefined && mapaDeBlocos[xx[3]][yy[3] - 2] == undefined) {
xx[0] = xx[0] + 1;
xx[1] = xx[1] + 1;
yy[3] = yy[3] - 2;
contaGiro++;
}
} else {
if (mapaDeBlocos[xx[0] - 1][yy[0]] == undefined && mapaDeBlocos[xx[1] - 1][yy[1]] == undefined && mapaDeBlocos[xx[3]][yy[3] + 2] == undefined && blocos1._x != 0) {
xx[0] = xx[0] - 1;
xx[1] = xx[1] - 1;
yy[3] = yy[3] + 2;
contaGiro = 0;
}
}
reposiciona();
} else if (formato_T) {
if (contaGiro == 0) {
if (mapaDeBlocos[xx[0] + 1][yy[0] - 1] == undefined) {
xx[0] = xx[0] + 1;
yy[0] = yy[0] - 1;
contaGiro++;
}
} else if (contaGiro == 1) {
if (mapaDeBlocos[xx[0] - 1][yy[0] + 1] == undefined && mapaDeBlocos[xx[2]][yy[2] - 2] == undefined && blocos1._x != 0) {
xx[0] = xx[0] - 1;
yy[0] = yy[0] + 1;
yy[2] = yy[2] - 2;
contaGiro++;
}
} else if (contaGiro == 2) {
if (mapaDeBlocos[xx[3] - 1][yy[3] + 1] == undefined) {
xx[3] = xx[3] - 1;
yy[3] = yy[3] + 1;
contaGiro++;
}
} else {
if (mapaDeBlocos[xx[2]][yy[2] + 2] == undefined && mapaDeBlocos[xx[3] + 1][yy[3] - 1] == undefined && blocos1._x != 160) {
yy[2] = yy[2] + 2;
xx[3] = xx[3] + 1;
yy[3] = yy[3] - 1;
contaGiro = 0;
}
}
reposiciona();
}
break;
/* caso tenha sido pressionada a tecla seta para a direita */
case 39:
/* checa a disponibilidade de todas as coordenadas dos quatro blocos uma posição a direita no mapa de blocos */
if (blocos4._x != 180 && mapaDeBlocos[xx[0] - 1][yy[0]] == undefined && mapaDeBlocos[xx[1] - 1][yy[1]] == undefined && mapaDeBlocos[xx[2] - 1][yy[2]] == undefined && mapaDeBlocos[xx[3] - 1][yy[3]] == undefined && mapaDeBlocos[xx[0] + 1][yy[0]] == undefined && mapaDeBlocos[xx[1] + 1][yy[1]] == undefined && mapaDeBlocos[xx[2] + 1][yy[2]] == undefined && mapaDeBlocos[xx[3] + 1][yy[3]] == undefined) {
/* e, em caso afirmativo, recalcula as coordenadas x de cada bloco uma posição à direita. */
for (var i = 0; i < 4; i++) {
xx[i]++;
}
reposiciona();
}
break;
/* fazemos teste e procedimentos semelhantes ao da seta para a direita quando a tecla pressionada for a seta para a esquerda */
case 37:
if (blocos1._x != 0 && mapaDeBlocos[xx[0] - 1][yy[0]] == undefined && mapaDeBlocos[xx[1] - 1][yy[1]] == undefined && mapaDeBlocos[xx[2] - 1][yy[2]] == undefined && mapaDeBlocos[xx[3] - 1][yy[3]] == undefined && mapaDeBlocos[xx[0] + 1][yy[0]] == undefined && mapaDeBlocos[xx[1] + 1][yy[1]] == undefined && mapaDeBlocos[xx[2] + 1][yy[2]] == undefined && mapaDeBlocos[xx[3] + 1][yy[3]] == undefined) {
for (var i = 0; i < 4; i++) {
xx[i]--;
}
reposiciona();
}
break
}

};
//Concluímos o tratamento da tecla pressionada assinalando o objeto Keylistener, criado acima, à classe Key por meio do método addListener. Esse procedimento amarra a função que acabamos de definir ao teclado do computador e faz o Flash Player “ouvir” a tecla pressionada:
Key.addListener(keyListener);

/*8. OS DETALHES
Acertado o fluxo lógico do programa, partimos para a definição das funções de usuário que controlarão os detalhes do jogo. Começamos com a função que inicia o jogo, chamada quando a barra de espaços é pressionada:
*/
iniciaJogo = function ()
{
// ligamos chave que indica ao programa que a barra de espaços foi pressionada e o jogo está ativo
ligado = true;
// iniciamos o contadores
contaLinhas = 0;
velocidade = 10;
nivelDeVelocidade = 8;
contador = 0;
// e invocamos o método que criará um novo movieclip, a próxima peça a cair no jogo
criaNovoObjeto();
// e mostramos o placar de linhas zerado na tela
texto.text = contaLinhas + " linhas";
texto2.text = "";
};

/*9. FINALIZAR
Passamos para a função que finaliza o jogo, invocada quando a pilha de peças toca o topo do mapa de blocos:
*/
fimDeJogo = function () {
//Desligamos a chave, indicando ao programa que o jogo está inativo até que se pressione novamente a barra de espaços
ligado = false;
//e mostramos o placar final da partida, montando uma string com o valor da variável contaLinhas
if (contaLinhas == 1) {
texto.text = "1 linha - Fim de Jogo";
} else {
texto.text = contaLinhas+" linhas - Fim de Jogo";
}
texto2.text = "Pressione a barra de espaços para jogar";
};

/*10. REPOSICIONAR
Aqui, definimos a função de usuário que reposiciona as peças giradas com a tecla seta para cima. Usam-se as referências de posição contidas nos arrays xx e yy multiplicados pelo valor do tamanho em pixels de cada bloco, contido na variável tamanhoBloco.
*/
reposiciona = function () {
blocos1._x = xx[0] * tamanhoBloco;
blocos2._x = xx[1] * tamanhoBloco;
blocos3._x = xx[2] * tamanhoBloco;
blocos4._x = xx[3] * tamanhoBloco;
};

//Passamos para a função que cria randomicamente os objetos que caem no jogo. Essa rotina pega um número de 0 a 6 aleatoriamente usando o método random() e associa esse número a um dos formatos de peça. Dependendo desse formato, define as posições dos quatro blocos que o formam. Ao final, invoca a função que transforma essas coordenadas em uma instância de movie clip.

criaNovoObjeto = function () {
// cada nova peça inicia-se com o contador de rotações zerado
contaGiro = 0;
// e incrementamos 1 no contador usado para criação de instâncias do movieClip.
contador++;
// usamos os método floor() e random(), da classe Math, para obter um número aleatório entre 0 e 6;
var rand = (Math.floor(Math.random() * 7));
// e iniciamos todas as boleanas que indicarão o formato da peça com falso:
formato_T = formato_L = formato_L_inv = formato_S = formato_Z = formato_linha = formato_quadrado = false;
/*A amarração do número com as peças é previamente definido:
0 - linha
1 - L
2 - L invertido
3 - quadrado
4 - S
5 - Z
6 - T*/
//A partir de agora, definimos as posições de cada um dos quatro blocos que compõem a peça escolhida.

switch (rand) {
// em cada caso específico
case 0:
// assinalamos a variável da respectiva boleana como verdadeira
formato_linha = true;
// definimos a posição de cada bloco dentro da peça
for (var i = 0; i < 4; i++) {
xx[i] = i;
yy[i] = 0;
}
// e saímos da estrutura switch / case
break;
case 1:
formato_L = true;
xx[0] = 0;
yy[0] = 0;
xx[1] = 1;
yy[1] = 0;
xx[2] = 2;
yy[2] = 0;
xx[3] = 2;
yy[3] = 1;
break;
case 2:
formato_L_inv = true;
xx[0] = 0;
yy[0] = 0;
xx[1] = 1;
yy[1] = 0;
xx[2] = 0;
yy[2] = 1;
xx[3] = 2;
yy[3] = 0;
break;
case 3:
formato_quadrado = true;
xx[0] = 0;
yy[0] = 0;
xx[1] = 0;
yy[1] = 1;
xx[2] = 1;
yy[2] = 1;
xx[3] = 1;
yy[3] = 0;
break;
case 4:
formato_S = true;
xx[0] = 0;
yy[0] = 1;
xx[1] = 1;
yy[1] = 1;
xx[2] = 1;
yy[2] = 0;
xx[3] = 2;
yy[3] = 0;
break;
case 5:
formato_Z = true;
xx[0] = 0;
yy[0] = 0;
xx[1] = 1;
yy[1] = 0;
xx[2] = 1;
yy[2] = 1;
xx[3] = 2;
yy[3] = 1;
break;
case 6:
formato_T = true;
xx[0] = 0;
yy[0] = 0;
xx[1] = 1;
yy[1] = 0;
xx[2] = 1;
yy[2] = 1;
xx[3] = 2;
yy[3] = 0;
break;
}
//Por fim, invocamos a função que cria o movie clip no formato da peça, mostrando-o na tela.
carregaNovoObjeto();
};
carregaNovoObjeto = function () {
//Agora, checamos se qualquer um dos blocos das colunas 3 a 6 da primeira linha no topo do quadro estão ocupados. Em caso afirmativo, o jogo termina.
if (mapaDeBlocos[3][0] != undefined || mapaDeBlocos[4][0] != undefined || mapaDeBlocos[5][0] != undefined || mapaDeBlocos[6][0] != undefined) {
fimDeJogo();
} else {
//Se não, checamos cada uma das linhas do quadro, procurando linhas completas.
for (var i = 0; i <= maxBlocosVert; i++) {
//Testamos o preenchimento de cada um dos blocos da linha.
if (mapaDeBlocos[0][i] != undefined && mapaDeBlocos[1][i] != undefined && mapaDeBlocos[2][i] != undefined && mapaDeBlocos[3][i] != undefined && mapaDeBlocos[4][i] != undefined && mapaDeBlocos[5][i] != undefined && mapaDeBlocos[6][i] != undefined && mapaDeBlocos[7][i] != undefined && mapaDeBlocos[8][i] != undefined && mapaDeBlocos[9][i] != undefined) {
/* E em caso positivo, ou seja, linha completa, */
for (var j = 0; j < maxBlocosHorz; j++) {
// removemos a referida linha do mapa de blocos
removeMovieClip(mapaDeBlocos[j][i]);
// e movemos as linhas acima dela para baixo, preenchendo o espaço deixado,
for (var k = 0; k < maxBlocosVert; k++) {
// somando o valor do tamanho do bloco, 20 pixels, na sua coordenada Y
mapaDeBlocos[j][i - k]._y += tamanhoBloco;
// e trazendo o conteúdo do bloco de cima para baixo uma posição
mapaDeBlocos[j][i - k] = mapaDeBlocos[j][i - k - 1];
}
}
// somamos um no placar de linhas
contaLinhas++;
// e atualizamos o texto com o placar mostrado na tela
if (contaLinhas == 1) {
texto.text = contaLinhas + " linha";
} else {
texto.text = contaLinhas + " linhas";
}
//A cada dez linhas completadas, tiramos um na variável nivelDeVelocidade, usada para calcular a velocidade de queda da peça, a não ser que essa variável já esteja com o valor mínimo. Para isso, usamos o operador módulo (%), testando o resto da divisão do número de linhas completadas por 10.
if (contaLinhas % 10 == 0 && nivelDeVelocidade > 1) {
nivelDeVelocidade--;
}
}
}
//Deslocamos a coordenada X da peça para o centro da tela, para que ela caia a partir do meio.
xx[0] = xx[0] + 3;
xx[1] = xx[1] + 3;
xx[2] = xx[2] + 3;
xx[3] = xx[3] + 3;
//Escolhemos uma cor aleatória para o nosso objeto
cor = Math.random( ) * 255 * 255 * 255;
//e criamos uma instância de movie clip para cada um dos quatro blocos que formam a peça, com nome e profundidade tirados do valor do contador:
peca = _root.createEmptyMovieClip("blocos1" + contador, contador * 4);
desenhaBloco(cor,"blocos1" + contador);
this["blocos1" + contador]._x = xx[0] * tamanhoBloco;
this["blocos1" + contador]._y = yy[0] * tamanhoBloco;
peca = _root.createEmptyMovieClip("blocos2" + contador, contador * 4 + 1);
desenhaBloco(cor,"blocos2" + contador);
this["blocos2" + contador]._x = xx[1] * tamanhoBloco;
this["blocos2" + contador]._y = yy[1] * tamanhoBloco;
peca = _root.createEmptyMovieClip("blocos3" + contador, contador * 4 + 2);
desenhaBloco(cor,"blocos3" + contador);
this["blocos3" + contador]._x = xx[2] * tamanhoBloco;
this["blocos3" + contador]._y = yy[2] * tamanhoBloco;
peca = _root.createEmptyMovieClip("blocos4" + contador, contador * 4 + 3);
desenhaBloco(cor,"blocos4" + contador);
this["blocos4" + contador]._x = xx[3] * tamanhoBloco;
this["blocos4" + contador]._y = yy[3] * tamanhoBloco;
// e para essa peça, associa nomes básicos para cada um dos quatro blocos
blocos1 = _root["blocos1" + contador];
blocos2 = _root["blocos2" + contador];
blocos3 = _root["blocos3" + contador];
blocos4 = _root["blocos4" + contador];
// e guarda referência deles na Array movieClipList, para poder apagá-los da tela quando o jogo for reiniciado.
movieClipList.push(blocos1);
movieClipList.push(blocos2);
movieClipList.push(blocos3);
movieClipList.push(blocos4);
}
};

/*12. OS FRAMES
Agora, definimos a função para o evento onEnterFrame, que ocorre a cada vez que o programa entra num novo frame. Como temos uma taxa de 12 fps, esse evento ocorrerá 12 vezes a cada segundo.
*/
_root.onEnterFrame = function() {
if (!ligado) {
return;
}
contaFrame++;
blocos4._y = (yy[3] - 1) * tamanhoBloco;
blocos3._y = (yy[2] - 1) * tamanhoBloco;
blocos2._y = (yy[1] - 1) * tamanhoBloco;
blocos1._y = (yy[0] - 1) * tamanhoBloco;
if (Key.isDown(Key.DOWN)) {
velocidade = 1;
} else {
velocidade = nivelDeVelocidade;
}
//A movimentação da peça ocorre apenas a um determinado número de frames, determinado pelo campo velocidade e testado com o operador módulo:

if (contaFrame % velocidade == 0) {
// checa se a nova posição da peça não atingiu o fundo ou algum bloco de outra peça,
if (mapaDeBlocos[xx[0]][yy[0] + 1] == undefined && mapaDeBlocos[xx[1]][yy[1] + 1] == undefined && mapaDeBlocos[xx[2]][yy[2] + 1] == undefined && mapaDeBlocos[xx[3]][yy[3] + 1] == undefined) {
// Em caso afirmativo, movimenta a peça uma posição para baixo
blocos4._y = yy[3] * tamanhoBloco;
blocos3._y = yy[2] * tamanhoBloco;
blocos2._y = yy[1] * tamanhoBloco;
blocos1._y = yy[0] * tamanhoBloco;
// E incrementa os valores de y armazenados da peça
for (var i = 0; i < 4; i++) {
yy[i]++;
}
} else {
// Mas, caso a peça tenha atingido o fundo ou outro bloco, assinala cada um dos blocos dela no mapa geral do quadro e cria uma nova peça
mapaDeBlocos[xx[0]][yy[0]] = blocos1;
mapaDeBlocos[xx[1]][yy[1]] = blocos2;
mapaDeBlocos[xx[2]][yy[2]] = blocos3;
mapaDeBlocos[xx[3]][yy[3]] = blocos4;
criaNovoObjeto();
/* e assinala um valor inicial ao contador de frames, para evitar que no próximo frame ele já entre nesse if,
já saindo uma posição abaixo no quadro */
contaFrame = 7;
}
}
};

/*13. DESENHO
Por fim, a função de usuário que utiliza os métodos de traço e preenchimento do ActionScript para desenhar cada bloco de peça, que é invocada da função carregaNovoObjeto:
*/
function desenhaBloco(vcor, obj) {

_root[obj].beginFill(vcor);
_root[obj].lineStyle(0);
_root[obj].lineTo(20, 0);
_root[obj].lineTo(20, 20);
_root[obj].lineTo(0, 20);
_root[obj].endFill();