7c699e776d
Re-measured on A's dressed yard. The bar clears at every value tested —
67% at the landed 0.12, 84% at 0.40, 85% at 0.45 — and the twisted rig
holds 4/4 at all three. storm_02 downdraftOfTotal 0.12 -> 0.45 per
decision 11. Both physics gates now close on the same storm JSON.
My "mathematically unachievable" claim was wrong, and the algebra says
exactly why: ratio = (f / (sin p + cos p·f))^2 depends on the REFERENCE
PITCH far more than on the downdraft. My synthetic reference was pitched
16.7 deg, where the bar genuinely is unreachable (asymptote 109%, needs
f=0.86). The yard is pitched 4.8 deg — house fascia 2.60 m to posts
3.95 m over ~16 m — where 0.45 gives 72% on paper and 85% measured. The
equation was right and the rig was fiction: I was measuring against a
sail the game cannot build. The integrator's "measured beats modelled"
call was correct, and C's 0.45 was right on the geometry that ships.
The assert now derives its reference from the yard's real pitch and says
so, with the pitch table in a comment, so the next person to touch this
can see in ten seconds why the number moves.
Also re-pointed §7's twisted rig off the 145 m2 quad decision 2 retired
onto a real 23 m2 one ('t1,p1,p2,p3', most twisted in the 18-45 band).
The repair leg's dodgy carabiner moves to p2: measured peaks are t1 2.43
/ p2 2.35 / p3 0.82 / p1 0.60 kN, and it had been sitting on p1 — the
lightest corner — so it rode out the storm and the leg skipped. It now
blows and one repair finishes 4/4. Removed its stale skip guard, which
still tested the old gusts.downdraft key.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
714 lines
34 KiB
JavaScript
714 lines
34 KiB
JavaScript
/**
|
|
* sail.selftest.js — assert suite for the sail sim. [Lane B]
|
|
*
|
|
* Exports SAIL_TESTS as plain [name, fn] pairs so ONE set of asserts runs in
|
|
* two harnesses: Lane A's selftest.html (via js/tests/b.test.js) and node
|
|
* (`node web/world/js/sail.selftest.js`) for fast iteration without a browser.
|
|
* Drives time with fixed-dt loops only — never rAF, never a clock.
|
|
*
|
|
* The headline assert is `hypar sheds load vs flat`: it is the game's thesis
|
|
* stated as a test. If it ever goes red, the sail has stopped being a sail.
|
|
*/
|
|
|
|
import { SailRig } from './sail.js';
|
|
import { HARDWARE, FIXED_DT, createStubWind, rng } from './contracts.js';
|
|
import { createWindField } from './weather.core.js';
|
|
|
|
const SIM_DT = FIXED_DT;
|
|
|
|
// ---------- real storm wind (SPRINT2 B-4) ----------
|
|
// The §7 gate used to run on the local stub, which is uniform, horizontal and
|
|
// tuned by nobody. These load the storms design actually ships and drive the
|
|
// cloth with them. weather.core.js is pure and import-free, so the same code
|
|
// path works in node and in Lane A's selftest.html; only reading the JSON off
|
|
// disk differs, and weather.js's own loadStorm can't help there (its STORM_DIR
|
|
// is a file:// URL under node, which fetch won't open).
|
|
|
|
async function loadStormDef(name) {
|
|
const url = new URL(`../data/storms/${name}.json`, import.meta.url);
|
|
if (typeof process !== 'undefined' && process.versions?.node) {
|
|
const { readFile } = await import('node:fs/promises');
|
|
return JSON.parse(await readFile(url, 'utf8'));
|
|
}
|
|
return (await fetch(url)).json();
|
|
}
|
|
|
|
const STORM_02 = await loadStormDef('storm_02_wildnight');
|
|
|
|
/** A Wind over a real storm def. Same field the game flies. */
|
|
function realWind(def = STORM_02, opts = {}) {
|
|
const field = createWindField(def, opts);
|
|
const out = { x: 0, y: 0, z: 0 };
|
|
return {
|
|
sample(pos, t) { return field.vecAt(pos.x, pos.z, t, out); },
|
|
speedAt(t) { field.vecAt(0, 0, t, out); return Math.hypot(out.x, out.z); },
|
|
gustTelegraph: (t) => field.gustTelegraph?.(t) ?? null,
|
|
};
|
|
}
|
|
|
|
/** Lane A's yard, verbatim (THREADS: "yard layout is now FACT"). */
|
|
const YARD = [
|
|
['h1', 'house', -5, 2.60, -9.9], ['h2', 'house', 0, 2.60, -9.9], ['h3', 'house', 5, 2.60, -9.9],
|
|
['t1', 'tree', -9, 3.22, 2], ['t2', 'tree', 8, 3.08, -2],
|
|
['p1', 'post', -4.9, 3.95, 5.9], ['p2', 'post', 4.3, 3.96, 6.5], ['p3', 'post', 0, 3.95, 7.6],
|
|
].map(([id, type, x, y, z]) => {
|
|
const pos = { x, y, z };
|
|
// Static on purpose: tree sway is world.js's, and mixing it in here would make
|
|
// a cloth assert fail for a reason that isn't the cloth. Sway is exercised in
|
|
// the game and in a.test.
|
|
return { id, type, pos, sway: () => pos };
|
|
});
|
|
|
|
/**
|
|
* SPRINT4 decision 11: §7's twisted rig re-pointed off the old 145 m² quad onto
|
|
* a real one from A's decision-2 yard — 23 m², inside the 18-45 m² band, and the
|
|
* most twisted quad the band offers. The old one was 6x too big, which is what
|
|
* made it break under downdraft and made me call the bar unachievable.
|
|
*/
|
|
const TWISTED_QUAD = ['t1', 'p1', 'p2', 'p3'];
|
|
|
|
const yardRig = (ids, hw, tension) =>
|
|
new SailRig({ anchors: YARD, gridN: 10 })
|
|
.attach(ids, Array.isArray(hw) ? hw : Array(4).fill(hw), tension);
|
|
|
|
// ---------- deterministic stub wind ----------
|
|
// contracts.js ships createStubWind(), and the integration test below uses it.
|
|
// This local one exists only because the thesis needs the wind DIRECTION swept,
|
|
// which the shared stub does not expose. Lane C's weather.js replaces both.
|
|
|
|
function makeStubWind({ seed = 7, stormLen = 90, dir = { x: 0, y: 0, z: 1 }, calm = false } = {}) {
|
|
const rand = rng(seed);
|
|
const gusts = [];
|
|
for (let t = 3; t < stormLen; t += 5 + rand() * 7) {
|
|
gusts.push({ start: t, pow: 12 + rand() * 16 + 10 * (t / stormLen) });
|
|
}
|
|
const len = Math.hypot(dir.x, dir.y, dir.z) || 1;
|
|
const dx = dir.x / len, dy = dir.y / len, dz = dir.z / len;
|
|
const out = { x: 0, y: 0, z: 0 };
|
|
|
|
return {
|
|
speedAt(t) {
|
|
if (calm) return 0;
|
|
let speed = 8 + 26 * Math.min(1, (t / stormLen) * 1.6);
|
|
for (const g of gusts) {
|
|
const gt = t - g.start;
|
|
if (gt < 0 || gt >= 5) continue;
|
|
if (gt < 1.5) continue; // telegraph: seen, not felt
|
|
else if (gt < 2.3) speed += g.pow * (gt - 1.5) / 0.8; // ramp
|
|
else if (gt < 4.0) speed += g.pow; // hold
|
|
else speed += g.pow * (5.0 - gt); // fade
|
|
}
|
|
return speed;
|
|
},
|
|
sample(pos, t) {
|
|
const s = this.speedAt(t);
|
|
out.x = dx * s; out.y = dy * s; out.z = dz * s;
|
|
return out;
|
|
},
|
|
gustTelegraph: () => null,
|
|
};
|
|
}
|
|
|
|
const constantWind = (v) => ({ sample: () => v, speedAt: () => Math.hypot(v.x, v.y, v.z), gustTelegraph: () => null });
|
|
|
|
// ---------- test rigs ----------
|
|
// Same 5x5 m footprint, same multiset of corner heights {4.0, 4.0, 2.5, 2.5}.
|
|
// Only the ARRANGEMENT differs: coplanar (flat, pitched) vs permuted (twisted
|
|
// hypar). Any load difference is therefore purely geometry, nothing else.
|
|
|
|
const FOOT = [
|
|
{ x: -2.5, z: -2.5 }, { x: 2.5, z: -2.5 }, { x: 2.5, z: 2.5 }, { x: -2.5, z: 2.5 },
|
|
];
|
|
export const HEIGHTS_FLAT = [4.0, 4.0, 2.5, 2.5]; // y linear in z -> one plane
|
|
export const HEIGHTS_HYPAR = [4.0, 2.5, 4.0, 2.5]; // opposite corners up/down -> saddle
|
|
|
|
/**
|
|
* Anchors shaped like contracts.js Anchor: sway(t) is the ABSOLUTE position.
|
|
* `theta` spins the footprint about the yard's Y axis — which is how you sweep
|
|
* wind direction against a real storm, whose direction curve you don't get to
|
|
* choose. Rotating the rig under the wind and rotating the wind over the rig are
|
|
* the same experiment; only one of them is available with authored storm JSON.
|
|
*/
|
|
export const makeAnchors = (heights, theta = 0) =>
|
|
FOOT.map((f, i) => {
|
|
const c = Math.cos(theta), s = Math.sin(theta);
|
|
const pos = { x: f.x * c - f.z * s, y: heights[i], z: f.x * s + f.z * c };
|
|
return { id: `a${i}`, type: 'post', pos, sway: () => pos };
|
|
});
|
|
|
|
const ALL_IDS = ['a0', 'a1', 'a2', 'a3'];
|
|
const UNBREAKABLE = { name: 'test rig', cost: 0, rating: Infinity };
|
|
|
|
function rig(heights, { hw = UNBREAKABLE, tension = 1.0, porosity = 0 } = {}) {
|
|
return new SailRig({ anchors: makeAnchors(heights), gridN: 10, porosity })
|
|
.attach(ALL_IDS, [hw, hw, hw, hw], tension);
|
|
}
|
|
|
|
/** Fixed-dt fast-forward. Returns the peak corner load over the whole run, N. */
|
|
function runStorm(r, wind, secs, onStep) {
|
|
const steps = Math.round(secs / SIM_DT);
|
|
let peak = 0;
|
|
for (let i = 0; i < steps; i++) {
|
|
r.step(SIM_DT, wind, i * SIM_DT);
|
|
const m = r.maxLoad();
|
|
if (m > peak) peak = m;
|
|
if (onStep) onStep(r, i);
|
|
}
|
|
return peak;
|
|
}
|
|
|
|
const TESTS = [];
|
|
const test = (name, fn) => TESTS.push([name, fn]);
|
|
const assert = (cond, msg) => { if (!cond) throw new Error(msg); };
|
|
const kN = (n) => `${(n / 1000).toFixed(2)} kN`;
|
|
|
|
// ---------- the suite ----------
|
|
|
|
test('sim stays finite through a full storm', () => {
|
|
const r = rig(HEIGHTS_HYPAR);
|
|
runStorm(r, makeStubWind({ stormLen: 90 }), 90);
|
|
for (const v of r.pos) assert(Number.isFinite(v), 'node position went NaN/Infinity');
|
|
for (const c of r.corners) assert(Number.isFinite(c.load), 'corner load went NaN');
|
|
return `peak ${kN(r.corners.reduce((m, c) => Math.max(m, c.peakLoad), 0))}`;
|
|
});
|
|
|
|
test('sail sags under gravity when calm', () => {
|
|
const r = rig(HEIGHTS_FLAT);
|
|
runStorm(r, makeStubWind({ calm: true }), 6);
|
|
const N = r.N, mid = (Math.floor(N / 2) * N + Math.floor(N / 2)) * 3;
|
|
const midY = r.pos[mid + 1];
|
|
const cornerMeanY = HEIGHTS_FLAT.reduce((a, b) => a + b) / 4;
|
|
assert(midY < cornerMeanY, `belly (${midY.toFixed(2)}m) should hang below corner mean (${cornerMeanY}m)`);
|
|
return `belly sags ${(cornerMeanY - midY).toFixed(2)} m below corner plane`;
|
|
});
|
|
|
|
// Newton's third law. This is what pins FABRIC_K to real newtons: if the corner
|
|
// reactions don't sum to the actual aerodynamic + weight force on the fabric,
|
|
// the load meter is lying and every kN rating on it is meaningless.
|
|
test('statics: corner reactions balance the applied force', () => {
|
|
const w = constantWind({ x: 0, y: 0, z: 18 });
|
|
const r = rig(HEIGHTS_FLAT);
|
|
runStorm(r, w, 12); // settle
|
|
// A membrane in steady wind never fully stops moving, so compare the
|
|
// TIME-AVERAGED reaction against the time-averaged applied force. That is the
|
|
// momentum balance that must hold; instant by instant it need not.
|
|
let n = 0, ax = 0, ay = 0, az = 0, rx = 0, ry = 0, rz = 0;
|
|
for (let i = 0; i < Math.round(4 / SIM_DT); i++) {
|
|
const t = 12 + i * SIM_DT;
|
|
r.step(SIM_DT, w, t);
|
|
const f = r.netAppliedForce(w, t);
|
|
ax += f.x; ay += f.y; az += f.z;
|
|
for (const c of r.corners) { rx += c.loadVec.x; ry += c.loadVec.y; rz += c.loadVec.z; }
|
|
n++;
|
|
}
|
|
ax /= n; ay /= n; az /= n; rx /= n; ry /= n; rz /= n;
|
|
const appliedMag = Math.hypot(ax, ay, az);
|
|
const err = Math.hypot(rx - ax, ry - ay, rz - az) / appliedMag;
|
|
assert(err < 0.2, `reactions ${kN(Math.hypot(rx, ry, rz))} vs applied ${kN(appliedMag)} — ${(err * 100).toFixed(0)}% out of balance`);
|
|
return `applied ${kN(appliedMag)}, reactions ${kN(Math.hypot(rx, ry, rz))}, residual ${(err * 100).toFixed(1)}%`;
|
|
});
|
|
|
|
// THE THESIS. A twisted sail resists bellying into one coherent pocket, so its
|
|
// worst moment is gentler than a flat sail's worst moment.
|
|
//
|
|
// Scored on WORST CASE over wind direction, not per-direction. Lane C's storms
|
|
// veer, so the player never gets to choose the wind, and worst-case is what the
|
|
// hardware actually has to survive. Per-direction would be a false assert: a
|
|
// flat sail sitting edge-on to the wind genuinely does have low drag, and from
|
|
// that one angle it beats the hypar. Demanding otherwise would mean tuning the
|
|
// sim into a lie.
|
|
test('hypar sheds load vs flat, worst case over wind direction (the thesis)', () => {
|
|
const DIRS = [
|
|
{ name: 'N', x: 0, z: 1 }, { name: 'NE', x: 0.707, z: 0.707 },
|
|
{ name: 'E', x: 1, z: 0 }, { name: 'SE', x: 0.707, z: -0.707 },
|
|
{ name: 'S', x: 0, z: -1 }, { name: 'SW', x: -0.707, z: -0.707 },
|
|
{ name: 'W', x: -1, z: 0 }, { name: 'NW', x: -0.707, z: 0.707 },
|
|
];
|
|
const sweep = (heights) => {
|
|
let worst = 0, at = '';
|
|
for (const d of DIRS) {
|
|
const storm = makeStubWind({ seed: 7, stormLen: 45, dir: { x: d.x, y: 0, z: d.z } });
|
|
const p = runStorm(rig(heights), storm, 45);
|
|
if (p > worst) { worst = p; at = d.name; }
|
|
}
|
|
return { worst, at };
|
|
};
|
|
const flat = sweep(HEIGHTS_FLAT);
|
|
const hypar = sweep(HEIGHTS_HYPAR);
|
|
assert(
|
|
hypar.worst < flat.worst * 0.8,
|
|
`hypar worst ${kN(hypar.worst)} (${hypar.at}) should be well under flat worst ${kN(flat.worst)} (${flat.at})`
|
|
);
|
|
return `flat worst ${kN(flat.worst)} from ${flat.at} -> hypar worst ${kN(hypar.worst)} from ${hypar.at} (sheds ${((1 - hypar.worst / flat.worst) * 100).toFixed(0)}%)`;
|
|
});
|
|
|
|
test('cascade: losing a corner spikes its neighbours', () => {
|
|
const w = constantWind({ x: 0, y: 0, z: 22 });
|
|
const r = rig(HEIGHTS_HYPAR);
|
|
runStorm(r, w, 6); // settle
|
|
const before = Math.max(r.corners[1].load, r.corners[3].load);
|
|
r.corners[0].broken = true;
|
|
r._repin(r.t);
|
|
runStorm(r, w, 2.5); // let the load redistribute
|
|
const after = Math.max(r.corners[1].load, r.corners[3].load);
|
|
assert(after >= before * 2, `neighbour went ${kN(before)} -> ${kN(after)}, wanted >= 2x`);
|
|
return `neighbour ${kN(before)} -> ${kN(after)} (${(after / before).toFixed(1)}x)`;
|
|
});
|
|
|
|
test('determinism: identical inputs give byte-equal load traces', () => {
|
|
const trace = () => {
|
|
const r = rig(HEIGHTS_HYPAR);
|
|
const w = makeStubWind({ seed: 3, stormLen: 30 });
|
|
const out = [];
|
|
runStorm(r, w, 30, (rr) => { for (const c of rr.corners) out.push(c.load); });
|
|
return out;
|
|
};
|
|
const a = trace(), b = trace();
|
|
assert(a.length === b.length, 'traces differ in length');
|
|
for (let i = 0; i < a.length; i++) assert(a[i] === b[i], `sample ${i} diverged: ${a[i]} vs ${b[i]}`);
|
|
return `${a.length} load samples identical`;
|
|
});
|
|
|
|
test('determinism: variable frame dt matches fixed dt', () => {
|
|
// Lane A's render loop delivers ragged dt. The internal accumulator has to
|
|
// absorb that, or nothing the selftest proves applies to the real game.
|
|
const w1 = makeStubWind({ seed: 5, stormLen: 20 });
|
|
const fixed = rig(HEIGHTS_HYPAR);
|
|
for (let i = 0; i < Math.round(20 / SIM_DT); i++) fixed.step(SIM_DT, w1, i * SIM_DT);
|
|
|
|
const w2 = makeStubWind({ seed: 5, stormLen: 20 });
|
|
const ragged = rig(HEIGHTS_HYPAR);
|
|
const rand = rng(99);
|
|
let acc = 0;
|
|
while (acc < 20) {
|
|
const dt = 0.004 + rand() * 0.02; // 4-24 ms frames
|
|
ragged.step(dt, w2, acc);
|
|
acc += dt;
|
|
}
|
|
for (let k = 0; k < 4; k++) {
|
|
const d = Math.abs(fixed.corners[k].load - ragged.corners[k].load);
|
|
assert(d < 1e-6, `corner ${k} drifted ${d.toFixed(6)} N between fixed and ragged dt`);
|
|
}
|
|
return 'ragged frame times converge on the fixed-dt trace';
|
|
});
|
|
|
|
test('tension dial changes load (drum tight shock-loads)', () => {
|
|
const w = constantWind({ x: 0, y: 0, z: 20 });
|
|
const loosePeak = runStorm(rig(HEIGHTS_HYPAR, { tension: 0.7 }), w, 8);
|
|
const tightPeak = runStorm(rig(HEIGHTS_HYPAR, { tension: 1.35 }), w, 8);
|
|
assert(tightPeak > loosePeak, `tight ${kN(tightPeak)} should exceed loose ${kN(loosePeak)}`);
|
|
return `loose ${kN(loosePeak)} vs tight ${kN(tightPeak)}`;
|
|
});
|
|
|
|
test('porous shade cloth carries less load than solid membrane', () => {
|
|
const w = constantWind({ x: 0, y: 0, z: 20 });
|
|
const solid = runStorm(rig(HEIGHTS_HYPAR, { porosity: 0 }), w, 8);
|
|
const porous = runStorm(rig(HEIGHTS_HYPAR, { porosity: 0.35 }), w, 8);
|
|
assert(porous < solid, `porous ${kN(porous)} should be under solid ${kN(solid)}`);
|
|
return `solid ${kN(solid)} vs porous ${kN(porous)}`;
|
|
});
|
|
|
|
test('coverage: sail shades the ground under it, not beside it', () => {
|
|
const r = rig(HEIGHTS_FLAT);
|
|
runStorm(r, makeStubWind({ calm: true }), 4);
|
|
// world.gardenBed rects are CENTRE + size, so this bed straddles the origin.
|
|
const under = r.coverageOver({ x: 0, z: 0, w: 4, d: 4 });
|
|
const beside = r.coverageOver({ x: 14, z: 14, w: 4, d: 4 });
|
|
assert(under > 0.9, `ground under the sail only ${(under * 100).toFixed(0)}% shaded`);
|
|
assert(beside === 0, `ground 14 m away reported ${(beside * 100).toFixed(0)}% shaded`);
|
|
return `under sail ${(under * 100).toFixed(0)}%, off to the side ${(beside * 100).toFixed(0)}%`;
|
|
});
|
|
|
|
test('coverage tracks a low sun off to the side', () => {
|
|
const r = rig(HEIGHTS_FLAT);
|
|
runStorm(r, makeStubWind({ calm: true }), 4);
|
|
const noon = r.coverageOver({ x: 0, z: 0, w: 4, d: 4 }, { x: 0, y: 1, z: 0 });
|
|
const lowSun = r.coverageOver({ x: 0, z: 0, w: 4, d: 4 }, { x: 0.9, y: 0.25, z: 0 });
|
|
assert(noon > lowSun, `shadow should slide off the bed as the sun drops (noon ${noon}, low ${lowSun})`);
|
|
return `noon ${(noon * 100).toFixed(0)}% -> low sun ${(lowSun * 100).toFixed(0)}%`;
|
|
});
|
|
|
|
// PLAN3D §7 definition of done, in miniature.
|
|
test('cheap flat rig cascades; twisted mixed rig survives', () => {
|
|
const storm = () => makeStubWind({ seed: 11, stormLen: 90 });
|
|
const cheap = rig(HEIGHTS_FLAT, { hw: HARDWARE[0], tension: 1.35 });
|
|
runStorm(cheap, storm(), 90);
|
|
const cheapBroken = cheap.corners.filter((c) => c.broken).length;
|
|
|
|
const good = rig(HEIGHTS_HYPAR, { hw: HARDWARE[2], tension: 0.95 });
|
|
runStorm(good, storm(), 90);
|
|
const goodBroken = good.corners.filter((c) => c.broken).length;
|
|
|
|
assert(cheapBroken >= 2, `flat drum-tight carabiner rig only lost ${cheapBroken} corners — should cascade`);
|
|
assert(goodBroken === 0, `twisted rated-shackle rig lost ${goodBroken} corners — should survive`);
|
|
return `cheap flat lost ${cheapBroken}/4, good hypar lost ${goodBroken}/4`;
|
|
});
|
|
|
|
// PLAN3D §5-B: "broken corner frees the node -> flogging is emergent". This
|
|
// drives a REAL overload failure rather than setting broken by hand, because
|
|
// hand-setting it was exactly what hid the bug where _checkFailure marked a
|
|
// corner broken but never gave its node its mass back — so a blown corner
|
|
// stayed welded in mid-air and the sail never flogged.
|
|
test('a blown corner is freed and flies (flogging is emergent)', () => {
|
|
const w = makeStubWind({ seed: 11, stormLen: 90 });
|
|
const r = rig(HEIGHTS_FLAT, { hw: HARDWARE[0], tension: 1.3 }); // cheap and tight: this one lets go
|
|
const broke = [];
|
|
r.events.on('break', (e) => broke.push(e));
|
|
|
|
// step until the first corner lets go
|
|
let i = 0;
|
|
for (const end = Math.round(90 / SIM_DT); i < end && !broke.length; i++) r.step(SIM_DT, w, i * SIM_DT);
|
|
assert(broke.length > 0, 'a carabiner rig should have blown a corner somewhere in a 90 s storm');
|
|
|
|
const k = r.corners.indexOf(broke[0].corner);
|
|
const node = r.cornerIdx[k], ci = node * 3;
|
|
const anchor = r.corners[k].anchor.pos;
|
|
const before = [r.pos[ci], r.pos[ci + 1], r.pos[ci + 2]];
|
|
for (let j = 0; j < Math.round(3 / SIM_DT); j++) r.step(SIM_DT, w, (i + j) * SIM_DT);
|
|
|
|
const moved = Math.hypot(r.pos[ci] - before[0], r.pos[ci + 1] - before[1], r.pos[ci + 2] - before[2]);
|
|
const fromAnchor = Math.hypot(r.pos[ci] - anchor.x, r.pos[ci + 1] - anchor.y, r.pos[ci + 2] - anchor.z);
|
|
|
|
assert(r.invMass[node] > 0, 'blown corner still has infinite mass — it is welded in mid-air, not flogging');
|
|
assert(moved > 0.05, `blown corner only drifted ${moved.toFixed(3)} m in 3 s — it is not flogging`);
|
|
assert(fromAnchor > 0.2, `blown corner is still ${fromAnchor.toFixed(2)} m from its anchor — it never let go`);
|
|
return `corner ${broke[0].anchorId} blew at t=${broke[0].t.toFixed(1)}s, tore ${fromAnchor.toFixed(2)} m off its anchor and is flying`;
|
|
});
|
|
|
|
test('break and repair emit on the events Emitter', () => {
|
|
const w = constantWind({ x: 0, y: 0, z: 20 });
|
|
const r = rig(HEIGHTS_HYPAR, { hw: UNBREAKABLE });
|
|
const seen = [];
|
|
r.events.on('break', (e) => seen.push(e));
|
|
r.events.on('repair', (e) => seen.push(e));
|
|
|
|
runStorm(r, w, 4);
|
|
r.corners[0].broken = true;
|
|
r._repin(r.t);
|
|
runStorm(r, w, 1);
|
|
assert(r.corners[0].load === 0, 'broken corner should carry no load');
|
|
|
|
assert(r.repairCorner(0, UNBREAKABLE), 'repairCorner should report success');
|
|
runStorm(r, w, 3);
|
|
assert(r.corners[0].load > 100, `repaired corner only pulling ${kN(r.corners[0].load)}`);
|
|
assert(seen.some((e) => e.type === 'repair' && e.corner === r.corners[0]), 'no repair event with {type, corner}');
|
|
return `repaired corner back to ${kN(r.corners[0].load)}, ${seen.length} event(s) emitted`;
|
|
});
|
|
|
|
// --- SPRINT2 decision 4: the seam Lane D already calls ---------------------
|
|
|
|
test('decision 4: repair(i) re-rigs a blown corner with the spare', () => {
|
|
const w = constantWind({ x: 0, y: 0, z: 20 });
|
|
const r = rig(HEIGHTS_HYPAR, { hw: HARDWARE[0] });
|
|
runStorm(r, w, 4);
|
|
r.corners[0].broken = true;
|
|
r._repin(r.t);
|
|
|
|
// exactly Lane D's interact.js call: no hardware argument, return ignored
|
|
r.repair(0);
|
|
assert(!r.corners[0].broken, 'repair(0) should have re-rigged the corner');
|
|
assert(r.corners[0].hw === HARDWARE[1], `spare should re-rig at shackle grade, got ${r.corners[0].hw.name}`);
|
|
assert(r.invMass[r.cornerIdx[0]] === 0, 'repaired corner should be pinned again');
|
|
runStorm(r, w, 3);
|
|
assert(r.corners[0].load > 100, `repaired corner only pulling ${kN(r.corners[0].load)}`);
|
|
return `repair(0) -> ${r.corners[0].hw.name}, back to ${kN(r.corners[0].load)}`;
|
|
});
|
|
|
|
test('decision 4: repair(i) on an intact corner is a no-op', () => {
|
|
const r = rig(HEIGHTS_HYPAR, { hw: HARDWARE[2] });
|
|
runStorm(r, constantWind({ x: 0, y: 0, z: 12 }), 2);
|
|
const hw = r.corners[1].hw;
|
|
r.repair(1); // D gates on corner.broken, but the rig must not trust that
|
|
assert(r.corners[1].hw === hw, 'repairing an intact corner downgraded its hardware');
|
|
return 'intact corner untouched';
|
|
});
|
|
|
|
test('decision 4: trim(i, delta) tightens one corner only', () => {
|
|
const r = rig(HEIGHTS_HYPAR);
|
|
r.trim(0, +0.1);
|
|
assert(Math.abs(r.corners[0].trim - 1.1) < 1e-9, `corner 0 trim ${r.corners[0].trim}`);
|
|
assert(r.corners[1].trim === 1.0, 'trim leaked onto a neighbour');
|
|
for (let i = 0; i < 40; i++) r.trim(0, +0.1); // Lane D can hold the key down
|
|
assert(r.corners[0].trim <= 1.15 + 1e-9, `trim ran past its clamp: ${r.corners[0].trim}`);
|
|
return `trim clamps at ${r.corners[0].trim.toFixed(2)}, neighbours unmoved`;
|
|
});
|
|
|
|
test('decision 4: cornerPos(i) is live, fresh, and chases a flogging corner', () => {
|
|
const w = makeStubWind({ seed: 11, stormLen: 90 });
|
|
const r = rig(HEIGHTS_FLAT, { hw: HARDWARE[0], tension: 1.3 });
|
|
const anchor = r.corners[0].anchor.pos;
|
|
const p0 = r.cornerPos(0);
|
|
assert(Math.hypot(p0.x - anchor.x, p0.y - anchor.y, p0.z - anchor.z) < 1e-6,
|
|
'an intact corner should report its anchor position');
|
|
assert(r.cornerPos(0) !== r.cornerPos(0), 'cornerPos must return a FRESH vector, not shared scratch');
|
|
|
|
// blow it, then confirm the prompt would follow the flying corner
|
|
r.corners[0].broken = true;
|
|
r._repin(r.t);
|
|
runStorm(r, w, 6);
|
|
const p1 = r.cornerPos(0);
|
|
const drift = Math.hypot(p1.x - anchor.x, p1.y - anchor.y, p1.z - anchor.z);
|
|
assert(drift > 0.3, `blown corner's prompt only moved ${drift.toFixed(2)} m off the anchor`);
|
|
assert(new SailRig({ anchors: makeAnchors(HEIGHTS_FLAT) }).cornerPos(0) === null,
|
|
'cornerPos on an unrigged rig should be null, not a throw');
|
|
return `prompt tracks the blown corner ${drift.toFixed(2)} m off its anchor`;
|
|
});
|
|
|
|
// --- SPRINT2 decision 5: debris -------------------------------------------
|
|
|
|
const crate = (over) => ({ x: 0, y: 3.25, z: 0, vx: 0, vy: 0, vz: 14, r: 0.3, mass: 9, alive: true, ...over });
|
|
|
|
test('decision 5: a crate hitting the sail conserves momentum', () => {
|
|
const r = rig(HEIGHTS_FLAT);
|
|
runStorm(r, makeStubWind({ calm: true }), 4); // settle, so the cloth isn't ringing
|
|
// aimed at the belly, not a corner: a pinned corner would (correctly) dump
|
|
// momentum into the house and there'd be nothing to conserve
|
|
const mid = r.N * Math.floor(r.N / 2) + Math.floor(r.N / 2);
|
|
const p = crate({ x: r.pos[mid * 3], y: r.pos[mid * 3 + 1] - 0.25, z: r.pos[mid * 3 + 2], vy: 6, vz: 0 });
|
|
|
|
const clothP = () => {
|
|
let x = 0, y = 0, z = 0;
|
|
for (let n = 0; n < r.invMass.length; n++) {
|
|
if (r.invMass[n] === 0) continue; // pinned: its momentum belongs to the house
|
|
const i = n * 3;
|
|
x += (r.pos[i] - r.prev[i]) / SIM_DT * r.nodeMass;
|
|
y += (r.pos[i + 1] - r.prev[i + 1]) / SIM_DT * r.nodeMass;
|
|
z += (r.pos[i + 2] - r.prev[i + 2]) / SIM_DT * r.nodeMass;
|
|
}
|
|
return { x, y, z };
|
|
};
|
|
const total = () => {
|
|
const c = clothP();
|
|
return { x: c.x + p.vx * p.mass, y: c.y + p.vy * p.mass, z: c.z + p.vz * p.mass };
|
|
};
|
|
|
|
const before = total();
|
|
r._applyDebris([p], SIM_DT);
|
|
const after = total();
|
|
|
|
const drift = Math.hypot(after.x - before.x, after.y - before.y, after.z - before.z);
|
|
const scale = Math.hypot(before.x, before.y, before.z);
|
|
assert(scale > 1, 'test crate carries no momentum to conserve');
|
|
assert(drift / scale < 0.01, `momentum drifted ${drift.toFixed(3)} of ${scale.toFixed(1)} kg·m/s (${(drift / scale * 100).toFixed(1)}%)`);
|
|
assert(p.vy < 6, `the crate should have LOST speed to the cloth, still at ${p.vy.toFixed(2)} m/s`);
|
|
return `crate ${scale.toFixed(0)} kg·m/s, exchange conserves to ${(drift / scale * 100).toFixed(3)}%`;
|
|
});
|
|
|
|
test('decision 5: a crate through the sail shoves the cloth and emits', () => {
|
|
const r = rig(HEIGHTS_FLAT);
|
|
runStorm(r, makeStubWind({ calm: true }), 4);
|
|
const hits = [];
|
|
r.events.on('debrisHit', (e) => hits.push(e));
|
|
|
|
const mid = r.N * Math.floor(r.N / 2) + Math.floor(r.N / 2);
|
|
const before = r.pos[mid * 3 + 1];
|
|
const p = crate({ x: r.pos[mid * 3], y: r.pos[mid * 3 + 1] - 0.6, z: r.pos[mid * 3 + 2], vy: 12, vz: 0 });
|
|
const v0 = p.vy;
|
|
|
|
// Peak, not final: the crate crosses the cloth in about three frames and the
|
|
// membrane springs back well inside the run, so sampling the end measures the
|
|
// recovery rather than the punch.
|
|
const wind = makeStubWind({ calm: true });
|
|
let peak = before;
|
|
for (let i = 0; i < 30; i++) {
|
|
r.step(SIM_DT, wind, i * SIM_DT, { pieces: [p] });
|
|
p.y += p.vy * SIM_DT; p.z += p.vz * SIM_DT;
|
|
peak = Math.max(peak, r.pos[mid * 3 + 1]);
|
|
}
|
|
assert(hits.length > 0, 'crate passed through the cloth without a single contact');
|
|
assert(peak > before + 0.05, `belly only lifted ${(peak - before).toFixed(3)} m — the crate went straight through`);
|
|
assert(p.vy < v0, `crate left at ${p.vy.toFixed(2)} m/s, never paid for the punch (entered at ${v0})`);
|
|
return `${hits.length} contacts, belly punched ${(peak - before).toFixed(2)} m, crate ${v0} -> ${p.vy.toFixed(1)} m/s`;
|
|
});
|
|
|
|
test('decision 5: no debris and empty debris are both fine', () => {
|
|
const w = makeStubWind({ seed: 2, stormLen: 20 });
|
|
const a = rig(HEIGHTS_HYPAR), b = rig(HEIGHTS_HYPAR);
|
|
for (let i = 0; i < 600; i++) {
|
|
a.step(SIM_DT, w, i * SIM_DT); // Lane A's 3-arg call still works
|
|
b.step(SIM_DT, makeStubWind({ seed: 2, stormLen: 20 }), i * SIM_DT, { pieces: [] });
|
|
}
|
|
for (let k = 0; k < 4; k++) {
|
|
assert(Math.abs(a.corners[k].load - b.corners[k].load) < 1e-9,
|
|
'an empty debris list changed the sim');
|
|
}
|
|
return 'empty and absent debris both no-op';
|
|
});
|
|
|
|
// --- SPRINT2 B-4: the §7 gate, against the wind the game actually flies ------
|
|
|
|
// PLAN3D §7: "A flat drum-tight cheap rig MUST cascade-fail in storm_02; a
|
|
// well-twisted mixed rig with one mid-storm repair MUST be survivable." The old
|
|
// version of this proved it against my own stub wind, which is uniform,
|
|
// horizontal and tuned by nobody — so it proved the cloth was self-consistent,
|
|
// not that the game works. This is the real storm JSON, the real yard, and the
|
|
// same two rig shapes Lane C measured decision 3 against.
|
|
test('§7 gate on REAL storm_02: cheap flat rig cascades', () => {
|
|
const rig = yardRig(['h1', 'h3', 'p2', 'p1'], HARDWARE[0], 1.3); // drum-tight carabiners
|
|
const broke = [];
|
|
rig.events.on('break', (e) => broke.push(e));
|
|
const w = realWind();
|
|
for (let i = 0; i < Math.round(STORM_02.duration / SIM_DT); i++) rig.step(SIM_DT, w, i * SIM_DT);
|
|
const lost = rig.corners.filter((c) => c.broken).length;
|
|
assert(lost >= 2, `flat drum-tight carabiner rig only lost ${lost}/4 in the real storm_02 — no cascade`);
|
|
return `lost ${lost}/4, first at t=${broke[0].t.toFixed(1)}s (${broke[0].anchorId}, ${broke[0].hw})`;
|
|
});
|
|
|
|
test('§7 gate on REAL storm_02: twisted mixed rig survives', () => {
|
|
// Lane C's shape: h1 (house, 2.6) / t2 (tree, 3.1) / p1 (post, 3.9) / t1 (tree, 3.2)
|
|
// — corners at four different heights, i.e. an actual hypar, eased off tight.
|
|
const rig = yardRig(TWISTED_QUAD, [HARDWARE[2], HARDWARE[1], HARDWARE[2], HARDWARE[1]], 0.85);
|
|
const w = realWind();
|
|
let peak = 0;
|
|
for (let i = 0; i < Math.round(STORM_02.duration / SIM_DT); i++) {
|
|
rig.step(SIM_DT, w, i * SIM_DT);
|
|
peak = Math.max(peak, rig.maxLoad());
|
|
}
|
|
const lost = rig.corners.filter((c) => c.broken).length;
|
|
assert(lost === 0, `well-twisted mixed rig lost ${lost}/4 in storm_02 — §7 says it must be survivable`);
|
|
return `all 4 corners held, peak ${kN(peak)} (area ${rig.area.toFixed(0)} m2)`;
|
|
});
|
|
|
|
test('§7 gate on REAL storm_02: twisted rig + one repair on the dodgy corner', () => {
|
|
// The other half of §7: "a well-twisted mixed rig with ONE mid-storm repair
|
|
// MUST be survivable". The twisted rig above already survives outright, so
|
|
// the interesting scenario is DESIGN.md's: the budget forces one dodgy corner
|
|
// ($80 buys rated on at most two of four), that corner blows, and you run out
|
|
// and re-rig it once with the carried spare — exactly Lane D's hold-E.
|
|
// An $80-exact loadout on the decision-11 quad: rated t1 ($30) + shackle p1
|
|
// ($15) + carabiner p2 ($5) + shackle p3 ($15) + spare ($15).
|
|
//
|
|
// The carabiner goes on p2 because that is where the load actually IS —
|
|
// measured peaks on this quad are t1 2.43 / p2 2.35 / p3 0.82 / p1 0.60 kN.
|
|
// Hanging the cheap corner on p1 (the lightest) is what a player does by
|
|
// accident: it rides the whole storm out and proves nothing. p2 is the real
|
|
// bet, and it's the one that has to blow for this test to mean anything.
|
|
const rig = yardRig(
|
|
TWISTED_QUAD, // ['t1','p1','p2','p3']
|
|
[HARDWARE[2], HARDWARE[1], HARDWARE[0], HARDWARE[1]],
|
|
0.85,
|
|
);
|
|
const w = realWind();
|
|
let repairs = 0;
|
|
rig.events.on('break', () => { /* seen below; repairing inside the emit would reenter step */ });
|
|
for (let i = 0; i < Math.round(STORM_02.duration / SIM_DT); i++) {
|
|
rig.step(SIM_DT, w, i * SIM_DT);
|
|
if (repairs === 0) {
|
|
const k = rig.corners.findIndex((c) => c.broken);
|
|
if (k >= 0) { rig.repair(k); repairs++; }
|
|
}
|
|
}
|
|
const lost = rig.corners.filter((c) => c.broken).length;
|
|
if (repairs === 0) {
|
|
// A vacuous pass is worse than a skip: "nothing broke" would let this go
|
|
// green forever while proving nothing. Storm_02 can't threaten a shackle
|
|
// rig until Lane C's downdraft lands (their A/B: shackle blows at t=20.8 s
|
|
// with downdraft 0.3, never without). Lights up by itself on merge.
|
|
// Decision 11 landed the downdraft for real, so there is no longer an excuse
|
|
// for nothing breaking: a vacuous pass here would mean the §7 repair leg —
|
|
// the sprint's whole definition of done — is checking nothing.
|
|
assert(false, 'nothing blew, so the repair scenario proved nothing — the dodgy corner is not on a loaded corner');
|
|
}
|
|
assert(lost <= 1, `after one repair the rig still lost ${lost}/4 — not survivable`);
|
|
return `${repairs} repair, finished ${4 - lost}/4 corners intact`;
|
|
});
|
|
|
|
// --- SPRINT2 decision 3 / B-6: the flat-horizontal loophole ------------------
|
|
|
|
// Sprint 1 finding: a flat HORIZONTAL sail was the lowest-load rig of all,
|
|
// because a horizontal plate in horizontal wind has almost no drag — which
|
|
// inverted DESIGN.md's "big, flat, low = death in a storm". Lane C closed it by
|
|
// making the wind descend (decision 8: a fraction of TOTAL speed, present
|
|
// whenever it's windy).
|
|
//
|
|
// THE REFERENCE RIG IS THE WHOLE TEST, and getting it wrong is what made me
|
|
// declare this bar unachievable for two sprints (SPRINT3 [B], and I was wrong).
|
|
// The ratio is `(f / (sin p + cos p·f))²` for reference pitch p, so it depends
|
|
// on p far more than on the downdraft:
|
|
//
|
|
// pitch f=0.12 f=0.45 the bar is 60%
|
|
// 16.7° 8.9% 39.2% <- my old synthetic rig: unreachable,
|
|
// asymptote 109%, would need f=0.86
|
|
// 4.8° 34.9% 71.5% <- the yard: clears comfortably
|
|
//
|
|
// A steeply-pitched reference catches the downdraft nearly as well as a
|
|
// horizontal one does (its normal is still 96% vertical), so it can never be
|
|
// out-loaded. The yard cannot BUILD a 16.7° sail: house fascia is 2.60 m and
|
|
// the posts are 3.95 m, ~16 m apart — 4.8°. Measuring against a rig the game
|
|
// can't rig proved something true about nothing.
|
|
const YARD_PITCH_DEG = 4.8; // house 2.60 -> post 3.95 over ~16 m, from world.js
|
|
test('decision 3: flat-horizontal is no longer a free lunch', () => {
|
|
const f = STORM_02.gusts?.downdraftOfTotal ?? STORM_02.gusts?.downdraft ?? 0;
|
|
assert(f > 0, 'storm_02 has no downdraft at all — decision 3/8 has regressed out of the data');
|
|
|
|
// Footprint sized and pitched like a real quad from the dressed yard, spun
|
|
// through 8 headings under the real storm. (Re-seeding the wind instead only
|
|
// reshuffles gust TIMING — the direction curve is authored — so it would look
|
|
// like a sweep and measure nothing about direction.)
|
|
const S = Math.sqrt(30); // ~30 m², mid of A's 18-45 band
|
|
const rise = Math.tan((YARD_PITCH_DEG * Math.PI) / 180) * S;
|
|
const PITCHED = [3.2 + rise / 2, 3.2 + rise / 2, 3.2 - rise / 2, 3.2 - rise / 2];
|
|
const HORIZ = [3.2, 3.2, 3.2, 3.2];
|
|
|
|
const foot = [[-S / 2, -S / 2], [S / 2, -S / 2], [S / 2, S / 2], [-S / 2, S / 2]];
|
|
const at = (hs, th) => foot.map(([x, z], i) => {
|
|
const c = Math.cos(th), s = Math.sin(th);
|
|
const pos = { x: x * c - z * s, y: hs[i], z: x * s + z * c };
|
|
return { id: `a${i}`, type: 'post', pos, sway: () => pos };
|
|
});
|
|
const sweep = (hs) => {
|
|
let worst = 0;
|
|
for (let k = 0; k < 8; k++) {
|
|
const r = new SailRig({ anchors: at(hs, (k / 8) * Math.PI * 2), gridN: 10 })
|
|
.attach(ALL_IDS, Array(4).fill(UNBREAKABLE), 1.0);
|
|
// full duration: storm_02's own note says the peak lands just AFTER the
|
|
// southerly change, so a short sweep measures the wrong half of the storm
|
|
worst = Math.max(worst, runStorm(r, realWind(), STORM_02.duration));
|
|
}
|
|
return worst;
|
|
};
|
|
|
|
const pitched = sweep(PITCHED);
|
|
const horizontal = sweep(HORIZ);
|
|
const ratio = horizontal / pitched;
|
|
assert(ratio >= 0.6, `flat-horizontal peaks at only ${(ratio * 100).toFixed(0)}% of flat-pitched (${kN(horizontal)} vs ${kN(pitched)}) — still a free lunch`);
|
|
return `flat-horizontal ${kN(horizontal)} vs flat-pitched ${kN(pitched)} = ${(ratio * 100).toFixed(0)}% at ${YARD_PITCH_DEG}° yard pitch, downdraftOfTotal ${f}`;
|
|
});
|
|
|
|
test('runs against the shared contracts.js stub wind', () => {
|
|
// Proves the rig eats the sanctioned Wind implementation, not just my local
|
|
// stub — so nothing surprises us when Lane C's weather.js drops in.
|
|
const r = rig(HEIGHTS_HYPAR, { hw: HARDWARE[1] });
|
|
const wind = createStubWind({ seed: 1, stormLen: 90 });
|
|
const peak = runStorm(r, wind, 90);
|
|
for (const v of r.pos) assert(Number.isFinite(v), 'went NaN on the shared stub wind');
|
|
assert(peak > 0, 'shared stub wind produced no load at all');
|
|
return `90 s on contracts.js stub wind, peak ${kN(peak)}, ${r.corners.filter((c) => c.broken).length}/4 corners lost`;
|
|
});
|
|
|
|
export const SAIL_TESTS = TESTS;
|
|
|
|
export function runSailSelftest() {
|
|
const results = TESTS.map(([name, fn]) => {
|
|
try { return { name, pass: true, detail: fn() || '' }; }
|
|
catch (e) { return { name, pass: false, detail: e.message }; }
|
|
});
|
|
return { pass: results.every((r) => r.pass), results };
|
|
}
|
|
|
|
export function report(out) {
|
|
const lines = out.results.map(
|
|
(r) => `${r.pass ? 'PASS' : 'FAIL'} ${r.name}${r.detail ? `\n ${r.detail}` : ''}`
|
|
);
|
|
return `${lines.join('\n')}\n\n${out.pass ? 'ALL GREEN' : 'FAILURES'} — ${out.results.filter((r) => r.pass).length}/${out.results.length}`;
|
|
}
|
|
|
|
// Run only when invoked directly; importing this module must not run the suite.
|
|
if (typeof process !== 'undefined' && process.versions?.node && import.meta.filename === process.argv[1]) {
|
|
const out = runSailSelftest();
|
|
console.log(report(out));
|
|
process.exit(out.pass ? 0 : 1);
|
|
}
|
|
|
|
export { makeStubWind };
|