Grinder and Saw hopper blocks replace the Refiner and Stone cutter in the menu (t4)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/render/world.js

@@ -115,6 +115,11 @@ function drawWorld() {
         }
         else if (m === GATE) { if ((x & 1) === 0 && (y & 3) !== 0) { r -= 40; g -= 24; b -= 20; } }
         else if (m === CUTST) { const lx = x & 3, ly = y & 3; if (ly === 1 || ly === 3 || lx === (ly < 2 ? 3 : 1)) { r -= 34; g -= 33; b -= 30; } else if (ly === 0 || ly === 2) { r += 10; g += 10; b += 9; } }
+        else if (m === GRINDER || m === SAWB) {
+          const s = procState.get((y >> 2) * BW + (x >> 2)), step = s && tick - s.busyT < 30 ? anim >> 2 : 0, lx = x & 3, ly = y & 3;
+          const tooth = m === GRINDER ? (ly === 1 || ly === 2) && ((lx + ly + step) & 1) : ly === 1 || ly === 2 && ((lx + step) & 1);
+          r = tooth ? 166 : 46; g = tooth ? 174 : 52; b = tooth ? 186 : 62;
+        }
         else if (m === WOOD) { if ((y & 3) === 2 || ((x + (y >> 2) * 3) & 7) === 0) { r -= 26; g -= 22; b -= 16; } } // planks
         else if (m === LWOOD) { if (((x * 3 + y) & 3) === 0) { r -= 30; g -= 26; b -= 18; } } // stringy fibres
         else if (m === HULL) { if (((x * 7 + y * 3) & 15) === 0) { r += 20; g += 20; b += 22; } }

src/sim/blocks.js

@@ -26,6 +26,7 @@ function placeBlock(code, v, bx, by, free, extra) {
     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 (isProcCode(code)) setCell(i, code === BP_GRIND ? GRINDER : SAWB, AMB[y], 0);
     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); }
@@ -36,6 +37,7 @@ function placeBlock(code, v, bx, by, free, extra) {
   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; }
+  if (isProcCode(code)) procDirty = true;
   stats.placed++;
   undoNote({ t: 'block+', bx, by, code });
   return '';
@@ -51,6 +53,7 @@ function blockIntegrity(b) {
     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 (isProcCode(code)) { if (m === (code === BP_GRIND ? GRINDER : SAWB)) 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++; }
@@ -79,14 +82,15 @@ function removeBlock(bx, by) {
     } 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++; }
+    } else if (code === BP_BELT || code === BP_SHAFT || code === BP_GATE || isProcCode(code)) {
+      if (m === BELTL || m === BELTR || m === SHAFT || m === GATE || m === GRINDER || m === SAWB) { 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); }
+  if (isProcCode(code)) { procDirty = true; procState.delete(b); }
   blockP[b] = 0; blockV[b] = 0;
   if (isPipeCode(code)) {
     pipesDirty = true;

src/sim/machine-tick.js

@@ -45,6 +45,7 @@ function fanBlow(mm, sat) {
   }
 }
 function machinesTick() {
+  procBlocksTick();
   if (powerDirty && tick >= nextPowerBuild) { rebuildPower(); nextPowerBuild = tick + 6; }
   if (brokenMachines.length) {
     const ids = brokenMachines; brokenMachines = [];

src/sim/materials.js

@@ -11,8 +11,8 @@ const EMPTY = 0, GRASS = 1, DIRT = 2, LDIRT = 3, SAND = 4, GRAVEL = 5, CLAY = 6,
   ZNV = 63, ZNORE = 64, ZINC = 65, MZN = 66, SCRZN = 67, BARZN = 68,
   AGV = 69, AGORE = 70, SILVER = 71, MAG = 72, SCRAG = 73, BARAG = 74,
   AUV = 75, AUORE = 76, GOLD = 77, MAU = 78, SCRAU = 79, BARAU = 80,
-  BRONZE = 81, MBZ = 82, SCRBZ = 83, BARBZ = 84, BRASS = 85, MBS = 86, SCRBS = 87, BARBS = 88, DOCKW = 89, MSLAG = 90, PIPE = 91, BARGL = 92, CUTST = 93, BARSB = 94;
-const NMAT = 95;
+  BRONZE = 81, MBZ = 82, SCRBZ = 83, BARBZ = 84, BRASS = 85, MBS = 86, SCRBS = 87, BARBS = 88, DOCKW = 89, MSLAG = 90, PIPE = 91, BARGL = 92, CUTST = 93, BARSB = 94, GRINDER = 95, SAWB = 96;
+const NMAT = 97;
 
 const MD = [];
 function def(id, o) {
@@ -62,6 +62,8 @@ def(BELTL, { name: 'Belt', col: [66, 68, 74], v: 4, k: 0.03, hard: 2, melt: 1085
 def(BELTR, { name: 'Belt', col: [66, 68, 74], v: 4, k: 0.03, hard: 2, melt: 1085, meltTo: MCU, partMat: true });
 def(SHAFT, { name: 'Shaft', col: [150, 110, 64], v: 6, k: 0.005, hard: 2, ign: 340, flame: 800, flameF: 1000, fuel: 140, burnTo: ASH, ashP: 0.3, partMat: true });
 def(GATE, { name: 'Gate', col: [146, 74, 58], v: 6, k: 0.004, hard: 3, melt: 1750, meltTo: MAGMA, partMat: true });
+def(GRINDER, { name: 'Grinder', col: [64, 70, 80], v: 4, k: 0.035, hard: 6, melt: 1450, meltTo: MST, partMat: true });
+def(SAWB, { name: 'Saw', col: [74, 80, 90], v: 4, k: 0.035, hard: 6, melt: 1450, meltTo: MST, partMat: true });
 def(SPRING, { name: 'Spring', col: [92, 112, 128], v: 30, k: 0.012, hard: 9, yld: 0, desc: 'Groundwater seeps out of this rock whenever there is room next to it.' });
 def(RSTONE, { name: 'Stone rubble', ph: PH_POWDER, col: [126, 125, 130], v: 30, dens: 1.8, k: 0.01, hard: 0, melt: 1250, meltTo: MAGMA, bag: true, desc: 'Broken stone. 16 grains make a stone block.' });
 def(RGRAN, { name: 'Granite rubble', ph: PH_POWDER, col: [164, 128, 124], v: 32, dens: 1.9, k: 0.01, hard: 0, melt: 1260, meltTo: MAGMA, bag: true, desc: 'Broken granite. Makes granite blocks.' });

src/sim/pieces.js

@@ -4,7 +4,7 @@
 // Everything you build snaps to a grid of 4x4-grain blocks. The world itself
 // stays grain-level; only built pieces snap.
 const BS = 4;
-const BP_WALL = 1, BP_BELT = 2, BP_TUBE = 3, BP_SHAFT = 4, BP_GRATE = 5, BP_GATE = 6, BP_FILTER = 7, BP_PIPE = 8, BP_PUMP = 9, BP_OUTLET = 10;
+const BP_WALL = 1, BP_BELT = 2, BP_TUBE = 3, BP_SHAFT = 4, BP_GRATE = 5, BP_GATE = 6, BP_FILTER = 7, BP_PIPE = 8, BP_PUMP = 9, BP_OUTLET = 10, BP_GRIND = 11, BP_SAW = 12;
 function isPipeCode(c) { return c === BP_PIPE || c === BP_PUMP || c === BP_OUTLET; }
 // Filters: each filter block has a set of materials and a mode. In drop mode (inv 0)
 // the chosen materials fall through and everything else rides along on top; in carry
@@ -57,15 +57,19 @@ const PIECES = [
     desc: 'Draws liquid in at the tail of its arrow (keep that side under water) and pushes it into the pipes on its other sides, about 60 grains a second while the line has room. It takes water and anything else cooler than 500°C, one liquid at a time per line. Press F to switch it on or off.' },
   { id: 'outlet', code: BP_OUTLET, name: 'Outlet', kind: 'block', cost: [[CASH, 15]], dirs: ['down', 'left', 'up', 'right'],
     desc: 'Lets a pipe line\'s liquid out of the side its arrow points to, wherever there is room for it. Press F to open or close it.' },
+  { id: 'grinder', code: BP_GRIND, name: 'Grinder', kind: 'block', cost: [[CASH, 60]],
+    desc: 'Grinds rubble, gravel, sand and dirt resting on top into sand and the odd grain of ore. Results drop out below; keep that space clear. Wider rows grind faster. Stack under a Saw to cut stone and grind the rest.' },
+  { id: 'saw', code: BP_SAW, name: 'Saw', kind: 'block', cost: [[CASH, 90]],
+    desc: 'Cuts stone rubble resting on top into a brick for every 8 grains. Results drop out below; keep that space clear. Wider rows cut faster. Stack over a Grinder to grind everything else.' },
   { id: 'wheel', name: 'Water wheel', kind: 'machine', bw: 3, bh: 3, cost: [[LWOOD, 48]], hidden: POWER_FREE,
     desc: 'Makes power when liquid falls through it. More flow, more power.' },
   { id: 'fan', name: 'Fan', kind: 'machine', bw: 1, bh: 1, cost: [[CASH, 60]], dirs: ['right', 'down', 'left', 'up'],
     desc: 'Blows gas and forces air into fires, making them far hotter: its stream reaches 28 grains and passes through grates but not walls. Its copper body melts at 1085°C, so keep it outside the furnace, a block clear of the wall, blowing in through a grate. Press F to switch it on or off.' },
-  { id: 'cutter', name: 'Stone cutter', kind: 'machine', bw: 2, bh: 2, cost: [[CASH, 90]],
+  { id: 'cutter', hidden: true, name: 'Stone cutter', kind: 'machine', bw: 2, bh: 2, cost: [[CASH, 90]],
     desc: 'A saw under a hopper. Stone rubble dropped in is cut into stone bricks, one from every 8 grains, which drop out underneath. Builders buy stone bricks, and they make neat cut stone walls that stand more heat than rough stone. Anything else falls straight through.' },
   { id: 'silo', name: 'Silo', kind: 'machine', bw: 3, bh: 6, cost: [[CASH, 180]],
     desc: 'A steel bin on legs for one loose material: up to 4,000 grains go in through the hatch in its roof (drop them in from a belt or tube). Its gauge shows how full it is. Press F to open the gate in its cone and let it out underneath, about 60 grains a second; F again shuts it. The first material in decides what it holds until it is empty.' },
-  { id: 'refiner', name: 'Refiner', kind: 'machine', bw: 3, bh: 3, cost: [[CASH, 120]],
+  { id: 'refiner', hidden: true, name: 'Refiner', kind: 'machine', bw: 3, bh: 3, cost: [[CASH, 120]],
     desc: 'A crushing sieve. Drop stone, granite or basalt rubble, gravel, sand or dirt into its hopper: it grinds each grain, keeps the odd grain of ore it finds (clay, from dirt) and lets about half as much fine sand out of the chute underneath. Ore and anything else it cannot grind falls straight through. Keep the space under the chute clear, or a belt running under it.' },
   { id: 'engine', name: 'Steam engine', kind: 'machine', bw: 3, bh: 2, cost: [[BARCU, 10]], dirs: ['exhaust right', 'exhaust left'], hidden: POWER_FREE,
     desc: 'Steam rising into the intake slots on its underside drives it. Condensate drips out the exhaust side.' },

src/sim/processors.js

@@ -74,6 +74,72 @@ function cutterTick(mm) {
     jobs--; mm.busyT = tick;
   }
 }
+// Block hoppers share an outlet down a vertical stack; only its top spends work.
+let procState = new Map(), procBlocks = [], procDirty = true;
+function isProcCode(c) { return c === BP_GRIND || c === BP_SAW; }
+function rebuildProcessors() {
+  procBlocks = [];
+  for (let b = 0; b < NB; b++) if (isProcCode(blockP[b])) {
+    procBlocks.push(b);
+    if (!procState.has(b)) procState.set(b, { work: 0, cut: 0, busyT: -999, blocked: false });
+  }
+  procDirty = false;
+}
+function procBottom(b) { while (b + BW < NB && isProcCode(blockP[b + BW])) b += BW; return b; }
+function procSlot(b) {
+  const y = (((b / BW) | 0) + 1) * BS, x = (b % BW) * BS;
+  if (y >= H) return -1;
+  for (let k = 0; k < 4; k++) { const j = y * W + x + [1, 2, 0, 3][k]; if (mat[j] === EMPTY && !part[j] && !occ[j] && !mach[j]) return j; }
+  return -1;
+}
+function procFeed(b, m, T) {
+  const end = procBottom(b), x = (b % BW) * BS, y = ((b / BW) | 0) * BS - 1;
+  for (;;) {
+    const s = procState.get(b); s.busyT = tick;
+    if (blockP[b] === BP_GRIND && PH[m] === PH_POWDER && REFINE[m]) {
+      const from = m; let got = 0;
+      for (const [chance, o] of REFINE[m]) if (rnd() < chance) { got = o; break; }
+      if (got) { stats.refinedOre = (stats.refinedOre || 0) + 1; discover(got, x, y, from, 'refine'); }
+      else if (rnd() < REFINE_SAND) got = SAND;
+      stats.refined = (stats.refined || 0) + 1; m = got;
+      if (!m) return;
+    } else if (blockP[b] === BP_SAW && m === RSTONE) {
+      if (++s.cut < CUT_PER_BRICK) return;
+      s.cut = 0; m = BARSB;
+    }
+    if (b === end) break;
+    b += BW;
+  }
+  if (m === BARSB) {
+    const e = spawnBar(BARSB, x, (((end / BW) | 0) + 1) * BS, (rnd() - 0.5) * 0.1, 0.05);
+    if (e) { e.T = T; discover(BARSB, x, y, RSTONE, 'cut'); stats.bricks = (stats.bricks || 0) + 1; }
+  } else setCell(procSlot(end), m, T, 0);
+}
+function procBlocksTick() {
+  if (procDirty) rebuildProcessors();
+  for (const b of procBlocks) {
+    if (b >= BW && isProcCode(blockP[b - BW])) continue;
+    const s = procState.get(b), end = procBottom(b), y = ((b / BW) | 0) * BS - 1, x = (b % BW) * BS;
+    s.work += blockP[b] === BP_GRIND ? 0.25 : 0.5;
+    let jobs = Math.floor(s.work); s.work -= jobs;
+    if (!jobs || y < 0) continue; // a tick without work keeps the last blocked state, so it doesn't flicker
+    for (let q = b; q <= end; q += BW) procState.get(q).blocked = false;
+    for (let k = 0; k < 4 && jobs > 0; k++) {
+      const i = y * W + x + ((k + tick) & 3), m = mat[i];
+      if (m === EMPTY || PH[m] === PH_GAS || PH[m] === PH_SOLID || stamp[i] === tickStamp) continue;
+      let brick = false;
+      if (m === RSTONE) for (let q = b; q <= end; q += BW) {
+        if (blockP[q] === BP_GRIND) break;
+        if (blockP[q] === BP_SAW) { brick = procState.get(q).cut + 1 >= CUT_PER_BRICK; break; }
+      }
+      if (procSlot(end) < 0 || brick && !entFreeAt(x, (((end / BW) | 0) + 1) * BS)) {
+        for (let q = b; q <= end; q += BW) procState.get(q).blocked = true;
+        break;
+      }
+      const T = temp[i]; setCell(i, EMPTY, AMB[y], 0); procFeed(b, m, T); jobs--;
+    }
+  }
+}
 // ---------- Silo ----------
 // One loose material, counted (not simulated grain by grain inside): grains in the roof hatch
 // go in, and with the gate open they come out of the bottom of the cone.

src/sim/save.js

@@ -37,7 +37,7 @@ function deserializeWorld(meta, buffers) {
   computeAmbient(); fillNoise();
   mat.set(buffers.mat); life.set(buffers.life); flags.set(buffers.flags);
   for (let i = 0; i < N; i++) if (mat[i] === SPRING) mat[i] = STONE; // springs are gone: older worlds keep plain rock there
-  blockP.set(buffers.blockP); blockV.set(buffers.blockV); filtersDirty = true;
+  blockP.set(buffers.blockP); blockV.set(buffers.blockV); filtersDirty = true; rebuildProcessors();
   // pipes used to be solid copper blocks; now they are thin and let things past
   for (let b = 0; b < NB; b++) if (blockP[b] === BP_PIPE) for (const i of blockCellList(b % BW, (b / BW) | 0)) if (mat[i] === PIPE) { mat[i] = EMPTY; part[i] = P_PIPE; }
   for (const [b, m, inv] of meta.filters || []) if (blockP[b] === BP_FILTER) filterCfg.set(b, filterRec({ m, inv }));

src/sim/world.js

@@ -44,7 +44,7 @@ function alloc(w, h) {
   mat = new Uint8Array(N); temp = new Float32Array(N); life = new Uint8Array(N); flags = new Uint8Array(N);
   stamp = new Uint8Array(N); part = new Uint8Array(N); mach = new Uint16Array(N); digp = new Uint8Array(N);
   noiseB = new Uint8Array(N); bgm = new Uint8Array(N); airS = new Uint16Array(N); netId = new Uint16Array(N); isPow = new Uint8Array(N); occ = new Uint8Array(N);
-  BW = Math.ceil(w / BS); BH = Math.ceil(h / BS); NB = BW * BH; blockP = new Uint8Array(NB); blockV = new Uint8Array(NB); filtersDirty = true; filterCfg = new Map();
+  BW = Math.ceil(w / BS); BH = Math.ceil(h / BS); NB = BW * BH; blockP = new Uint8Array(NB); blockV = new Uint8Array(NB); filtersDirty = true; filterCfg = new Map(); procDirty = true; procState.clear();
   ents = []; flyers = []; ghostBlocks = new Map(); ghostMolds = []; treeBases = []; saplings = [];
   surfBase = Math.round(Math.min(h * 0.27, 175)); underD = h - surfBase; shallowD = 0; lapse = 0.36;
   surfY = new Int16Array(w); roofY = new Int16Array(w); dirtY = new Int16Array(w); graniteY = new Int16Array(w); basaltY = new Int16Array(w); magmaY = new Int16Array(w);

src/ui/build-menu.js

@@ -4,7 +4,7 @@ const BUILD_CATS = [
   ['Structure', ['wall', 'grate', 'gate']],
   ['Moving', ['belt', 'filter', 'tube']],
   ['Liquids', ['pipe', 'pump', 'outlet']],
-  ['Machines', ['fan', 'refiner', 'cutter', 'silo']],
+  ['Machines', ['fan', 'grinder', 'saw', 'silo']],
   ['Molds', ['ingotmold', 'bitmold', 'tankmold']],
 ];
 const BUILD_ORDER = BUILD_CATS.flatMap(c => c[1]);
@@ -21,6 +21,8 @@ const PIECE_ICONS = {
   fan: '<circle cx="12" cy="12" r="1.8"/><path d="M12 10.2c-.4-3.6 1.8-6 4-4.8 2 1.2.4 3.8-4 4.8zM13.8 12c3.6-.4 6 1.8 4.8 4-1.2 2-3.8.4-4.8-4zM12 13.8c.4 3.6-1.8 6-4 4.8-2-1.2-.4-3.8 4-4.8zM10.2 12c-3.6.4-6-1.8-4.8-4 1.2-2 3.8-.4 4.8 4z"/>',
   refiner: '<path d="M3 4h18l-5 7H8z"/><circle cx="9" cy="15.5" r="2.8"/><circle cx="15" cy="15.5" r="2.8"/><path d="M12 20v2"/>',
   cutter: '<path d="M5 3h14l-3 5H8z"/><circle cx="12" cy="15" r="5"/><circle cx="12" cy="15" r="1.2"/><path d="M12 9.2v1.6M17.8 15h-1.6M12 20.8v-1.6M6.2 15h1.6"/>',
+  grinder: '<path d="M3 4h18l-5 7H8z"/><circle cx="9" cy="15.5" r="2.8"/><circle cx="15" cy="15.5" r="2.8"/><path d="M12 20v2"/>',
+  saw: '<path d="M5 3h14l-3 5H8z"/><circle cx="12" cy="15" r="5"/><circle cx="12" cy="15" r="1.2"/><path d="M12 9.2v1.6M17.8 15h-1.6M12 20.8v-1.6M6.2 15h1.6"/>',
   silo: '<path d="M6 5.5h12v11H6z"/><path d="M6 5.5l1-2h10l1 2M6 16.5l4 3h4l4-3M7 16.5v5M17 16.5v5"/><path d="M15.5 8v6"/>',
   ingotmold: '<path d="M3 9h18l-2 7H5z"/><path d="M9.2 9l.8 7M14.8 9l-.8 7"/>',
   bitmold: '<path d="M3 9h10l7 3-7 3H3z"/><path d="M6.5 9v6M9.5 9v6"/>',

src/ui/info.js

@@ -31,8 +31,8 @@ function howText(e) {
     case 'blow': return 'Air blown through molten iron burned off its extra carbon.';
     case 'alloy': return `${F} melted into molten copper and the two mixed.`;
     case 'char': return `${F} got hot with no air to burn in, and charred.`;
-    case 'refine': return `Sifted out of ${f} by a Refiner.`;
-    case 'cut': return `Cut from ${f} by a Stone cutter.`;
+    case 'refine': return `Ground out of ${f}.`;
+    case 'cut': return `Cut from ${f} by a saw.`;
     default: return '';
   }
 }
@@ -93,6 +93,10 @@ function hoverInfo(ax, ay) {
     if (mm.type === 'silo') t2.push(mm.sn ? `holds ${mm.sn.toLocaleString('en-US')} / ${SILO_CAP.toLocaleString('en-US')} ${MD[mm.sm].name.toLowerCase()}` : `empty (holds ${SILO_CAP.toLocaleString('en-US')} grains of one material)`, mm.open ? 'gate open · F shuts it' : 'gate shut · F opens it');
     if (mm.type === 'cutter') t2.push(mm.blocked ? 'stopped: clear the space under it' : tick - (mm.busyT || -999) < 30 ? 'cutting' : 'idle: drop stone rubble in', `${(stats.bricks || 0).toLocaleString('en-US')} bricks cut`);
     if (mm.type === 'refiner') t2.push(mm.blocked ? 'stopped: clear the space under its chute' : tick - (mm.busyT || -999) < 30 ? 'grinding' : 'idle: drop rubble, gravel, sand or dirt in', `${(stats.refined || 0).toLocaleString('en-US')} ground, ${(stats.refinedOre || 0).toLocaleString('en-US')} ore found`);
+  } else if (isProcCode(b)) {
+    const s = procState.get((ay >> 2) * BW + (ax >> 2)), saw = b === BP_SAW;
+    t1 = saw ? 'Saw' : 'Grinder';
+    t2.push(s && s.blocked ? 'stopped: clear the space under it' : s && tick - s.busyT < 30 ? saw ? 'cutting' : 'grinding' : saw ? 'idle: drop stone rubble on top' : 'idle: drop rubble, gravel, sand or dirt on top', saw ? `${(stats.bricks || 0).toLocaleString('en-US')} bricks cut` : `${(stats.refined || 0).toLocaleString('en-US')} ground, ${(stats.refinedOre || 0).toLocaleString('en-US')} ore found`);
   } else if (p === P_FILTER) {
     const fb = ((ay / BS) | 0) * BW + ((ax / BS) | 0), pr = filterParts(filterInfo(fb)), ar = blockV[fb] & 128 ? '→' : '←';
     t1 = 'Filter ' + ar; t2.push(`drops ${pr.drops}`, `carries ${pr.rides} ${ar}`, 'F to change · I shows all');

src/ui/notebook.js

@@ -182,7 +182,7 @@ function controlsHtml() {
   const tools = [
     ['1 Resonance drill', 'Hold left click to send pulses from the bot toward the cursor: rock they shake hard enough shatters and falls as rubble, ore, coal or scrap, and trees come apart into wood chunks and acorns. Q and E set the pulse width: narrow bores a tunnel fast, wide clears a big cone slowly, medium is in between. R over a material tunes the drill to it, so only that shatters (great for pulling a vein out of the rock); R again untunes. Built blocks are never harmed. Better bits dig harder rock, faster and further.'],
     ['2 Pneumatic nozzle', "Left drag picks up the selection, or what you click if nothing is selected. Right click blows the selection. Click a bag name or Q/E selects one; Ctrl+click mixes. Hold Ctrl to see everything found. Clear removes the selection. Bars blow alone. Blowing out the last of a material deselects it. Shift while not flying takes everything; Shift + right click blows everything loose in the bag."],
-    ['3 Build', 'Places pieces on a grid of 4×4 blocks: wall blocks, belts, tubes, filters, grates, gates, pipes, pumps and outlets, machines (fans, the Refiner) and molds. Drag for a line, hold Shift while dragging for a filled rectangle. Right click takes a piece back. Your bot flies through anything you build.'],
+    ['3 Build', 'Places pieces on a grid of 4×4 blocks: wall blocks, belts, tubes, filters, grates, gates, pipes, pumps, outlets, Grinders and Saws, machines (fans and silos) and molds. Drag for a line, hold Shift while dragging for a filled rectangle. Right click takes a piece back. Your bot flies through anything you build.'],
     ['4 Igniter', 'Heats a small spot to 640°C, and its flame reaches a few grains into a pile. Enough to light coal and wood that touch air.'],
     ['Copy, cut and paste', 'Hold C (copy) or X (cut) and drag a box over what you built; let go and it is picked up, ready to paste. Cut takes it down and refunds it to your bag. Click to place ghosts: your bot builds them from your bag when it is close. R flips, V pastes again, right click or Esc stops. Ctrl+Z undoes building. The notebook (B) keeps saved blueprints and a few starter designs.'],
   ];