Como fazer um jogo de plataforma em JavaScript (parte 1)

Nesta série vamos fazer um jogo de plataforma completo com JavaScript puro e o canvas do HTML5: sem engine, sem bibliotecas, num único arquivo que abre com dois cliques. O personagem corre sozinho, um swipe faz ele dar meia-volta e um botão faz ele pular, como nos jogos de plataforma de corrida automática do celular. Na parte 1 preparamos o canvas para ficar nítido em qualquer tela, escrevemos o loop do jogo e colocamos nosso personagem no chão.

Toda segunda-feira sai uma parte nova. Todas terminam com uma demo jogável e o código completo até ali, então você pode começar por qualquer uma.

O que vamos construir

Um runner quase sempre é uma linha reta: corra, pule e não caia. Poder dar meia-volta muda tudo. Uma fase pode esconder coisas atrás de você, pedir que você volte para buscar uma chave ou colocar uma parede que você só passa se virar. É esse o tipo de jogo que vamos fazer:

  • Correr e cair: gravidade e colisões contra os blocos da fase.
  • Controles: um botão de pulo, um swipe para mudar de direção e o teclado no computador.
  • A fase e a câmera: um mapa escrito como texto, moedas e uma câmera que olha para a frente.
  • Ganhar e perder: buracos, espinhos e uma bandeira de chegada. Aí fica a primeira fase completa.
  • Inimigos: dois personagens que andam pela fase, e a história completa das caixas de colisão.
  • Portas e uma sala de moedas: portas que levam a outro lugar do mapa, e uma sala secreta.

Os gráficos são retângulos coloridos de propósito: tudo o que vamos aprender é sobre como o jogo se comporta, e com retângulos o código fala só disso.

Conheça o Cubi

Nosso personagem é o Cubi, um cubo verde de tênis. Ele é um único quadro em SVG, escrito dentro do próprio código: nada de imagens para baixar nem folhas de animação. Ele mede exatamente um bloco, 32 por 32, e não é por acaso. Num jogo, o que você vê e o que colide são duas coisas diferentes: o desenho, e uma caixa invisível que a física usa. No Cubi as duas são o mesmo quadrado, e isso deixa as primeiras lições simples: a linha tracejada da imagem é a caixa de colisão dele, e ela encaixa certinho.

Cubi, um cubo verde com olhos e tênis, em pé sobre tijolos vermelhos com o céu azul atrás; uma linha tracejada marca sua caixa de colisão quadrada.

Quase nunca é assim: um inimigo redondo, ou um com espinhos, precisa de uma caixa que não bate com o desenho, e ajustá-la pede um pouco de matemática. Vamos ver isso com calma na parte dos inimigos.

Passo 1: a página

Tudo fica num único arquivo HTML. A página é preta, o canvas fica no meio, e touch-action: none avisa o navegador que um dedo sobre o canvas é do jogo: sem isso, um swipe rolaria a página ou daria zoom em vez de chegar ao nosso código.

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>My platformer</title>
<style>
  html, body { margin: 0; height: 100%; background: #000; }
  body { display: flex; align-items: center; justify-content: center; overflow: hidden; }
  canvas { display: block; touch-action: none; }
</style>
</head>
<body>
<canvas id="game"></canvas>
<script>
  // Tudo desta série vai aqui.
</script>
</body>
</html>

Passo 2: um mundo de tamanho fixo

A primeira decisão é a mais importante: o jogo não pensa em pixels da tela. Ele pensa num mundo de 16 por 9 blocos de 32 pixels, 512 por 288, sempre. Um celular, um monitor ou um quadro dentro de uma página só decidem o quão grande esse mundo é desenhado. Assim um pulo chega à mesma altura em todos os aparelhos, e quem desenha as fases pode contar em blocos.

// O jogo pensa num mundo fixo de 16 x 9 blocos.
const TILE = 32;
const VIEW_W = 16 * TILE;   // 512
const VIEW_H = 9 * TILE;    // 288
const STEP = 1 / 60;        // um passo de física: 1/60 de segundo

const SKY = '#5c94fc';
const BRICK = '#c84c0c';
const MORTAR = '#6b2205';
const BRICK_LIGHT = '#f08850';

Azul-céu e vermelho-tijolo: as cores clássicas do gênero, para o jogo nunca se misturar com a página em volta.

Passo 3: um canvas nítido em qualquer tela

Um canvas tem dois tamanhos, e confundi-los é o motivo mais comum de um jogo em canvas ficar borrado. O tamanho do CSS diz o quão grande ele aparece na página. O tamanho do buffer, canvas.width e canvas.height, diz quantos pixels reais ele tem. Um celular tem uns três pixels físicos para cada pixel de CSS (devicePixelRatio), então um buffer do tamanho da caixa CSS é esticado três vezes.

A solução é aumentar o buffer nessa proporção e usar setTransform para continuar desenhando no nosso mundo de 512 por 288 enquanto o navegador preenche cada pixel real:

const canvas = document.getElementById('game');
const ctx = canvas.getContext('2d');

function resize() {
  const dpr = window.devicePixelRatio || 1;
  // O maior tamanho que cabe sem mudar o formato 16:9.
  const scale = Math.min(window.innerWidth / VIEW_W, window.innerHeight / VIEW_H);
  const cssW = Math.floor(VIEW_W * scale);
  const cssH = Math.floor(VIEW_H * scale);
  // O quanto ele APARECE na página.
  canvas.style.width = cssW + 'px';
  canvas.style.height = cssH + 'px';
  // Quantos pixels REAIS ele tem: nítido no celular também.
  canvas.width = Math.floor(cssW * dpr);
  canvas.height = Math.floor(cssH * dpr);
  // Daqui em diante desenhamos em unidades do mundo (512 x 288).
  ctx.setTransform(canvas.width / VIEW_W, 0, 0, canvas.height / VIEW_H, 0, 0);
}
window.addEventListener('resize', resize);
resize();

Chamamos resize() uma vez no começo e de novo toda vez que a janela muda, por exemplo ao girar o celular.

Passo 4: carregar o Cubi

O SVG é uma string de texto dentro do código. Para desenhá-lo no canvas, transformamos ele em imagem com uma URL data:. decode() devolve uma promise que se resolve quando a imagem está pronta, assim o jogo nunca tenta desenhar algo que ainda não carregou.

const CUBI_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" width="64" height="64">
  <rect x="2" y="2" width="28" height="24" rx="4" fill="#3ec74b" stroke="#1d6b2a" stroke-width="2"/>
  <rect x="5" y="5" width="10" height="3" rx="1.5" fill="#8fe39a"/>
  <ellipse cx="18" cy="12" rx="3.5" ry="4.5" fill="#fff"/>
  <ellipse cx="25" cy="12" rx="3.5" ry="4.5" fill="#fff"/>
  <circle cx="19.5" cy="13" r="2" fill="#1a1a1a"/>
  <circle cx="26.5" cy="13" r="2" fill="#1a1a1a"/>
  <path d="M19 20 q3 2.5 6 0" fill="none" stroke="#1d6b2a" stroke-width="1.6" stroke-linecap="round"/>
  <rect x="3" y="25" width="11" height="6" rx="2.5" fill="#fff" stroke="#333" stroke-width="1.2"/>
  <rect x="18" y="25" width="11" height="6" rx="2.5" fill="#fff" stroke="#333" stroke-width="1.2"/>
  <rect x="3" y="29" width="11" height="2" fill="#e53935"/>
  <rect x="18" y="29" width="11" height="2" fill="#e53935"/>
</svg>`;

function loadImage(svg) {
  const img = new Image();
  img.src = 'data:image/svg+xml,' + encodeURIComponent(svg);
  // decode() espera até a imagem poder ser desenhada sem engasgos.
  return img.decode().then(() => img);
}

Passo 5: o estado do jogo

O chão são duas fileiras de tijolos, e há alguns blocos flutuando para dar forma à cena. O Cubi é um objeto com posição, tamanho, velocidade e direção. Repare na unidade da velocidade: pixels por segundo. Se movêssemos ele um número fixo de pixels por quadro, num monitor de 144 Hz ele correria mais que o dobro do que num celular de 60 Hz.

const GROUND_ROW = 7;
const FLOATING = [[4, 4], [5, 4], [6, 4], [11, 3], [12, 3]];   // [coluna, linha]

const player = {
  x: 0,
  y: GROUND_ROW * TILE - TILE,   // em pé no chão
  w: TILE,
  h: TILE,
  speed: 120,                    // pixels por SEGUNDO, não por quadro
  dir: 1,                        // 1 direita, -1 esquerda
  sprite: null,
};

function update(dt) {
  player.x += player.speed * player.dir * dt;
  // Por enquanto o Cubi sai por um lado e volta pelo outro.
  if (player.x > VIEW_W) player.x = -player.w;
  if (player.x < -player.w) player.x = VIEW_W;
}

update(dt) avança o mundo dt segundos. Por enquanto só move o Cubi; nas próximas partes é ali que vão morar a gravidade, as colisões e todo o resto.

Passo 6: desenhar

Cada quadro é pintado do zero, de trás para a frente: céu, blocos e o Cubi por cima. Um tijolo é um retângulo vermelho com algumas linhas mais escuras para as juntas. Para o Cubi olhar para a esquerda não precisamos de um segundo desenho: espelhamos o canvas no centro dele com scale(-1, 1), entre save() e restore() para o espelho valer só para ele.

function drawBrick(col, row) {
  const x = col * TILE;
  const y = row * TILE;
  const half = TILE / 2;
  ctx.fillStyle = BRICK;
  ctx.fillRect(x, y, TILE, TILE);
  // As juntas: duas fileiras de tijolos, a segunda deslocada meio tijolo.
  ctx.fillStyle = MORTAR;
  ctx.fillRect(x, y + half - 1, TILE, 2);
  ctx.fillRect(x, y + TILE - 2, TILE, 2);
  ctx.fillRect(x + half - 1, y, 2, half);
  ctx.fillRect(x, y + half, 2, half);
  ctx.fillStyle = BRICK_LIGHT;
  ctx.fillRect(x, y, TILE, 2);
}

function drawPlayer() {
  ctx.save();
  if (player.dir < 0) {
    // Olhando para a esquerda: espelhar o desenho no centro do Cubi.
    ctx.translate(player.x + player.w / 2, 0);
    ctx.scale(-1, 1);
    ctx.translate(-(player.x + player.w / 2), 0);
  }
  ctx.drawImage(player.sprite, Math.round(player.x), Math.round(player.y), player.w, player.h);
  ctx.restore();
}

function draw() {
  ctx.fillStyle = SKY;
  ctx.fillRect(0, 0, VIEW_W, VIEW_H);
  for (let col = 0; col < VIEW_W / TILE; col++) {
    drawBrick(col, GROUND_ROW);
    drawBrick(col, GROUND_ROW + 1);
  }
  for (const [col, row] of FLOATING) drawBrick(col, row);
  drawPlayer();
}

Passo 7: o loop do jogo, com passo fixo

requestAnimationFrame chama nossa função uma vez a cada atualização da tela e passa a hora atual. O tempo entre duas chamadas não é constante: 16,7 ms numa tela, 6,9 ms em outra, e bem mais se o celular ficar ocupado por um instante.

Mover as coisas pelo tempo decorrido basta para o Cubi hoje, mas a física fica imprevisível quando esse tempo muda de um quadro para outro: um quadro longo pode fazer ele atravessar uma parede fina. Por isso usamos um passo fixo. O tempo decorrido vai para um acumulador, e update() roda em fatias de exatamente 1/60 de segundo, quantas couberem. O desenho continua acontecendo uma vez por quadro.

let last = 0;
let acc = 0;

function frame(now) {
  // Segundos desde o quadro anterior, com limite de 0.25.
  const elapsed = Math.min((now - last) / 1000, 0.25);
  last = now;
  acc += elapsed;
  // A física sempre avança em fatias de exatamente STEP.
  while (acc >= STEP) {
    update(STEP);
    acc -= STEP;
  }
  draw();
  requestAnimationFrame(frame);
}

// Primeiro carregar, depois rodar.
loadImage(CUBI_SVG).then((img) => {
  player.sprite = img;
  requestAnimationFrame((now) => {
    last = now;
    requestAnimationFrame(frame);
  });
});

O limite de 0,25 segundo importa mais do que parece: se você troca de aba e volta um minuto depois, o navegador informa um minuto inteiro, e sem o limite o jogo tentaria simular tudo de uma vez.

Experimente

Este é o resultado da parte 1: o Cubi corre em velocidade constante e dá a volta na tela. No celular, use o botão do canto para ver em tela cheia.

Baixar o código da parte 1

O arquivo que você baixa é o jogo completo até aqui, com os comentários em português, inglês e espanhol. Abra no navegador e mude as coisas: a velocidade, as cores, o lugar dos blocos.

Na próxima segunda: correr e cair

Na parte 2 o Cubi ganha gravidade, e os blocos deixam de ser enfeite: vamos escrever colisões entre caixas, resolvendo um eixo de cada vez, para ele poder ficar em pé nas plataformas e bater nas paredes. Se você gosta de jogos feitos assim, pode jogar os que fazemos na Raptware na nossa página de jogos.

← Todos os posts

Comentários

Lemos cada comentário antes de publicá-lo. Seja gentil e não compartilhe dados pessoais.