From 729378770a0ea9c6365412fc7cf19bb907ce0b20 Mon Sep 17 00:00:00 2001 From: 44r0n7 <44r0n7+gitea@pm.me> Date: Wed, 28 Oct 2026 18:09:42 -0400 Subject: [PATCH] Drill pulses pass through rubble and fluidise it; per-grain damping (t92) Co-Authored-By: Claude Opus 5.5 --- docs/PROJECT_MAP.md | 6 +-- docs/agent-log.md | 38 ++++++++++++++++++ src/sim/drill.js | 58 ++++++++++++++++----------- test/t_drill.js | 97 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 172 insertions(+), 27 deletions(-) diff --git a/docs/PROJECT_MAP.md b/docs/PROJECT_MAP.md index b9ba83f..392f6ea 100644 --- a/docs/PROJECT_MAP.md +++ b/docs/PROJECT_MAP.md @@ -327,7 +327,7 @@ Tool helpers: reach, brushes, and plain digging. - functions: setBuildRange, inBuildRange, inReach, forBrush, drillReach, inDrillReach, toolDig - variables: BUILD_MAX, buildBox -### src/sim/drill.js (177 lines) +### src/sim/drill.js (187 lines) The resonance drill: tuned pulses that shatter one material. - functions: drillOrigin, pulseRay, builtCell, toolPulse, crumbleAround, crumbly, shatterCell, pulseTick, pingRadius, resonancePing - variables: PULSE_W, PULSE_EVERY, PULSE_SPEED, PULSE_K, drillPulses, lastPulseTick, drillWidth, THIN_BONUS, CRUMBLE_MAX, THIN_BONUS_OFF, PING_VEINS @@ -443,7 +443,7 @@ GPU sources retain the CPU roof and transmission rules; directional relaxation f Smooth slope geometry and cleats, ported from slope-belt-shader.js. - variables: GPU_SMOOTH_SLOPE_HELPERS, GPU_SMOOTH_SLOPE_DRAW -### src/render/gpu/smooth-shader.js (368 lines) +### src/render/gpu/smooth-shader.js (369 lines) Literal port of the legacy smooth shader; dpdy is reversed for WebGPU's top-left origin. - variables: GPU_SMOOTH @@ -648,7 +648,7 @@ The frame loop and boot. - `test/t_fog.js`: Fog: surface, sight, range, saves and simulation independence. - `test/t_furnace_repeat.js`: The starter furnaces keep working when fired again and again without cleaning, however the charge goes in: mixed, ore first with coal on top, or blown in through the vent. Each case plays furnace_play.js, which builds the design and fires it like a player. - `test/t_gpu.py`: Dirty uploads, default limits, warm pipelines, world replacement and device recovery. -- `test/t_gpu_golden.py`: Frozen legacy references, captured before retirement; compare the WebGPU world only. +- `test/t_gpu_golden.py`: Frozen world references; seven smooth crops corrected for continuous noise in t91. - `test/t_gpu_light.py`: The former CPU light behavioural checks, now read from the actual GPU light grid. - `test/t_joins.js`: The oracle states the geometric rule independently of the precomputed neighbour tables. - `test/t_load.js`: Reload wakes nearby areas first, without losing distant water, fire or saved state. diff --git a/docs/agent-log.md b/docs/agent-log.md index b6fadaf..e3820ce 100644 --- a/docs/agent-log.md +++ b/docs/agent-log.md @@ -4,6 +4,44 @@ What agents have done, newest first. Add an entry for every piece of work: the d note or request it was for, what changed, the files touched, the tests run, and anything left open or not verified. Keep each entry short; the git history has the details. +## 2026-10-28: t92 drill pulses pass through rubble and fluidise it (Codex) + +- Converted every pulse loss to a per-grain factor, applied with `factor ** step` outside + the ray sampling loop. Powder keeps 0.97 per grain; liquid, built, hard and tuned paths + preserve their former squared half-grain factors. Tree damping and shake now scale with + distance too. Rock damping retuned to 0.76/0.69/0.6084 per grain for narrow/medium/wide. +- Replaced the botward nudge with random sideways/upward one-cell hops through open cells, + using `rnd`, `move`, stamps, occupancy, part/cleat rules and sealed corners. At most three + moves per ray/tick. Up to four shake debris events/tick reuse the existing particles; + no new rendering or UI code, dependencies, save fields or design decisions. +- Added drill regressions: 35-grain shield failed before (0 basalt opened), now opens 78 + basalt cells with the real steel medium reach; 115 grains opens none. Only the latter + fixture extends range beyond the bit's reach, isolating attenuation from range. + Exact 3% loss crosses the cutoff near 117 grains; an additional 118-grain check + confirms extinction before any basalt damage. Fixed + powder transmission is 0.4821/1.4 = 34.44%; quarter/half/whole-grain attenuation agrees + for rubble, sand, ore, coal, liquids, rock, tuned skips/hits and built material. + Seeded heap height drops 25 -> 20 in eight seconds versus control 25 -> 25, conserving + 625 grains; repeatability, movement protection, three-move/ray and four-event caps pass. +- Before/after two-second copper-bit stone-wall fixture, depth/opened cells: narrow + 22/181 -> 24/195 (+9.1%/+7.7%), medium 13/186 -> 13/197 (0%/+5.9%), wide + 6/134 -> 6/134. Existing follow-face, width, tuning, shielding and tree checks retained. + Fixed powder-ray microbenchmark median: 21.48 -> 21.28 ms per 20,000 calls (five warm + samples); this is an isolated pulse cost check, not a whole-game performance measurement. +- Files: `src/sim/drill.js`, `test/t_drill.js`, generated `docs/PROJECT_MAP.md`, t92 task + tracking and this log. No commit. Verification: focused drill suite passes all 61 checks; + initial full run passed all 32 headless suites but seven browser suites failed under the + sandbox's unavailable WebGPU adapter. Host-GPU `python3 test/run_all.py --browser` exited + 0, ALL PASSED (all 32 headless suites; gameplay 361, smooth 28, console 18, caps 7, + GPU 14, goldens 28, light 71 and Firefox 2). The additional 118-grain extinction check + was then verified in the focused 61-check suite. Logs: `/tmp/t92-drill-before.log`, + `/tmp/t92-drill-red.log`, `/tmp/t92-drill-after.log`, `/tmp/t92-all-tests-host.log`. + Inspected `shots/t92-pile-before-pixel.png`, `t92-pile-after-pixel.png` and + `t92-pile-after-smooth.png`: the drilled side is lower and flatter, with small dust puffs + close to the surface. Setup scripts retained in `/tmp/t92-scene-before.js` and + `/tmp/t92-scene-after.js`; capture with `tools/shot.py --setup FILE --zoom 10 --no-light + --freeze` (add `--look smooth` for smooth). Task moved to Review; owner playtesting remains. + ## 2026-10-28: t91 sky renders as mismatched blocks (Codex) - Reproduced the owner's cloud rectangles and stepped distant hills on NVIDIA Blackwell: diff --git a/src/sim/drill.js b/src/sim/drill.js index d4329a3..28fc003 100644 --- a/src/sim/drill.js +++ b/src/sim/drill.js @@ -8,14 +8,15 @@ // medium: a cone, the all-rounder // wide: a broad fan that clears a big face close to the bot, but reaches only a short way // Tuned to one material, a pulse passes through everything else and shatters only that, and -// loose grains it passes are jostled toward the bot, so a shattered vein pours out of the wall. +// loose grains it passes are shaken into short hops, so piles flow and pockets drain. // Built blocks, machines and molds soak pulses up unharmed. // half: half the spread angle; mouth: half the width of the fan where it leaves the bot; -// en: energy per ray; damp: energy kept after each shake (higher bores deeper); reach: x bit reach +// en: energy per ray; damp: energy kept per grain (higher bores deeper); reach: x bit reach +// Narrow/medium compensate for rubble now passing pulses; wide keeps its old squared loss. const PULSE_W = [ - { name: 'narrow', half: 0.03, mouth: 3.2, rays: 13, en: 1.75, damp: 0.9, reach: 1.45 }, - { name: 'medium', half: 0.24, mouth: 3, rays: 23, en: 1.4, damp: 0.84, reach: 1 }, - { name: 'wide', half: 0.62, mouth: 3.4, rays: 41, en: 1.32, damp: 0.78, reach: 0.7 }, + { name: 'narrow', half: 0.03, mouth: 3.2, rays: 13, en: 1.75, damp: 0.76, reach: 1.45 }, + { name: 'medium', half: 0.24, mouth: 3, rays: 23, en: 1.4, damp: 0.69, reach: 1 }, + { name: 'wide', half: 0.62, mouth: 3.4, rays: 41, en: 1.32, damp: 0.6084, reach: 0.7 }, ]; const PULSE_EVERY = 8, PULSE_SPEED = 2.2, PULSE_K = 240; // ticks between pulses, cells per tick, shake per unit of energy let drillPulses = [], lastPulseTick = -99, drillWidth = 1; @@ -97,49 +98,58 @@ function shatterCell(i, x, y, m) { if ((stats.dug & 7) === 0) emit({ t: 'sfx', s: 'dig', a: HARD[m] }); } // Advance every pulse in flight by one tick -function pulseTick() { +function pulseTick(step = 0.5) { if (!drillPulses.length) return; const tier = BIT_TIERS[player.bitTier]; + // Per-grain losses; squared old half-grain factors preserve the rock/built/liquid paths. + const loose = 0.97 ** step, liquid = 0.970225 ** step, built = 0.0625 ** step; + const skip = 0.986049 ** step, hard = 0.1225 ** step, tuned = 0.9216 ** step; + const wood = 0.85 ** step, leaves = 0.97 ** step; + let dust = 0; // cells inside the bot's body are not touched (it flies in its own little space) const bx0 = Math.floor(bot.x), by0 = Math.floor(bot.y), bx1 = Math.ceil(bot.x + bot.w) - 1, by1 = Math.ceil(bot.y + bot.h) - 1; for (const p of drillPulses) { p.r += PULSE_SPEED; - const lim = Math.min(p.r, p.range), Wd = PULSE_W[p.w]; + const lim = Math.min(p.r, p.range), Wd = PULSE_W[p.w], damp = p.damp ** step; for (let k = 0; k < p.n; k++) { let e = p.en[k]; if (e < 0.04) continue; const ray = pulseRay(p.ox, p.oy, p.ang, Wd, -1 + 2 * (k + p.jit) / p.n), ux = ray.ux, uy = ray.uy; - let sd = p.s[k]; + let sd = p.s[k], kicks = 0; while (sd < lim && e >= 0.04) { - sd += 0.5; + sd += step; const x = Math.floor(ray.x + ux * sd), y = Math.floor(ray.y + uy * sd); if (x < 0 || y < 0 || x >= W || y >= H) { e = 0; break; } if (x >= bx0 && x <= bx1 && y >= by0 && y <= by1) continue; const i = y * W + x, m = mat[i], ph = PH[m]; if (ph === PH_EMPTY || ph === PH_GAS) { // standing trees in the way are shaken apart too (not by a tuned pulse) - if (bgm[i] && !p.tune && (sd * 2 & 1) === 0) { cutTree(i, x, y, tier, e * 0.5); e *= bgm[i] === WOOD ? 0.85 : 0.97; } + if (bgm[i] && !p.tune) { const loss = bgm[i] === WOOD ? wood : leaves; cutTree(i, x, y, tier, e * step * 0.5); e *= loss; } continue; } - if (ph === PH_LIQUID) { e *= 0.985; continue; } + if (ph === PH_LIQUID) { e *= liquid; continue; } if (ph === PH_POWDER) { - // loose grains are jostled back toward the bot, so a shattered pocket drains out of the - // wall and a bore clears itself: straight back if there is room, else down or up a step - e *= 0.94; - if (stamp[i] !== tickStamp && rnd() < 0.3 * e) { - const sx = Math.abs(ux) > 0.3 ? -Math.sign(ux) : 0, sy = Math.abs(uy) > 0.3 ? -Math.sign(uy) : 0; - for (const [mx, my] of [[sx, sy], [sx, 1], [sx, -1], [0, sy]]) { - if (!mx && !my) continue; + e *= loose; + // At most three one-cell hops per ray/tick; gravity settles the shaken grains. + if (kicks < 3 && stamp[i] !== tickStamp && !occ[i] && !part[i] && rnd() < 1.1 * e * step) { + const side = rnd() < 0.5 ? -1 : 1; + for (let hop = 0; hop < 4; hop++) { + const mx = hop < 2 ? side : -side, my = -(hop & 1); const nx = x + mx, ny = y + my; if (nx < 0 || ny < 0 || nx >= W || ny >= H) continue; const j = ny * W + nx; - if ((mat[j] === EMPTY || PH[mat[j]] === PH_GAS) && !occ[j] && !part[j]) { move(i, j, x, y, nx, ny); break; } + if (mat[j] !== EMPTY && PH[mat[j]] !== PH_GAS) continue; + if (occ[j] || part[j] || stamp[j] === tickStamp || !enter(m, ph, j, mx, my)) continue; + if (my && CORNER_SEAL && PH[mat[i + mx]] === PH_SOLID && PH[mat[i - W]] === PH_SOLID) continue; + move(i, j, x, y, nx, ny); kicks++; + if (dust < 4) { emit({ t: 'debris', x, y, m }); dust++; } + break; } } continue; } - if (builtCell(i, x, y)) { e *= 0.25; continue; } - if (p.tune && YLD[m] !== p.tune) { e *= 0.993; continue; } + if (builtCell(i, x, y)) { e *= built; continue; } + if (p.tune && YLD[m] !== p.tune) { e *= skip; continue; } const h = HARD[m]; // thin rock (a corner, a nub, a sliver with open space on two or more sides) has little // to hold it and shakes apart faster than a flat face, so ragged edges get cleaned up @@ -149,10 +159,10 @@ function pulseTick() { if (y > 0 && PH[mat[i - W]] !== PH_SOLID) open++; if (y < H - 1 && PH[mat[i + W]] !== PH_SOLID) open++; const thin = open > 1 && !THIN_BONUS_OFF ? 1 + (open - 1) * THIN_BONUS : 1; - if (h > tier.hard) { e *= 0.35; continue; } - const q = digp[i] + e * thin * tier.speed * PULSE_K / (1 + h * h * 0.6); + if (h > tier.hard) { e *= hard; continue; } + const q = digp[i] + e * (2 * step) * thin * tier.speed * PULSE_K / (1 + h * h * 0.6); if (q >= 255) { shatterCell(i, x, y, m); if (!p.tune) crumbleAround(x, y); } else { digp[i] = q; renderDirtyIdx(i); } - e *= p.tune ? 0.96 : p.damp; + e *= p.tune ? tuned : damp; } p.en[k] = e; p.s[k] = sd; } diff --git a/test/t_drill.js b/test/t_drill.js index bcfef6d..435bf07 100644 --- a/test/t_drill.js +++ b/test/t_drill.js @@ -35,6 +35,13 @@ wall2(); hold(150, 78, 2, 0, 2); const wideRows = rowsOf(); wall2(); hold(150, 78, 0, 0, 2); const narRows = rowsOf(); check('the wide cone is taller at the face than the narrow one', wideRows > narRows, `wide ${wideRows} rows, narrow ${narRows}`); +// Fixed two-second wall fixture: measured before t92, including normal rubble/gravity. +for (const [name, got, baseline] of [['narrow', nar, {d:22,n:181}], ['medium', med2, {d:13,n:186}], ['wide', wid, {d:6,n:134}]]) { + check(`${name} stone bore stays within 10% of its depth and opened area`, + Math.abs(got.d - baseline.d) <= baseline.d * 0.1 && Math.abs(got.n - baseline.n) <= baseline.n * 0.1, + `${got.d} deep / ${got.n} opened (before ${baseline.d} / ${baseline.n})`); +} + // the reach depends on the width: a narrow beam reaches furthest, a wide fan only close by run('player.bitTier = 0;'); const reaches = [0, 1, 2].map(w => run(`drillReach(${w})`)); @@ -171,6 +178,96 @@ check('a mold and what sets inside it stay safe from the drill', run(`(() => { for (const i of moldCellsAt(mo.kind, mo.x, mo.y).walls) if (crumbly(i)) return false; return true; })()`)); +// No gravity or kicks here: measure absorption through a fixed thickness, beyond normal reach +// for the 115-grain case. All real medium rays still cross the powder before reaching basalt. +function rubbleShield(thickness) { + flatWorld(run, 240, 160, 150); + return run(`(() => { + RS = 12345; tick = 0; lastPulseTick = -99; drillPulses = []; player.bitTier = 3; + bot.x = 10; bot.y = 76; + for (let y = 10; y < 145; y++) { + for (let x = 20; x < 20 + ${thickness}; x++) setCell(y*W+x, RSTONE, 20, 0); + for (let x = 20 + ${thickness}; x < 220; x++) setCell(y*W+x, BASALT, 20, F_NAT); + } + const before = stats.dug; + for (let t = 0; t < 240; t++) { + tick++; tickStamp = tickStamp % 255 + 1; stamp.fill(tickStamp); + toolPulse(219, 78, 1, 0); + if (${thickness} > 46) for (const p of drillPulses) p.range = 180; + pulseTick(); + } + return stats.dug - before; + })()`); +} +const through35 = rubbleShield(35), through115 = rubbleShield(115); +check('steel medium pulses shatter basalt behind 35 grains of rubble', through35 > 0, `${through35} basalt opened`); +check('115 grains of rubble prevent basalt breaking during sustained drilling', through115 === 0, `${through115} basalt opened`); +// 1.4 * 0.97^distance crosses 0.04 at about 117 grains; check actual extinction too. +const through118 = rubbleShield(118); +check('118 grains extinguish the ray before it can even shake basalt', through118 === 0 && !run('digp.some(d => d > 0)'), `${through118} basalt opened`); + +// Absorption over a fixed distance, isolated from gravity, kicks and cell breakage. +function transmission(material, distance, step, tune = 0) { + flatWorld(run, 240, 160, 150); + return run(`(() => { + bot.x = 0; bot.y = 0; player.bitTier = 0; stamp.fill(tickStamp); + for (let y = 70; y < 90; y++) for (let x = 10; x < 180; x++) setCell(y*W+x, ${material}, 20, F_NAT); + const p = {ox:20,oy:80.5,ang:0,w:1,jit:0.5,n:1,damp:PULSE_W[1].damp, + en:new Float32Array([1.4]),s:new Float32Array(1),r:200,range:${distance},tune:${tune}}; + drillPulses = [p]; pulseTick(${step}); return p.en[0]; + })()`); +} +for (const [m, distance, factor, tune] of [ + ['RSTONE',35,0.97,0], ['SAND',35,0.97,0], ['FEORE',35,0.97,0], ['COAL',35,0.97,0], + ['WATER',10,0.985**2,0], ['GRANITE',1,0.35**2,0], ['STONE',10,0.993**2,'CUORE'], + ['STONE',1,0.69,0], ['STONE',1,0.96**2,'RSTONE'], ['BELTL',1,0.25**2,0], +]) { + const energies = [0.25,0.5,1].map(step => transmission(m,distance,step,tune)); + const expected = 1.4 * factor ** distance; + check(`${m} attenuation counts distance at quarter, half and whole-grain steps (tune ${tune})`, + energies.every(e => Math.abs(e-expected) < 0.00001), energies.map(e=>e.toFixed(5)).join(' / ')); +} + +// A settled heap must slump further than an undrilled control, conserving all its grains. +function shakenPile(pulse) { + flatWorld(run,240,160,110); + run(`RS=12345; tick=0; lastPulseTick=-99; drillPulses=[]; player.bitTier=3; bot.x=40; bot.y=88; + for(let x=65;x<116;x++) for(let y=85+Math.abs(x-90);y<110;y++) setCell(y*W+x,RSTONE,20,0); + for(let t=0;t<240;t++) simTick();`); + const height = () => run(`(() => {let top=110;for(let i=0;i<110*W;i++) if(mat[i]===RSTONE) top=Math.min(top,(i/W)|0);return 110-top;})()`); + const before=height(), grains=count(run,run('RSTONE')); + run(`for(let t=0;t<480;t++) {${pulse?'toolPulse(90,94,1,0);':''}simTick();}`); + return {before,after:height(),grains,left:count(run,run('RSTONE'))}; +} +const restingPile=shakenPile(false), fluidPile=shakenPile(true); +check('pulses fluidise a settled rubble pile so its height drops', + fluidPile.after <= fluidPile.before-3 && fluidPile.after < restingPile.after-3, + `resting ${restingPile.before}->${restingPile.after}, shaken ${fluidPile.before}->${fluidPile.after}`); +check('shaking conserves the pile material',fluidPile.grains===fluidPile.left,`${fluidPile.grains}->${fluidPile.left}`); +check('repeating a seeded pile gives the same result',JSON.stringify(shakenPile(true))===JSON.stringify(fluidPile)); + +// One artificially long ray crosses many exposed grains in a single tick, exercising the caps. +flatWorld(run,240,160,150); +const kicks = run(`(() => { + RS=12345; bot.x=0;bot.y=0;tickStamp=1; EV.length=0; + for(let x=20;x<120;x+=2) setCell(80*W+x,RSTONE,20,0); + // Neither a covered grain nor a grain already moved this tick may be kicked. + occ[80*W+20]=1; part[80*W+22]=P_PIPE; stamp[80*W+24]=tickStamp; + // An open but owned destination and one stamped this tick are also off limits. + part[80*W+25]=P_PIPE; occ[80*W+27]=1; stamp[80*W+29]=tickStamp; + const p={ox:19.5,oy:80.5,ang:0,w:1,jit:0.5,n:8,damp:PULSE_W[1].damp, + en:new Float32Array(8).fill(1.4),s:new Float32Array(8),r:200,range:100,tune:0}; + // Zero spread gives eight overlapping rays, testing the per-tick dust cap as well. + const half=PULSE_W[1].half,mouth=PULSE_W[1].mouth; PULSE_W[1].half=0;PULSE_W[1].mouth=0; + drillPulses=[p]; pulseTick(); PULSE_W[1].half=half;PULSE_W[1].mouth=mouth; + let moved=0; for(let i=0;ie.t==='debris').length, + protected:mat[80*W+20]===RSTONE && mat[80*W+22]===RSTONE && mat[80*W+24]===RSTONE, + blocked:mat[80*W+25]===EMPTY && mat[80*W+27]===EMPTY && mat[80*W+29]===EMPTY}; +})()`); +check('kicks are bounded to three per ray and dust to four puffs per tick',kicks.moved>0 && kicks.moved<=24 && kicks.dust>0 && kicks.dust<=4,JSON.stringify(kicks)); +check('shaking respects occupied, owned and stamped cells',kicks.protected && kicks.blocked,JSON.stringify(kicks)); + // Resonance ping (t50): finds natural veins within reach of the bit, under fog too, and // nothing else. flatWorld(run, 240, 160, 150);