Deepgrain Foundry: move from a claude.ai artifact to a local repository

The game as of artifact version 24, ready for local development with coding agents. - Source split from three large files into 52 small ones under src/sim, src/render and src/ui, joined in the order in src/manifest.json by build.py. The joined code is unchanged apart from comments; every headless suite gives the same output, and screenshots in both looks are pixel-identical to before. - Light tidying with no change in behaviour: one movement scan loop, shared hazard-stripe and belt shader helpers, unused code removed, a shared check helper for the test suites. - World files can be exported as an ordinary download outside claude.ai. - Tests: broken old scripts removed, experiments moved to tools/, test/run_all.py added. Tools: shot.py (repeatable screenshots), where.py, map.py. - Docs: AGENTS.md, CLAUDE.md, NOTES.md (the owner's to-do inbox), docs/PROJECT_MAP.md, DESIGN.md, TESTING.md, systems notes, the owner's requests and an agent log. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K9kLmYADKSEjuwUN3rFxDA
2026-10-23 16:05:31 -04:00
commit 3f971a94c2
100 changed files with 11928 additions and 0 deletions
@@ -0,0 +1,132 @@
+// Building blocks: placing, integrity, removing, lines and rectangles of blocks.
+// ---------- Blocks ----------
+function blockOf(x, y) { return { bx: Math.floor(x / BS), by: Math.floor(y / BS) }; }
+function blockCellList(bx, by) { const out = []; for (let y = by * BS; y < by * BS + BS; y++) for (let x = bx * BS; x < bx * BS + BS; x++) out.push(y * W + x); return out; }
+function pieceCost(code, v) { return code === BP_WALL ? wallCost(v, BS * BS) : PIECE_BY_CODE[code].cost; }
+function canPlaceBlock(bx, by) {
+  if (bx < 0 || by < 0 || bx >= BW || by >= BH) return 'Out of bounds';
+  if (blockP[by * BW + bx]) return 'Something is already built there';
+  for (const i of blockCellList(bx, by)) {
+    if (mach[i] || part[i]) return 'Something is already built there';
+    if (PH[mat[i]] === PH_SOLID) return 'Needs open space. Clear the rock first.';
+    if (occ[i]) return 'A bar is in the way';
+  }
+  return '';
+}
+// v: wall material (loose id) for walls, direction for belts and tubes
+function placeBlock(code, v, bx, by, free, extra) {
+  const err = canPlaceBlock(bx, by); if (err) return err;
+  if (code === BP_WALL && !WALL_OF[v]) return 'Pick a wall material with R';
+  const cost = pieceCost(code, v);
+  if (!free) { if (!canAfford(cost, 1)) return needText(cost, 1); payCost(cost, 1); }
+  const cells = blockCellList(bx, by);
+  if (code !== BP_PIPE) evictCells(cells, by * BS); // a pipe is thin: what is there stays and flows past it
+  for (const i of cells) {
+    const y = (i / W) | 0, x = i % W;
+    if (code === BP_WALL) setCell(i, WALL_OF[v], AMB[y], 0);
+    else if (code === BP_BELT) { setCell(i, v === 0 ? BELTL : BELTR, AMB[y], 0); markPow(i, true); }
+    else if (code === BP_SHAFT) { setCell(i, SHAFT, AMB[y], 0); markPow(i, true); }
+    else if (code === BP_GATE) setCell(i, GATE, AMB[y], 0);
+    else if (code === BP_GRATE) { part[i] = P_GRATE; wakeXY(x, y); }
+    else if (code === BP_TUBE) { part[i] = [P_TU, P_TR, P_TD, P_TL][v & 3]; markPow(i, true); wakeXY(x, y); }
+    else if (code === BP_FILTER) { part[i] = P_FILTER; wakeXY(x, y); }
+    else if (code === BP_PIPE) { part[i] = P_PIPE; wakeXY(x, y); }
+    else if (isPipeCode(code)) setCell(i, PIPE, AMB[y], 0);
+  }
+  if (isPipeCode(code)) pipesDirty = true;
+  blockP[by * BW + bx] = code; blockV[by * BW + bx] = v;
+  if (code === BP_FILTER) { blockV[by * BW + bx] = v & 128; filterCfg.set(by * BW + bx, filterRec(extra)); filtersDirty = true; }
+  stats.placed++;
+  undoNote({ t: 'block+', bx, by, code });
+  return '';
+}
+// How many of a block's cells still look like the piece the registry says is there
+function blockIntegrity(b) {
+  const code = blockP[b], v = blockV[b];
+  if (!code) return 0;
+  const bx = b % BW, by = (b / BW) | 0;
+  let n = 0;
+  for (const i of blockCellList(bx, by)) {
+    const m = mat[i], p = part[i];
+    if (code === BP_WALL) { if (PH[m] === PH_SOLID && !(flags[i] & F_NAT) && !PARTMAT[m]) n++; }
+    else if (code === BP_BELT) { if (m === BELTL || m === BELTR) n++; }
+    else if (code === BP_SHAFT) { if (m === SHAFT) n++; }
+    else if (code === BP_GATE) { if (m === GATE || p === P_GOPEN) n++; }
+    else if (code === BP_GRATE) { if (p === P_GRATE) n++; }
+    else if (code === BP_TUBE) { if (p >= P_TU && p <= P_TR) n++; }
+    else if (code === BP_FILTER) { if (p === P_FILTER) n++; }
+    else if (isPipeCode(code)) { if (m === PIPE || p === P_PIPE) n++; }
+  }
+  void v;
+  return n;
+}
+function removeBlock(bx, by) {
+  const b = by * BW + bx, code = blockP[b], v = blockV[b];
+  if (!code) return 0;
+  undoNote({ t: 'block-', bx, by, code, v, extra: code === BP_FILTER ? filterInfo(b) : undefined });
+  // a pipe taken out spills its share of what the line holds
+  const spill = isPipeCode(code) ? pipeTakeShare(b) : null;
+  let n = 0, metal = 0;
+  for (const i of blockCellList(bx, by)) {
+    const m = mat[i], p = part[i];
+    if (code === BP_WALL) {
+      if (PH[m] === PH_SOLID && !(flags[i] & F_NAT) && !PARTMAT[m] && m !== SPRING) {
+        if (BAR_OF[m] && PH[v] === PH_ITEM) { metal++; setCell(i, EMPTY, temp[i], 0); }
+        else if (YLD[m] && bagAdd(YLD[m], 1, false) === 0) { setCell(i, YLD[m], temp[i], 0); droppedLast++; } // bag full: it crumbles in place
+        else setCell(i, EMPTY, temp[i], 0);
+        n++;
+      }
+    } else if (isPipeCode(code)) {
+      if (p === P_PIPE) { part[i] = 0; wakeIdx(i); n++; }
+      else if (m === PIPE) { setCell(i, EMPTY, temp[i], 0); n++; }
+    } else if (code === BP_BELT || code === BP_SHAFT || code === BP_GATE) {
+      if (m === BELTL || m === BELTR || m === SHAFT || m === GATE) { setCell(i, EMPTY, temp[i], 0); markPow(i, false); n++; }
+      if (p === P_GOPEN) { part[i] = 0; n++; wakeIdx(i); }
+    } else if (p) { part[i] = 0; markPow(i, false); wakeIdx(i); n++; }
+  }
+  if (code === BP_WALL && metal) giveOrDrop(BAR_OF[WALL_OF[v]] || BARCU, Math.floor(metal / GRAINS_PER_BAR), bx * BS + 2, by * BS + 2);
+  else if (code !== BP_WALL && n >= 8) refundAt(PIECE_BY_CODE[code].cost, 1, bx * BS + 2, by * BS + 2);
+  if (code === BP_FILTER) { filtersDirty = true; filterCfg.delete(b); }
+  blockP[b] = 0; blockV[b] = 0;
+  if (isPipeCode(code)) {
+    pipesDirty = true;
+    if (spill) { let k = spill.n; for (let y = by * BS + BS - 1; y >= by * BS && k > 0; y--) for (let x = bx * BS; x < bx * BS + BS && k > 0; x++) { const i = y * W + x; if (mat[i] === EMPTY) { setCell(i, spill.m, spill.T, 0); k--; } } }
+  }
+  return n;
+}
+// Straight line of blocks along the dominant axis
+function blockLine(bx0, by0, bx1, by1) {
+  const out = [];
+  if (Math.abs(bx1 - bx0) >= Math.abs(by1 - by0)) { const s = bx1 >= bx0 ? 1 : -1; for (let x = bx0; ; x += s) { out.push([x, by0]); if (x === bx1) break; } }
+  else { const s = by1 >= by0 ? 1 : -1; for (let y = by0; ; y += s) { out.push([bx0, y]); if (y === by1) break; } }
+  return out;
+}
+function blockRect(bx0, by0, bx1, by1) {
+  const out = [];
+  for (let y = Math.min(by0, by1); y <= Math.max(by0, by1); y++) for (let x = Math.min(bx0, bx1); x <= Math.max(bx0, bx1); x++) out.push([x, y]);
+  return out;
+}
+function blockInReach(bx, by) { return inReach(bx * BS + BS / 2, by * BS + BS / 2); }
+// Is block b already exactly this piece (same kind, variant and, for a filter, settings)?
+function blockIs(b, code, v, extra) {
+  if (blockP[b] !== code) return false;
+  if (code === BP_FILTER) return (blockV[b] & 128) === (v & 128) && sameFilter(filterInfo(b), cleanFilterCfg(extra));
+  return blockV[b] === v;
+}
+// replace: a block already built in the way is taken down (and refunded) to make room
+function placeBlocks(code, v, list, extra, replace) {
+  let n = 0, last = '';
+  for (const [bx, by] of list) {
+    if (!blockInReach(bx, by)) { last = 'Out of reach'; continue; }
+    const b = by * BW + bx;
+    if (replace && blockP[b]) {
+      if (blockIs(b, code, v, extra)) continue;
+      if (blockP[b] === BP_FILTER && code === BP_FILTER) { undoNote({ t: 'filter', bx, by, v: blockV[b], extra: filterInfo(b) }); blockV[b] = v & 128; setFilter(b, extra); filtersDirty = true; n++; continue; } // just re-set it
+      if (!canAfford(pieceCost(code, v), 1)) { last = needText(pieceCost(code, v), 1); break; }
+      removeBlock(bx, by);
+    }
+    const r = placeBlock(code, v, bx, by, false, extra);
+    if (r) { last = r; if (r.startsWith('Not enough') || r.startsWith('Pick')) break; } else n++;
+  }
+  return { n, status: n ? '' : last };
+}