Brian's Brain — Neural Pulses

let GW = 0, GH = 0, CELL = 4;
let cur, nxt, img;
let lastReseed = 0;

function reseed(density) {
  for (let i = 0; i < cur.length; i++) {
    cur[i] = Math.random() < density ? 1 : 0;
  }
}

function splash(cx, cy, r) {
  for (let y = -r; y <= r; y++) {
    for (let x = -r; x <= r; x++) {
      if (x * x + y * y > r * r) continue;
      const gx = ((cx + x) % GW + GW) % GW;
      const gy = ((cy + y) % GH + GH) % GH;
      if (Math.random() < 0.35) cur[gy * GW + gx] = 1;
    }
  }
}

function init({ canvas, ctx, width, height }) {
  CELL = Math.max(3, Math.floor(Math.min(width, height) / 160));
  GW = Math.floor(width / CELL);
  GH = Math.floor(height / CELL);
  cur = new Uint8Array(GW * GH);
  nxt = new Uint8Array(GW * GH);
  img = ctx.createImageData(GW, GH);
  reseed(0.25);
  ctx.imageSmoothingEnabled = false;
}

function step() {
  for (let y = 0; y < GH; y++) {
    const ym = (y - 1 + GH) % GH;
    const yp = (y + 1) % GH;
    const rowY = y * GW;
    const rowM = ym * GW;
    const rowP = yp * GW;
    for (let x = 0; x < GW; x++) {
      const xm = (x - 1 + GW) % GW;
      const xp = (x + 1) % GW;
      const s = cur[rowY + x];
      if (s === 1) {
        nxt[rowY + x] = 2;
      } else if (s === 2) {
        nxt[rowY + x] = 0;
      } else {
        let n = 0;
        if (cur[rowM + xm] === 1) n++;
        if (cur[rowM + x]  === 1) n++;
        if (cur[rowM + xp] === 1) n++;
        if (cur[rowY + xm] === 1) n++;
        if (cur[rowY + xp] === 1) n++;
        if (cur[rowP + xm] === 1) n++;
        if (cur[rowP + x]  === 1) n++;
        if (cur[rowP + xp] === 1) n++;
        nxt[rowY + x] = (n === 2) ? 1 : 0;
      }
    }
  }
  const tmp = cur; cur = nxt; nxt = tmp;
}

function render(ctx, time, width, height) {
  const data = img.data;
  const t = time * 0.00012;
  const hueShift = 0.5 + 0.5 * Math.sin(t);
  const onR = Math.floor(120 + 120 * hueShift);
  const onG = Math.floor(180 - 140 * hueShift);
  const onB = 255;
  const dyR = (onR * 0.35) | 0;
  const dyG = (onG * 0.35) | 0;
  const dyB = (onB * 0.45) | 0;
  let p = 0;
  for (let i = 0; i < cur.length; i++) {
    const s = cur[i];
    if (s === 1) {
      data[p] = onR; data[p+1] = onG; data[p+2] = onB; data[p+3] = 255;
    } else if (s === 2) {
      data[p] = dyR; data[p+1] = dyG; data[p+2] = dyB; data[p+3] = 255;
    } else {
      data[p] = 6; data[p+1] = 8; data[p+2] = 14; data[p+3] = 255;
    }
    p += 4;
  }
  if (!render._buf || render._buf.width !== GW || render._buf.height !== GH) {
    render._buf = new OffscreenCanvas(GW, GH);
    render._bctx = render._buf.getContext('2d');
  }
  render._bctx.putImageData(img, 0, 0);
  ctx.imageSmoothingEnabled = false;
  ctx.drawImage(render._buf, 0, 0, GW, GH, 0, 0, width, height);
}

function tick({ ctx, frame, time, width, height }) {
  step();

  if ((frame & 31) === 0) {
    let on = 0;
    for (let i = 0; i < cur.length; i += 4) if (cur[i] === 1) on++;
    const ratio = on / (cur.length / 4);
    if (ratio < 0.005 && time - lastReseed > 800) {
      const cx = (Math.random() * GW) | 0;
      const cy = (Math.random() * GH) | 0;
      splash(cx, cy, Math.max(8, (Math.min(GW, GH) / 8) | 0));
      lastReseed = time;
    }
  }

  render(ctx, time, width, height);
}