Resultado final:

Tiro ao alvo - clique nos logotipos voadores para derrubá-los. Acompanhe seus cliques, acertos, erros e a sua precisão.

Código:

  1. class="codigo">/*

  2. Animação Programada
  3. Este exemplo mostra como criar, posicionar, animar, testar acerto da figura com o mouse e deletar MCs (movieClips)
  4. */
  5. /*
  6. Definição das variáveis que serão usadas para estatísticas
  7. */
  8. _global.acertos = 0; //Armazena a quantidade de logos atingidos
  9. _global.erros = 0; // Armazena a quantidade de logos que “fugiram”
  10. _global.cliques = 0; // Armazena a quantidad e cliques (acertos e erros)
  11. _global.cProfundidade = 100;
  12. _global.nivel = 1;
  13. /*
  14. Definição das variáveis (tempo de execução) que serão usadas nos cálculos
  15. */
  16. var xVelocidade:Number = 3;
  17. var larguraStage:Number = 550; //Definição da área dos cliques
  18. var alturaStage:Number = 580; // Definição da área dos cliques
  19. /*
  20. Inclusão a instância do MC alvo_mc da Library no Stage.
  21. Este clip será usado como um cursor personalizado
  22. */
  23. this.attachMovie(”alvo_mc”, “alvo_mc”, 5001);
  24. /*
  25. Oculta o cursor do mouse
  26. */
  27. Mouse.hide();
  28. /*
  29. Cria Listener para o Mouse
  30. */
  31. var mouseListener:Object = new Object();
  32. /*
  33. Sempre que o cursor do mouse mover-se para fora do arquivo SWF, a posição será atualizada na instância do alvo_mc no Stage.
  34. */
  35. mouseListener.onMouseMove = function() {
  36.    alvo_mc._x = _xmouse;
  37.    alvo_mc._y = _ymouse;
  38. };
  39. /*
  40. Quando o botão do mouse é clicado, verificar se o cursor está fora dos limites do Stage.
  41. Em caso positivo, incrementa o número de cliques dados
  42. */
  43. mouseListener.onMouseDown = function() {
  44.    _global.cliques++;
  45.    if (fundo_mc.hitTest(_xmouse, _ymouse, false)) {
  46.       _global.acertos++;
  47.    }
  48. };
  49. Mouse.addListener(mouseListener);
  50. /*
  51. Define um TextFormat que é usado para formatar o campo estatisticas_txt.
  52. */
  53. var meu_textoFormatado:TextFormat = new TextFormat();
  54. meu_textoFormatado.bold = true;
  55. meu_textoFormatado.font = “Arial”;
  56. meu_textoFormatado.size = 12;
  57. meu_textoFormatado.color = 0×000000;
  58. /*
  59. Cria um campo texto para mostrar as estatísticas do jogador.
  60. */
  61. this.createTextField(”estatisticas_txt”, 5000, 10, 0, 530, 22);
  62. /*
  63. Aplica o TextFormat no campo texto.
  64. */
  65. estatisticas_txt.setNewTextFormat(meu_textoFormatado);
  66. estatisticas_txt.selectable = false;
  67. updateStats();
  68. /*
  69. Inclui um evento onEnterFrame na timeline principal para que um novo logo seja constantemente gerado no jogo.
  70. */
  71. this.onEnterFrame = function() {
  72.    /*
  73.    Inclui aleatoriamente um novo logo
  74.    */
  75.    if (randRange(0, 20) == 0) {
  76.       /*
  77.       anexa uma nova instância do logo da Library no Stage e define uma profundidade única
  78.       */
  79.       var randomLogo:Number = randRange(1, 3);
  80.       /*
  81.       Observe que o nome do MC a seguir é obtido pelo Flash através do Identifier do Linkage (clique com o botão direito
  82.       do mouse sobre o objeto na Library e escolha Linkage…)
  83.       */
  84.       var thisMC:MovieClip = this.attachMovie(”logo”+randomLogo+”_mc”, “logoAlvo”+_global.cProfundidade+”_mc”, _global.cProfundidade);
  85.       _global.cProfundidade++;
  86.       /*
  87.       Configura a posição inicial do logoAlvo_mc à esquerda do Stage
  88.       */
  89.       thisMC._x = -thisMC._width;
  90.       /*
  91.       Cria um número aleatório entre 80 e 100.
  92.       Será usado para o tamanho (escala) do MC atual, alpha e velocidade
  93.       que se moverá pelo Stage.
  94.       */
  95.       var escala = randRange(80, 100);
  96.       /*
  97.       Configura as propriedades do _xescala e _yescala no MC atual.*/
  98.       */
  99.       thisMC._xescala = escala;
  100.       thisMC._yescala = escala;
  101.       thisMC._alpha = escala;
  102.       thisMC.speed = xVelocidade+randRange(0, 3)+_global.nivel;
  103.       /*
  104.       Configura um valor aleatório para _y.
  105.       Agora, ao invés de todos os logos voarem sobre o mesmo caminho,
  106.       eles variam sua posição vertical levemente. */
  107.       */
  108.       thisMC._y = Math.round(Math.random()*350)+65;
  109.       /*
  110.       Cria um manipulador onEnterFrame que executam algumas dúzias de vezes por segundo */
  111.       */
  112.       thisMC.onEnterFrame = function() {
  113.          /*
  114.          Move o logo horizontalmente ao longo do Stage.
  115.          No momento todos os logos movem-se da esquerda para a direita
  116.          */
  117.          this._x += this.speed;
  118.          /*
  119.          Decrementa levemente a posição do _y no MC atual.
  120.          Isto faz com que pareça que os logos estejam voando
  121.          levemente mais alto do que movem-se no Stage.
  122.          */
  123.          this._y -= .4;
  124.          /*
  125.          Se a posição atual do logo é maior do que o Stage,
  126.          conta o logo como “perdido” e apaga sua instância.
  127.          */
  128.          if (this._x>larguraStage) {
  129.             _global.erros++;
  130.             updateStats();
  131.             this.removeMovieClip();
  132.          }
  133.       };
  134.       /*
  135.       Quando o logo é pressionado, contar como um “acerto”
  136.       */
  137.       thisMC.onPress = function() {
  138.          /*
  139.          Atualizar as estatísticas do jogador
  140.          */
  141.          _global.acertos++;
  142.          if ((_global.acertos%40) == 0) {
  143.             _global.nivel++; // Mudança de nível
  144.          }
  145.          updateStats();
  146.          /*
  147.          Vai para o rótulo do MC chamado “hit”
  148.          (que permite você mostrar uma animação engenhosa quando a
  149.          instância é atingida.)
  150.          */
  151.          this.gotoAndPlay(”hit”);
  152.          /*
  153.          Configura algumas variáveis locais que você usará para
  154.          animar o logo caindo pelo Stage.
  155.          */
  156.          var ymov = this._y;
  157.          var gravity = 20;
  158.          /*
  159.          Cria um evento onEnterFrame para a instância do MC atual.
  160.          */
  161.          this.onEnterFrame = function() {
  162.             ymov += gravity;
  163.             xmov *= 0.5;
  164.             /*
  165.             Incrementa a rotação do MC atual no sentido horário em 5 graus.
  166.             */
  167.             this._rotation += 5;
  168.             /*
  169.             Configura as propriedades _x e _y do MC no Stage,
  170.             isto permite-nos fazer com que a queda
  171.             seja mais realista
  172.             */
  173.             this._x += xVelocidade;
  174.             this._y = ymov;
  175.             /*
  176.             Após anular a posição _y position no Stage,
  177.             remova o MC para que suas coordenadas não sejam
  178.             continuamente calculadas */
  179.             if (this._y>alturaStage) {
  180.                this.removeMovieClip();
  181.             }
  182.          };
  183.          /*
  184.          Apagar o manipulador de evento onPress.
  185.          Isto faz com que o logo não possa ser continuamente clicado
  186.          enquanto ele está caindo pelo Stage.
  187.          */
  188.          delete this.onPress;
  189.       };
  190.    }
  191. };
  192. /*
  193. Função que atualiza as estatísticas no Stage
  194. */
  195. function updateStats() {
  196.    var precisao:Number = Math.round((_global.acertos/_global.cliques)*100);
  197.    if (isNaN(precisao)) {
  198.       precisao = 0;
  199.    }
  200.    estatisticas_txt.text = “Cliques: “+_global.cliques+” “+”Acertos: “+_global.acertos+” “+”Erros: “+_global.erros+” “+”Precisão: “+precisao+”%”+” “+”Nível: “+_global.nivel;
  201. }
  202. /*
  203. Função que retorna um inteiro aleatório entre dois números especificados. Isto permite que você inclua algumas diferenças sutis de tamanho e
  204. velocidade para o MC no Stage.
  205. */
  206. function randRange(minNum:Number, maxNum:Number):Number {
  207.    return (Math.floor(Math.random()*(maxNum-minNum+1))+minNum);
  208. }

Tutorial extraído do site MXStudio. Veja na íntegra >>