case técnico

Jogo • Arcade no navegador

Mata Alien

Remake do Mata Mosquito, um dos meus primeiros projetos em JavaScript: os tripulantes do OVNI do site descem e é preciso acertar cada um antes que a nave venha buscá-lo. JavaScript puro, sem imagens nem bibliotecas.

Game design, front-end e som Jogável Remake de um projeto de estudo
JavaScript HTML CSS SVG Web Audio PHP
resumo executivo

Problema

O Mata Mosquito original, feito enquanto eu aprendia JavaScript, tinha quatro páginas HTML, níveis que não mudavam nada e só funcionava bem com mouse.

Solução

Reescrevi o jogo do zero numa página só, com os aliens do OVNI do site, três níveis de verdade, combo, aliens especiais, sons gerados no navegador e suporte a toque.

Resultado

Um arcade rápido que roda em qualquer navegador sem baixar nenhuma imagem ou som, com recordes salvos e versão em português e inglês.

Estado atual

Pronto para ir ao ar no subdomínio de jogos.

contexto

Um primeiro projeto, refeito com o que aprendi depois

O Mata Mosquito foi um dos meus primeiros projetos em JavaScript: clicar no mosquito antes que ele sumisse. O Mata Alien mantém a ideia (3 vidas e aguentar até o tempo acabar) e corrige o que não funcionava: o nível escolhido não mudava o intervalo, “Normal” e “normal” nunca batiam, eram 4 vidas em vez de 3 e “Reiniciar” voltava sem nível. Os alvos agora são os tripulantes do OVNI que voa pelo portfolio.

objetivos e restrições

Objetivos

  • Manter a ideia do original: acertar antes que fuja, 3 vidas e 30 segundos
  • Níveis que realmente mudam ritmo, quantidade e movimento
  • Funcionar no toque tão bem quanto no mouse
  • Nenhum arquivo de mídia: aliens em SVG e sons gerados na hora
  • Dar motivo para jogar de novo: combo, recordes e desafio por link

Restrições

  • Uma página só, sem bibliotecas e sem imagens
  • Animação fluida no celular, sem travar a página
  • Navegadores só liberam áudio depois do primeiro toque
  • Pausar sozinho quando a aba perde o foco
arquitetura da solução

Front-end

index.php com as telas de menu, pausa e fim; game.css com o visual. Aliens, nave e ícones são símbolos SVG reaproveitados, e as variações (verde, dourado, de capacete) trocam as cores por variáveis CSS.

Back-end

game.js roda tudo num único laço com requestAnimationFrame e relógio próprio: pausar congela até o tempo de vida de cada alien. Os aliens se movem só com transform e as partículas ficam num canvas separado.

Banco de dados

Sem banco de dados: recordes, nível escolhido e preferência de som ficam no localStorage do navegador.

segurança e prevenções

Funciona sem armazenamento

Se o localStorage estiver bloqueado, como no modo privado, o jogo segue normalmente, só sem salvar recordes.

Nada sai do navegador

Sem login, placar online ou envio de dados; o desafio compartilha só um texto com a pontuação e o link do jogo.

Acessível

Rótulos para leitores de tela, atalhos de teclado (P para pausar, M para som) e animações reduzidas para quem pede menos movimento.

processo
01

Mata Mosquito

Primeira versão, feita como estudo: quatro páginas HTML e intervalo fixo entre os mosquitos.

02

Reescrita do zero

Uma página só, laço com requestAnimationFrame, relógio próprio e pausa automática.

03

Regras novas

Três níveis de verdade, combo multiplicador, alien dourado e alien de capacete.

04

Som e toque

Efeitos gerados com Web Audio e tiro no pointerdown, com área de toque maior no celular.

05

Publicação

Versão em português e inglês, pronta para o subdomínio de jogos.

bastidores técnicos
mata-alien/game.js JavaScript linhas 80–98
  const DURATION = 30000;
  const MAX_LIVES = 3;
  const LIFE_BONUS = 250;
  const COUNTDOWN_STEP = 600;

  const LEVELS = {
    facil:   { spawn: [1300, 900], ttl: [2400, 1700], maxAlive: 1, drift: 0,  gold: 0.06, armored: 0 },
    dificil: { spawn: [950, 620],  ttl: [1900, 1300], maxAlive: 3, drift: 40, gold: 0.07, armored: 0.14 },
    mori:    { spawn: [680, 420],  ttl: [1350, 950],  maxAlive: 4, drift: 95, gold: 0.08, armored: 0.18 }
  };

  // os três tamanhos do original (50, 70 e 90 px), um pouco maiores; menor vale mais
  const SIZES = [
    { px: 54, pts: 150 },
    { px: 72, pts: 100 },
    { px: 92, pts: 75 }
  ];

  const POINTS = { gold: 500, armored: 250 };
As regras em um lugar: duração, vidas, ritmo de cada nível e quanto vale cada tipo de alien.
mata-alien/game.js JavaScript linhas 566–615
  function spawn(progress) {
    const cfg = game.cfg;
    const roll = Math.random();
    const kind = roll < cfg.gold ? 'gold' : roll < cfg.gold + cfg.armored ? 'armored' : 'normal';

    let sizeIndex = Math.floor(Math.random() * 3);
    if (kind === 'gold') sizeIndex = Math.floor(Math.random() * 2);
    if (kind === 'armored') sizeIndex = 1 + Math.floor(Math.random() * 2);

    const def = SIZES[sizeIndex];
    const size = Math.round(def.px * scale);

    let ttl = lerp(cfg.ttl[0], cfg.ttl[1], progress);
    if (kind === 'gold') ttl *= 0.7;
    if (kind === 'armored') ttl *= 1.35;

    const spot = findSpot(size);
    const el = TEMPLATES[kind].cloneNode(true);
    el.classList.add('alien--' + kind);
    if (Math.random() < 0.5) el.classList.add('flip');
    el.style.setProperty('--size', size + 'px');

    const alien = {
      el,
      kind,
      size,
      x: spot.x,
      y: spot.y,
      vx: 0,
      vy: 0,
      born: game.t,
      ttl,
      hp: kind === 'armored' ? 2 : 1,
      pts: POINTS[kind] || def.pts,
      warned: false
    };

    if (cfg.drift) {
      const angle = Math.random() * Math.PI * 2;
      const speed = cfg.drift * rand(0.6, 1.3) * scale * (0.7 + progress * 0.6);
      alien.vx = Math.cos(angle) * speed;
      alien.vy = Math.sin(angle) * speed;
    }

    place(alien);
    byElement.set(el, alien);
    stage.appendChild(el);
    game.aliens.push(alien);
    sfx.spawn();
  }
Cada alien nasce num lugar livre da tela; o tipo, o tamanho e o tempo antes da fuga dependem do nível e de quanto da partida já passou.
mata-alien/game.js JavaScript linhas 642–677
  // no toque o dedo cobre o alvo: aceita alguns pixels a mais em volta
  function alienAt(x, y, target, pointerType) {
    const direct = target.closest && target.closest('.alien');
    if (direct && byElement.has(direct)) {
      const alien = byElement.get(direct);
      if (game.aliens.includes(alien)) return alien;
    }

    const slack = pointerType === 'mouse' ? 4 : 16;
    let found = null;
    let bestDistance = Infinity;

    for (const alien of game.aliens) {
      const [cx, cy] = center(alien);
      const distance = Math.hypot(cx - x, cy - y) - alien.size / 2;
      if (distance <= slack && distance < bestDistance) {
        bestDistance = distance;
        found = alien;
      }
    }

    return found;
  }

  function shoot(event) {
    if (game.state !== 'playing') return;
    if (event.button > 0) return;

    event.preventDefault();
    sfx.unlock();
    game.shots++;

    const alien = alienAt(event.clientX, event.clientY, event.target, event.pointerType);
    if (alien) hit(alien);
    else miss(event.clientX, event.clientY);
  }
No toque, o dedo cobre o alvo, então o tiro aceita alguns pixels a mais em volta; no mouse, a tolerância é menor.
mata-alien/game.js JavaScript linhas 695–725
  function kill(alien) {
    removeAlien(alien);

    const before = multiplier();
    game.kills++;
    game.combo++;
    game.bestCombo = Math.max(game.bestCombo, game.combo);
    // relógio do jogo + o que passou desde o último quadro: reflexo em ms, não em quadros
    const now = game.t + Math.min(performance.now() - last, 50);
    game.fastest = Math.min(game.fastest, now - alien.born);

    const mult = multiplier();
    const pts = alien.pts * mult;
    game.score += pts;

    const [cx, cy] = center(alien);
    const gold = alien.kind === 'gold';
    fx.burst(cx, cy, gold ? '#ffd36b' : '#8be28f', gold ? 26 : 16, alien.size / 76);
    popup('+' + fmt(pts), cx, cy, gold ? 'gold' : '');
    if (mult > before) popup(T.combo(mult), cx, cy - alien.size * 0.7, 'combo');

    alien.el.classList.add('is-dead');
    removeLater(alien.el, 260);

    if (gold) sfx.gold();
    else sfx.zap();

    // um respiro antes do próximo (no fácil é um de cada vez)
    game.nextSpawn = Math.max(game.nextSpawn, game.t + 220);
    renderScore();
  }
No abate, o combo multiplica os pontos, o reflexo é medido em milissegundos pelo relógio do jogo e o dourado ganha uma explosão maior.
impacto

Resultados

Um jogo completo em três arquivos, que carrega rápido porque não baixa nenhuma imagem ou som.

Aprendizados

Refazer um projeto antigo mostra a evolução de forma concreta: os mesmos objetivos, agora com estado bem definido, laço de jogo único e cuidado com toque, som e acessibilidade.