セルオートマトンの世界 — ライフゲームから波動関数崩壊まで

const W = 200
const H = 150
let grid = new Uint8Array(W * H)
let nextGrid = new Uint8Array(W * H)

function stepLife() {
  for (let y = 0; y < H; y++) {
    for (let x = 0; x < W; x++) {
      let neighbors = 0

      for (let dy = -1; dy <= 1; dy++) {
        for (let dx = -1; dx <= 1; dx++) {
          if (dx === 0 && dy === 0) continue
          const nx = (x + dx + W) % W
          const ny = (y + dy + H) % H
          neighbors += grid[ny * W + nx]
        }
      }

      const idx = y * W + x
      const alive = grid[idx]

      if (alive) {
        nextGrid[idx] = neighbors === 2 || neighbors === 3 ? 1 : 0
      } else {
        nextGrid[idx] = neighbors === 3 ? 1 : 0
      }
    }
  }

  // バッファスワップ（コピーなし）
  const temp = grid
  grid = nextGrid
  nextGrid = temp
}

type Material = 0 | 1 | 2 // 0: 空気, 1: 砂, 2: 水

function stepSand(grid: Uint8Array, w: number, h: number) {
  // 下から上にスキャン（重力方向の処理順が重要）
  for (let y = h - 2; y >= 0; y--) {
    for (let x = 0; x < w; x++) {
      const idx = y * w + x
      if (grid[idx] !== 1) continue

      const below = (y + 1) * w + x
      const belowLeft = (y + 1) * w + (x - 1)
      const belowRight = (y + 1) * w + (x + 1)

      if (grid[below] === 0) {
        // 真下が空なら落下
        grid[below] = 1
        grid[idx] = 0
      } else if (x > 0 && grid[belowLeft] === 0) {
        // 左下が空なら斜め落下
        grid[belowLeft] = 1
        grid[idx] = 0
      } else if (x < w - 1 && grid[belowRight] === 0) {
        // 右下が空なら斜め落下
        grid[belowRight] = 1
        grid[idx] = 0
      }
    }
  }
}

type Cell = {
  collapsed: boolean
  options: Set<number>
}

function findLowestEntropy(cells: Cell[][]): [number, number] | null {
  let minEntropy = Infinity
  let candidates: [number, number][] = []

  for (let y = 0; y < cells.length; y++) {
    for (let x = 0; x < cells[y].length; x++) {
      if (cells[y][x].collapsed) continue
      const entropy = cells[y][x].options.size
      if (entropy < minEntropy) {
        minEntropy = entropy
        candidates = [[x, y]]
      } else if (entropy === minEntropy) {
        candidates.push([x, y])
      }
    }
  }

  if (candidates.length === 0) return null
  return candidates[Math.floor(Math.random() * candidates.length)]
}

function collapse(cells: Cell[][], x: number, y: number) {
  const options = Array.from(cells[y][x].options)
  const chosen = options[Math.floor(Math.random() * options.length)]
  cells[y][x].options = new Set([chosen])
  cells[y][x].collapsed = true
}

function propagate(cells: Cell[][], rules: Map<number, Set<number>[]>) {
  const stack: [number, number][] = []
  // ... 制約を近傍に伝播
  // 隣接セルの選択肢を互換性ルールで削減
}

function renderGrid(ctx: CanvasRenderingContext2D, grid: Uint8Array, w: number, h: number) {
  const imageData = ctx.createImageData(w, h)
  const data = imageData.data

  for (let i = 0; i < w * h; i++) {
    const px = i * 4
    const cell = grid[i]

    if (cell === 1) {       // 砂
      data[px] = 194
      data[px + 1] = 178
      data[px + 2] = 128
    } else if (cell === 2) { // 水
      data[px] = 64
      data[px + 1] = 164
      data[px + 2] = 223
    }
    data[px + 3] = 255
  }

  ctx.putImageData(imageData, 0, 0)
}