Juego de la vida en 3D

Un autómata celular en tres dimensiones, interactivo. Proyecto de formación reconstruido para la web: arrastrá para rotar, rueda para acercar.

Qué es

El Juego de la vida de Conway (1970) es un autómata celular: una cuadrícula de células vivas o muertas que evolucionan por generaciones según reglas que solo miran a los vecinos inmediatos. No hay jugadores. Una vez fijado el estado inicial, todo lo que ocurre es consecuencia mecánica de las reglas, y aun así emergen estructuras estables, osciladores y patrones que se desplazan.

Esta versión lleva la idea a tres dimensiones. Cada célula es un cubo y su vecindad son los 26 cubos que la tocan por cara, arista o vértice (vecindad de Moore en 3D). El universo está acotado: las celdas fuera del límite se consideran muertas.

Las reglas

Las reglas se expresan en notación B/S (born/survive). Una célula muerta nace si su número de vecinos vivos cae dentro del rango “nacer”; una célula viva sobrevive si su número de vecinos cae dentro del rango “sobrevivir”; en cualquier otro caso muere o sigue muerta.

Los valores por defecto —nacer con 4 o 5 vecinos, sobrevivir con exactamente 5— corresponden a la regla 4555 que Carter Bays identificó en 1987 como uno de los pocos análogos tridimensionales del Life original: produce estructuras estables, osciladores y planeadores en vez de extinguirse o llenar todo el espacio. Probá 5766 (la otra regla de Bays) o ampliá los rangos para ver la diferencia entre una explosión y una extinción.

Cómo está implementado

El universo no se guarda como un cubo denso (con tamaño 20 serían 21³ = 9261 celdas) sino como un conjunto disperso con las coordenadas de las células vivas. En cada generación se recorren solo las células vivas y cada una suma +1 a sus 26 vecinos en un mapa de conteos; después se decide el destino de cada celda que aparece en el mapa. El costo por paso es proporcional al número de células vivas × 26, no al volumen del universo.

El render usa una sola malla instanciada de three.js: todos los cubos comparten geometría y material y solo cambian sus matrices de posición, así que miles de células se dibujan en una única llamada a la GPU. La escena se carga solo en esta ruta para no encarecer el resto del sitio.

La función de transición completa, tal como corre en esta página:

function nextGeneration(cells, gridSize, rules) {
  const limit = Math.floor(gridSize / 2);
  const counts = new Map();

  // 1. Cada célula viva suma +1
  //    a sus 26 vecinos.
  cells.forEach((key) => {
    const [cx, cy, cz] = keyToPos(key);
    for (const [dx, dy, dz] of NEIGHBOR_OFFSETS) {
      const nx = cx + dx;
      const ny = cy + dy;
      const nz = cz + dz;
      const outside =
        Math.abs(nx) > limit ||
        Math.abs(ny) > limit ||
        Math.abs(nz) > limit;
      if (outside) continue;
      const nKey = posToKey(nx, ny, nz);
      counts.set(nKey, (counts.get(nKey) ?? 0) + 1);
    }
  });

  // 2. Solo las celdas con algún vecino vivo
  //    pueden cambiar de estado.
  const next = new Set();
  counts.forEach((count, key) => {
    const alive = cells.has(key);
    const lo = alive
      ? rules.surviveMin
      : rules.bornMin;
    const hi = alive
      ? rules.surviveMax
      : rules.bornMax;
    if (count >= lo && count <= hi) next.add(key);
  });
  return next;
}