Cómo hacer un juego de plataformas en JavaScript (parte 1)

En esta serie vamos a hacer un juego de plataformas completo con JavaScript puro y el canvas de HTML5: sin motor, sin librerías, en un solo archivo que se abre con doble clic. El personaje corre solo, un swipe lo hace darse la vuelta y un botón lo hace saltar, como en los juegos de plataformas de correr solos que hay en el teléfono. En la parte 1 preparamos el lienzo para que se vea nítido en cualquier pantalla, escribimos el bucle del juego y ponemos a nuestro personaje en el suelo.

Cada lunes sale una parte nueva. Todas terminan con una demo jugable y el código completo hasta ese punto, así que puedes empezar desde cualquiera.

Qué vamos a construir

Un runner casi siempre es una línea recta: corre, salta y no te caigas. Poder darse la vuelta lo cambia todo. Un nivel puede esconder cosas a tu espalda, pedirte que regreses por una llave o ponerte un muro que solo pasas si te volteas. Ese es el tipo de juego que vamos a hacer:

  • Correr y caer: gravedad y colisiones contra los bloques del nivel.
  • Controles: un botón de salto, un swipe para cambiar de dirección y el teclado en la computadora.
  • El nivel y la cámara: un mapa escrito como texto, monedas y una cámara que mira hacia adelante.
  • Ganar y perder: huecos, picos y una bandera de meta. Ahí queda el primer nivel completo.
  • Enemigos: dos personajes que recorren el nivel, y la historia completa de las cajas de colisión.
  • Puertas y un cuarto de monedas: puertas que te llevan a otro lugar del mapa, y un cuarto secreto.

Los gráficos son rectángulos de colores a propósito: todo lo que vamos a aprender es sobre cómo se comporta el juego, y con rectángulos el código habla solo de eso.

Te presento a Cubi

Nuestro personaje es Cubi, un cubo verde con tenis. Es un solo cuadro en SVG, escrito dentro del mismo código: no hay imágenes que descargar ni hojas de animación. Mide exactamente un bloque, 32 por 32, y no es casualidad. En un juego, lo que ves y lo que choca son dos cosas distintas: el dibujo, y una caja invisible que usa la física. En Cubi las dos son el mismo cuadrado, y eso hace sencillas las primeras lecciones: la línea punteada de la imagen es su caja de colisión, y le queda exacta.

Cubi, un cubo verde con ojos y tenis, parado sobre ladrillos rojos con el cielo azul detrás; una línea punteada marca su caja de colisión cuadrada.

Casi nunca es así: un enemigo redondo, o uno con picos, necesita una caja que no coincide con su dibujo, y ajustarla pide un poco de matemáticas. Eso lo vemos con calma en la parte de los enemigos.

Paso 1: la página

Todo vive en un solo archivo HTML. La página es negra, el lienzo va en medio, y touch-action: none le dice al navegador que un dedo sobre el lienzo es del juego: sin eso, un swipe movería la página o haría zoom en vez de llegar a nuestro 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>
  // Todo lo de esta serie va aquí.
</script>
</body>
</html>

Paso 2: un mundo de tamaño fijo

La primera decisión es la más importante: el juego no piensa en píxeles de pantalla. Piensa en un mundo de 16 por 9 bloques de 32 píxeles, 512 por 288, siempre. Un teléfono, un monitor o un recuadro dentro de una página solo deciden qué tan grande se dibuja ese mundo. Así un salto llega igual de alto en todos los dispositivos, y quien diseña los niveles puede contar en bloques.

// El juego piensa en un mundo fijo de 16 x 9 bloques.
const TILE = 32;
const VIEW_W = 16 * TILE;   // 512
const VIEW_H = 9 * TILE;    // 288
const STEP = 1 / 60;        // un paso de física: 1/60 de segundo

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

Azul cielo y rojo ladrillo: los colores clásicos del género, para que el juego nunca se confunda con la página que lo rodea.

Paso 3: un lienzo nítido en cualquier pantalla

Un canvas tiene dos tamaños, y confundirlos es la razón más común de que un juego en canvas se vea borroso. El tamaño del CSS dice qué tan grande se ve en la página. El tamaño del búfer, canvas.width y canvas.height, dice cuántos píxeles reales tiene. Un teléfono tiene unos tres píxeles físicos por cada píxel de CSS (devicePixelRatio), así que un búfer del tamaño de la caja CSS se estira tres veces.

La solución es hacer el búfer más grande por esa proporción y usar setTransform para seguir dibujando en nuestro mundo de 512 por 288 mientras el navegador llena cada píxel real:

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

function resize() {
  const dpr = window.devicePixelRatio || 1;
  // El tamaño más grande que cabe sin cambiar la forma 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);
  // Qué tan grande SE VE en la página.
  canvas.style.width = cssW + 'px';
  canvas.style.height = cssH + 'px';
  // Cuántos píxeles REALES tiene: nítido también en el teléfono.
  canvas.width = Math.floor(cssW * dpr);
  canvas.height = Math.floor(cssH * dpr);
  // De aquí en adelante dibujamos en unidades del mundo (512 x 288).
  ctx.setTransform(canvas.width / VIEW_W, 0, 0, canvas.height / VIEW_H, 0, 0);
}
window.addEventListener('resize', resize);
resize();

Llamamos a resize() una vez al empezar y otra cada vez que cambia la ventana, por ejemplo al girar el teléfono.

Paso 4: cargar a Cubi

El SVG es una cadena de texto dentro del código. Para dibujarlo en el lienzo lo convertimos en imagen con una URL data:. decode() devuelve una promesa que se cumple cuando la imagen está lista, así el juego nunca intenta dibujar algo que todavía no carga.

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 a que la imagen se pueda dibujar sin tropiezos.
  return img.decode().then(() => img);
}

Paso 5: el estado del juego

El suelo son dos hileras de ladrillos, y hay unos bloques flotando para darle forma a la escena. Cubi es un objeto con posición, tamaño, velocidad y dirección. Fíjate en la unidad de la velocidad: píxeles por segundo. Si lo moviéramos un número fijo de píxeles por cuadro, en un monitor de 144 Hz correría más del doble de rápido que en un teléfono de 60 Hz.

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

const player = {
  x: 0,
  y: GROUND_ROW * TILE - TILE,   // parado en el suelo
  w: TILE,
  h: TILE,
  speed: 120,                    // píxeles por SEGUNDO, no por cuadro
  dir: 1,                        // 1 derecha, -1 izquierda
  sprite: null,
};

function update(dt) {
  player.x += player.speed * player.dir * dt;
  // Por ahora Cubi sale por un lado y vuelve a entrar por el otro.
  if (player.x > VIEW_W) player.x = -player.w;
  if (player.x < -player.w) player.x = VIEW_W;
}

update(dt) avanza el mundo dt segundos. Por ahora solo mueve a Cubi; en las próximas partes ahí van a vivir la gravedad, las colisiones y todo lo demás.

Paso 6: dibujar

Cada cuadro se pinta desde cero, de atrás hacia adelante: cielo, bloques y Cubi encima. Un ladrillo es un rectángulo rojo con unas líneas más oscuras para las juntas. Para que Cubi mire a la izquierda no hace falta un segundo dibujo: reflejamos el lienzo sobre su centro con scale(-1, 1), entre save() y restore() para que el reflejo solo le toque a él.

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);
  // Las juntas: dos hileras de ladrillos, la segunda corrida medio ladrillo.
  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) {
    // Mirando a la izquierda: reflejar el dibujo sobre el centro de 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();
}

Paso 7: el bucle del juego, con paso fijo

requestAnimationFrame llama a nuestra función una vez por cada refresco de pantalla y le pasa la hora actual. El tiempo entre dos llamadas no es constante: 16.7 ms en una pantalla, 6.9 ms en otra, y mucho más si el teléfono se ocupa un momento.

Mover las cosas según el tiempo transcurrido le alcanza a Cubi hoy, pero la física se vuelve impredecible cuando ese tiempo cambia de un cuadro a otro: un cuadro largo puede hacer que atraviese una pared delgada. Por eso usamos un paso fijo. El tiempo transcurrido va a un acumulador, y update() corre en rebanadas de exactamente 1/60 de segundo, todas las que quepan. El dibujo sigue siendo una vez por cuadro.

let last = 0;
let acc = 0;

function frame(now) {
  // Segundos desde el cuadro anterior, con tope de 0.25.
  const elapsed = Math.min((now - last) / 1000, 0.25);
  last = now;
  acc += elapsed;
  // La física siempre avanza en rebanadas de exactamente STEP.
  while (acc >= STEP) {
    update(STEP);
    acc -= STEP;
  }
  draw();
  requestAnimationFrame(frame);
}

// Primero cargar, después correr.
loadImage(CUBI_SVG).then((img) => {
  player.sprite = img;
  requestAnimationFrame((now) => {
    last = now;
    requestAnimationFrame(frame);
  });
});

El tope de 0.25 segundos importa más de lo que parece: si cambias de pestaña y regresas un minuto después, el navegador reporta un minuto entero, y sin el tope el juego intentaría simularlo de golpe.

Pruébalo

Este es el resultado de la parte 1: Cubi corre a velocidad constante y le da la vuelta a la pantalla. En el teléfono, usa el botón de la esquina para verlo en pantalla completa.

Descargar el código de la parte 1

El archivo que descargas es el juego completo hasta este punto, con sus comentarios en español, inglés y portugués. Ábrelo con tu navegador y cámbiale cosas: la velocidad, los colores, el lugar de los bloques.

El próximo lunes: correr y caer

En la parte 2 Cubi tendrá gravedad, y los bloques dejarán de ser decoración: vamos a escribir colisiones entre cajas, resolviendo un eje a la vez, para que pueda pararse en las plataformas y chocar con los muros. Si te gustan los juegos hechos así, puedes jugar los que hacemos en Raptware en nuestra página de juegos.

← Todas las entradas

Comentarios

Leemos cada comentario antes de publicarlo. Sé amable y no compartas datos personales.