Dendrite Bloom

let W, H, GW, GH, grid, ageBuf;
let cx, cy, maxR, spawnR, killR, stuckCount, totalAge;
let img, pix;
let offCanvas, offCtx;
const WALKERS = 500;
const STEPS = 40;
const SCALE = 2;

function hsv(h, s, v) {
  const c = v * s;
  const hp = h / 60;
  const x = c * (1 - Math.abs((hp % 2) - 1));
  let r = 0, g = 0, b = 0;
  if (hp < 1) { r = c; g = x; }
  else if (hp < 2) { r = x; g = c; }
  else if (hp < 3) { g = c; b = x; }
  else if (hp < 4) { g = x; b = c; }
  else if (hp < 5) { r = x; b = c; }
  else { r = c; b = x; }
  const m = v - c;
  return [((r + m) * 255) | 0, ((g + m) * 255) | 0, ((b + m) * 255) | 0];
}

function init({ canvas, ctx, width, height }) {
  W = width; H = height;
  GW = Math.max(64, Math.floor(W / SCALE));
  GH = Math.max(64, Math.floor(H / SCALE));
  cx = (GW / 2) | 0; cy = (GH / 2) | 0;
  grid = new Uint8Array(GW * GH);
  ageBuf = new Uint32Array(GW * GH);
  img = ctx.createImageData(GW, GH);
  pix = img.data;
  for (let i = 3; i < pix.length; i += 4) pix[i] = 255;

  // Seed with a small disc so the first few sticks have something
  // worth latching onto and the bloom is visible from frame zero.
  let seeded = 0;
  for (let dy = -3; dy <= 3; dy++) {
    for (let dx = -3; dx <= 3; dx++) {
      if (dx * dx + dy * dy <= 9) {
        const idx = (cy + dy) * GW + (cx + dx);
        grid[idx] = 1;
        ageBuf[idx] = 1;
        const c = hsv(0, 0.85, 1.0);
        const p = idx * 4;
        pix[p] = c[0]; pix[p + 1] = c[1]; pix[p + 2] = c[2];
        seeded++;
      }
    }
  }
  stuckCount = seeded;
  totalAge = seeded;
  maxR = 4;
  spawnR = 14;
  killR = 36;

  offCanvas = new OffscreenCanvas(GW, GH);
  offCtx = offCanvas.getContext('2d');
}

function stuckNeighbor(x, y) {
  if (x <= 0 || y <= 0 || x >= GW - 1 || y >= GH - 1) return false;
  const i = y * GW + x;
  return grid[i - 1] || grid[i + 1] || grid[i - GW] || grid[i + GW] ||
         grid[i - GW - 1] || grid[i - GW + 1] || grid[i + GW - 1] || grid[i + GW + 1];
}

function tick({ ctx, frame, width, height }) {
  const hardCap = Math.min(GW, GH) * 0.48;
  for (let w = 0; w < WALKERS; w++) {
    if (maxR > hardCap) break;
    const theta = Math.random() * Math.PI * 2;
    let x = (cx + Math.cos(theta) * spawnR) | 0;
    let y = (cy + Math.sin(theta) * spawnR) | 0;
    let alive = true;
    for (let s = 0; s < STEPS && alive; s++) {
      const r = Math.random();
      if (r < 0.25) x++;
      else if (r < 0.5) x--;
      else if (r < 0.75) y++;
      else y--;
      if (x < 1 || y < 1 || x >= GW - 1 || y >= GH - 1) { alive = false; break; }
      const dx = x - cx, dy = y - cy;
      const d2 = dx * dx + dy * dy;
      if (d2 > killR * killR) { alive = false; break; }
      if (stuckNeighbor(x, y)) {
        const idx = y * GW + x;
        if (!grid[idx]) {
          grid[idx] = 1;
          stuckCount++;
          totalAge = stuckCount;
          ageBuf[idx] = totalAge;
          const d = Math.sqrt(d2);
          if (d > maxR) maxR = d;
          spawnR = Math.min(hardCap, maxR + 10);
          killR = Math.min(hardCap + 80, maxR * 2 + 50);
        }
        alive = false;
      }
    }
  }

  if ((frame & 1) === 0) {
    for (let i = 0; i < grid.length; i++) {
      if (grid[i]) {
        const a = ageBuf[i];
        const t = Math.min(1, a / Math.max(1, totalAge));
        const hue = t * 320;
        const c = hsv(hue, 0.85, 1.0);
        const p = i * 4;
        pix[p] = c[0]; pix[p + 1] = c[1]; pix[p + 2] = c[2];
      }
    }
  }

  ctx.fillStyle = '#070912';
  ctx.fillRect(0, 0, W, H);

  offCtx.putImageData(img, 0, 0);
  ctx.imageSmoothingEnabled = false;
  ctx.drawImage(offCanvas, 0, 0, GW, GH, 0, 0, W, H);

  ctx.strokeStyle = 'rgba(120,160,255,0.16)';
  ctx.beginPath();
  ctx.arc(cx * SCALE, cy * SCALE, spawnR * SCALE, 0, Math.PI * 2);
  ctx.stroke();
  ctx.strokeStyle = 'rgba(255,80,120,0.08)';
  ctx.beginPath();
  ctx.arc(cx * SCALE, cy * SCALE, killR * SCALE, 0, Math.PI * 2);
  ctx.stroke();

  ctx.fillStyle = 'rgba(220,230,255,0.75)';
  ctx.font = '12px system-ui, sans-serif';
  ctx.fillText(`particles: ${stuckCount}  r: ${maxR.toFixed(1)}`, 10, 18);
}