← Así se hace un juego: Snake de Daily Challenge · Lección 10/16

El mismo azar para todos

1/10

Math.random no se puede repetir

En Snake la fruta sale en una casilla libre al azar. Si ese azar fuera Math.random(), cada quien vería la fruta en otro lado y el reto del día ya no sería el mismo para todos. Peor: el servidor, que vuelve a jugar tu partida para revisar el puntaje (lo verás en la unidad 7), sacaría otras frutas y otro resultado.

La salida es un generador pseudoaleatorio: una función que, a partir de un número inicial, la semilla, da una serie que parece azar pero es siempre la misma. Daily Challenge usa mulberry32: diez renglones, sin librerías. Corre el programa dos veces: Math.random cambia; las dos series de la semilla 42 no.

leccion.js

1function mulberry32(seed) {
2  let a = seed >>> 0;
3  const next = () => {
4    a = (a + 0x6D2B79F5) >>> 0;
5    let t = a;
6    t = Math.imul(t ^ (t >>> 15), t | 1);
7    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
8    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
9  };
10  return {
11    next,
12    int: (min, max) => min + Math.floor(next() * (max - min + 1)),
13    pick: (arr) => arr[Math.floor(next() * arr.length)],
14    chance: (p) => next() < p,
15  };
16}
17
18console.log("Math.random:", Math.random().toFixed(4), Math.random().toFixed(4));
19
20const a = mulberry32(42);
21const b = mulberry32(42);   // otra serie, misma semilla
22console.log("a:", a.next().toFixed(4), a.next().toFixed(4), a.next().toFixed(4));
23console.log("b:", b.next().toFixed(4), b.next().toFixed(4), b.next().toFixed(4));

$ node leccion.js

Pulsa CORRER (o Ctrl+Enter).

Qué mirar

Los de Math.random salen distintos cada vez que pulsas CORRER.
a y b dan exactamente los mismos tres números: misma semilla, misma serie.
Cada next() devuelve un número entre 0 (incluido) y 1 (sin incluir), como Math.random.

Generador de números pseudoaleatorios (Wikipedia) ↗

Toda la lección en una página

Math.random no se puede repetir

1function mulberry32(seed) {
2  let a = seed >>> 0;
3  const next = () => {
4    a = (a + 0x6D2B79F5) >>> 0;
5    let t = a;
6    t = Math.imul(t ^ (t >>> 15), t | 1);
7    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
8    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
9  };
10  return {
11    next,
12    int: (min, max) => min + Math.floor(next() * (max - min + 1)),
13    pick: (arr) => arr[Math.floor(next() * arr.length)],
14    chance: (p) => next() < p,
15  };
16}
17
18console.log("Math.random:", Math.random().toFixed(4), Math.random().toFixed(4));
19
20const a = mulberry32(42);
21const b = mulberry32(42);   // otra serie, misma semilla
22console.log("a:", a.next().toFixed(4), a.next().toFixed(4), a.next().toFixed(4));
23console.log("b:", b.next().toFixed(4), b.next().toFixed(4), b.next().toFixed(4));

Los de Math.random salen distintos cada vez que pulsas CORRER.
a y b dan exactamente los mismos tres números: misma semilla, misma serie.
Cada next() devuelve un número entre 0 (incluido) y 1 (sin incluir), como Math.random.

La fecha se vuelve semilla

¿De dónde sale la semilla del día? De la fecha. hashString convierte un texto como "2026-10-23" en un entero de 32 bits con FNV-1a: por cada letra, mezcla su código con ^ (o exclusivo) y multiplica por un primo. Fechas seguidas sólo cambian en la última letra y dan semillas cercanas, pero no importa: mulberry32 las revuelve y sus series no se parecen en nada.

De esa semilla salen dos series independientes con seeds(): una para el juego y otra para la música. Así, si un día la música pide más números al azar, la fruta no se mueve de lugar.

1function mulberry32(seed) {
2  let a = seed >>> 0;
3  const next = () => {
4    a = (a + 0x6D2B79F5) >>> 0;
5    let t = a;
6    t = Math.imul(t ^ (t >>> 15), t | 1);
7    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
8    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
9  };
10  return {
11    next,
12    int: (min, max) => min + Math.floor(next() * (max - min + 1)),
13    pick: (arr) => arr[Math.floor(next() * arr.length)],
14    chance: (p) => next() < p,
15  };
16}
17
18function hashString(str) {
19  let h = 0x811c9dc5;
20  for (let i = 0; i < str.length; i++) {
21    h ^= str.charCodeAt(i);
22    h = Math.imul(h, 0x01000193);
23  }
24  return h >>> 0;
25}
26
27// De public/arcade/core/rng.js: dos semillas que no se pisan
28const seeds = (seed) => ({ game: (seed ^ 0x1234abcd) >>> 0, music: (seed ^ 0x9e3779b9) >>> 0 });
29
30for (const fecha of ["2026-10-23", "2026-10-24", "2026-10-25"]) {
31  const s = hashString(fecha);
32  const rng = mulberry32(seeds(s).game);
33  const tres = [rng.next(), rng.next(), rng.next()].map((v) => v.toFixed(2)).join(" ");
34  console.log(fecha, "->", s, "| juego:", tres);
35}

Las tres semillas se parecen (sólo cambió la última letra), pero las series del juego que salen de ellas no tienen nada que ver: el generador hace el revoltijo.
>>> 0 deja el número como entero sin signo de 32 bits; sin él, la mitad saldrían negativos.
El servidor calcula lo mismo con la misma función (src/lib/reto.ts hace hashString(fecha)), así que nadie tiene que mandarle la semilla.

pick, int y chance

Sobre next() hay tres ayudas: int(min, max) da un entero entre los dos (incluidos), pick(arr) elige un elemento y chance(p) es «sí» con probabilidad p.

Snake usa pick: junta las casillas libres en un arreglo y elige una (randomEmpty en games/snake.js). Aquí está esa idea en un tablero de 4×3. Corre el programa: con la misma semilla las tres frutas caen siempre en las mismas casillas, en el teléfono de cualquiera y en el servidor.

1function mulberry32(seed) {
2  let a = seed >>> 0;
3  const next = () => {
4    a = (a + 0x6D2B79F5) >>> 0;
5    let t = a;
6    t = Math.imul(t ^ (t >>> 15), t | 1);
7    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
8    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
9  };
10  return {
11    next,
12    int: (min, max) => min + Math.floor(next() * (max - min + 1)),
13    pick: (arr) => arr[Math.floor(next() * arr.length)],
14    chance: (p) => next() < p,
15  };
16}
17
18function frutas(semilla) {
19  const rng = mulberry32(semilla);
20  const libres = [];   // casillas donde puede caer
21  for (let y = 0; y < 3; y++)
22    for (let x = 0; x < 4; x++) libres.push({ x, y });
23  const salen = [];
24  for (let i = 0; i < 3; i++) {
25    const f = rng.pick(libres);
26    libres.splice(libres.indexOf(f), 1);
27    salen.push(f.x + "," + f.y);
28  }
29  return salen.join("  ");
30}
31
32console.log("semilla 7:", frutas(7));
33console.log("semilla 7:", frutas(7));   // otra vez: igual
34console.log("semilla 8:", frutas(8));
35
36const dado = mulberry32(2026);
37console.log("dado:", dado.int(1, 6), dado.int(1, 6), dado.int(1, 6));
38console.log("moneda:", dado.chance(0.5) ? "águila" : "sol");

Las dos líneas de la semilla 7 son idénticas; la 8 cambia todo. Fíjate en que el juego nunca guarda «la fruta salió en 2,1»: le basta con la semilla y con pedir los números en el mismo orden.

La regla: sólo la semilla y los botones

Para que una partida se pueda repetir, la simulación sólo puede depender de dos cosas: la semilla y los botones de cada tick. Nada de Math.random, ni de la hora (Date.now), ni del tamaño de la pantalla dentro de update.

Fuera de la simulación sí se vale: el ruido blanco de la percusión se llena con Math.random (core/audio.js) porque sólo suena; no mueve ni una casilla. Y ojo con el orden: pedir un número de más en un lugar corre toda la serie. Por eso el juego y la música tienen series separadas.

1function mulberry32(seed) {
2  let a = seed >>> 0;
3  const next = () => {
4    a = (a + 0x6D2B79F5) >>> 0;
5    let t = a;
6    t = Math.imul(t ^ (t >>> 15), t | 1);
7    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
8    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
9  };
10  return {
11    next,
12    int: (min, max) => min + Math.floor(next() * (max - min + 1)),
13    pick: (arr) => arr[Math.floor(next() * arr.length)],
14    chance: (p) => next() < p,
15  };
16}
17
18const juego = mulberry32(99);
19const otra = mulberry32(99);
20
21otra.next();   // alguien pidió UN número de más (por ejemplo, la música)
22
23console.log("fruta 1:", juego.int(0, 15), "vs", otra.int(0, 15));
24console.log("fruta 2:", juego.int(0, 15), "vs", otra.int(0, 15));
25console.log("fruta 3:", juego.int(0, 15), "vs", otra.int(0, 15));

Un solo next() de más y todas las frutas siguientes cambian. Si la música compartiera la serie del juego, cambiar una canción movería las frutas y rompería las partidas guardadas.