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.

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.
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.
Comentários
Entre com sua conta Raptware para deixar um comentário.
Dados pessoais
Desculpe, este site é feito para crianças e adultos, por isso não podemos permitir o compartilhamento de dados pessoais. Agradecemos sua compreensão e seus comentários!