monster/HardYards
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Lane D: ladder survives a mid-carry knockdown, and the prompt names the right bracket

Browse Source 
SPRINT13 gate 2.6 pool, both found by the integrator's QA and both silent
(no error, no red, just a mechanic that stopped):

- The ladder left the game if the wind took you over while carrying it.
  knockdown() -> drop() nulls player.carrying but nothing told the ladder,
  so state.carried stayed true: the mesh hid (visible = !carried), pos()
  returned null so there was nothing to walk to, and canUse gated on
  !carried so it could never be picked up again. Swept the whole yard post-
  knockdown: no usable ladder offer anywhere, while ladder_place still said
  'it's by the shed'. On the corner block that silently ends the site's
  thesis (cb1/cb2 are bracket work). Fix: reconcile against the player's
  hands every frame in update() and let the ladder fall flat where it was
  lost, findable and re-takeable. Verified in the running game.

- The place label hardcoded 'the fascia' — a lie on a carport beam. Now
  keyed on anchor.type (a checked enum since Sprint 11): house -> the
  fascia, carport -> the carport bracket, unknown -> the bracket (vague but
  never false). And it stops claiming 'by the shed' once the ladder is
  dropped in the yard.

Two new asserts against the REAL createLadder, not the fake: the drop-
reconcile and the label. Mutation-checked — reverting the reconcile turns
both red on the right assertions. Selftest 337/0/0 (335 + 2).
This commit is contained in:
type-two 2026-07-18 01:00:01 +10:00
parent 8d0045bb29
commit d7658fb7af
2 changed files with 124 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
web/world/js/ladder.js
View File

@ -69,7 +69,22 @@ export const needsLadder = (anchor) => {
return anchor.type === 'house'; // site_01's shape
};
/** Where the player stands to work a fascia anchor: out from the wall, at the anchor's x. */
/**
* What to call the thing the ladder serves, in the player's own words.
*
* SPRINT13 pool (the integrator's QA pass): the place label hardcoded "the fascia" — true on
* backyard_01, a lie on the corner block, where the bracket is a carport beam. Keyed on `type`,
* which has been a CHECKED enum since Sprint 11 (`validateSite` rejects an unknown one), so a new
* site can only arrive here with a type somebody typed on purpose.
*
* The fallback names the MECHANISM, not a guessed structure: an unmapped bracket reads "the bracket
* needs the ladder", which is vague but never false. Same instinct as `needsLadder` itself — the
* thing that broke here was a rule keyed on site_01's spelling of the idea instead of the idea.
*/
const BRACKET_NOUN = { house: 'the fascia', carport: 'the carport bracket' };
const bracketNoun = (a) => BRACKET_NOUN[a?.type] ?? 'the bracket';
/** Where the player stands to work a bracket anchor: out from the wall, at the anchor's x. */
const STAND_OFF = 0.9; // m clear of the wall face
const PLACE_RANGE = 2.6; // m — how close you must be to a fascia anchor to plant the ladder
const RUNG_CLEAR = 0.55; // m — feet this far below the top rung, so the fascia is at chest height
@ -95,6 +110,8 @@ export function createLadder(scene, world, interact, player) {
base: new THREE.Vector3(),
topY: 2.9, // overwritten from the GLB's ladder_top node
view: null,
dropped: false, // lying in the grass where it was lost (see the reconcile in update)
dropYaw: 0,
};
// Home: leaning on the shed, near the spare table but NOT on top of it. Read from world.shedTable
@ -134,6 +151,11 @@ export function createLadder(scene, world, interact, player) {
// planted: yaw so local +Z faces the wall, then tip the head into it. +X rotation carries the
// top toward local +Z, which is the wall — so the feet stand off and the head rests on it.
state.view.rotation.set(LEAN, Math.atan2(a.pos.x - state.base.x, a.pos.z - state.base.z), 0);
} else if (state.dropped) {
// Dropped, not stowed: it lies FLAT where it fell. The stowed pose is a slouch against the
// shed wall, and a slouch in open grass reads as a ladder leaning on thin air — which looks
// like a bug at exactly the moment the player is hunting for the thing.
state.view.rotation.set(Math.PI / 2, state.dropYaw, 0);
} else {
state.view.rotation.set(0, 0.6, 0.22); // stowed: slouched against the shed
}
@ -169,6 +191,7 @@ export function createLadder(scene, world, interact, player) {
onDone: (p, t) => {
state.carried = true;
state.placedAt = null;
state.dropped = false;
p.pickUp('ladder', t);
syncView();
},
@ -185,15 +208,19 @@ export function createLadder(scene, world, interact, player) {
clip: 'PickUp',
// Reads as an offer when you can, and as a reason when you can't — interact.visible() now
// shows unusable targets greyed, and a label written only as an offer explains nothing there.
// Standing under a blown fascia bracket holding a spare, "the fascia needs the ladder" is the
// single most useful sentence in the game.
// Standing under a blown bracket holding a spare, "the fascia needs the ladder" is the single
// most useful sentence in the game — so it has to name the RIGHT structure, or it's the single
// most confusing one. It said "fascia" in the corner block until SPRINT13.
// ...and it must not lie about WHERE. "it's by the shed" is true until the wind takes it out
// of your hands, and then it's the game sending you to the wrong end of the yard mid-storm.
label: (p) => (p.carrying === 'ladder'
? `set the ladder under ${a.id}`
: 'the fascia needs the ladder — it\'s by the shed'),
? `set the ladder under ${a.id.toUpperCase()}`
: `${bracketNoun(a)} needs the ladder — ${state.dropped ? 'you dropped it out there' : "it's by the shed"}`),
canUse: (p) => p.carrying === 'ladder',
onDone: (p, t) => {
state.carried = false;
state.placedAt = a.id;
state.dropped = false;
state.base.set(a.pos.x, world.heightAt ? world.heightAt(a.pos.x, a.pos.z + STAND_OFF) : 0,
a.pos.z + STAND_OFF);
p.carrying = null;
@ -239,6 +266,29 @@ export function createLadder(scene, world, interact, player) {
* player.js calls this each frame from the same input it reads for movement.
*/
update(dt, t, input) {
// SPRINT13 pool — "the dropped spare's whereabouts are unknown" is the small half of this.
// The player can lose the ladder without telling us: knockdown() calls drop() (player.sim.js),
// which nulls `carrying` and pushes an event nothing here listens for. state.carried stayed
// true forever, and every consequence of that is silent:
// · syncView hides the mesh (`visible = !carried`) → the ladder is invisible
// · ladder_take.pos() returns null while carried → nothing to walk to
// · ladder_take.canUse needs !state.carried → it can never be picked up again
// Blown over mid-carry and the ladder left the game, while ladder_place went on saying "it's
// by the shed". It wasn't. On the corner block that silently ends the site's whole thesis:
// cb1/cb2 are bracket work, and bracket work needs a ladder that no longer exists.
// The player's hands are the one source of truth, so reconcile against them every frame and
// let the ladder FALL where it was lost — the same instinct as STATES.shelter, which enters
// and leaves itself so a dropped release can't strand you. Fetching it is now a cost you can
// see and walk to, which is what the mechanic wanted from the knockdown in the first place.
if (state.carried && player.carrying !== 'ladder') {
state.carried = false;
state.placedAt = null;
state.dropped = true;
state.dropYaw = player.facing ?? 0;
state.base.set(player.pos.x,
world.heightAt ? world.heightAt(player.pos.x, player.pos.z) : 0,
player.pos.z);
}
if (player.state === 'atTop' && input && input.z < 0) player.climbTo(0, t);
syncView();
},

70
web/world/js/tests/d.test.js
View File

@ -16,7 +16,7 @@ import { Interact, wireYardActions } from '../interact.js';
import { createBroom, BROOM_TUNE } from '../broom.js';
// The REAL rule, not the fakeLadder's hand-copied duplicate of it — a rule the suite re-implements
// is a rule the suite cannot catch drifting. (ladder.js is headless-importable for this reason.)
import { needsLadder as realNeedsLadder } from '../ladder.js';
import { needsLadder as realNeedsLadder, createLadder } from '../ladder.js';
import { assert, assertEq, assertClose, assertLess, fixedLoop } from '../testkit.js';
import { FIXED_DT } from '../contracts.js';
import { loadStorm, createWind } from '../weather.js';
@ -448,6 +448,74 @@ export default async function run(t) {
'nor a tree limb — that is a strop you throw');
});
// --- SPRINT13 pool: the real createLadder, not the fake. These two pin the things the QA pass
// found by playing, and both were silent — no error, no red, just a mechanic that stopped.
// (createLadder is scene-free with scene=null: the view is the only THREE it needs.)
const realLadderWorld = () => ({
anchors: [
{ id: 'h2', type: 'house', work: 'bracket', pos: { x: 0, y: 2.48, z: -9.95 } },
{ id: 'cb1', type: 'carport', work: 'bracket', pos: { x: -8.4, y: 2.29, z: -3 } },
],
shedTable: { pos: { x: 9, y: 0.9, z: 6 } },
heightAt: () => 0,
});
t.test('ladder: a knockdown mid-carry drops it in the grass — it does not leave the game', () => {
const world = realLadderWorld();
const interact = new Interact();
const player = new PlayerSim({ start: { x: 4, y: 0, z: 2 } });
const ladder = createLadder(null, world, interact, player);
const takeTarget = [...interact.targets.values()].find((x) => x.id === 'ladder_take');
// in your hands, walking it out to the bracket — through the target's OWN onDone, because
// player.pickUp alone fills your hands without telling the ladder, which is not a state the
// game can produce and would test the fixture rather than the code.
takeTarget.onDone(player, 0);
ladder.update(DT, 0, {});
assert(ladder.carried, 'carried');
assertEq(player.carrying, 'ladder', 'and the hands agree');
assertEq(takeTarget.pos(), null, 'nothing to walk to while it is in your hands');
// the wind takes you over at (4, 2). knockdown() -> drop() nulls carrying, and before SPRINT13
// nothing told the ladder: it stayed "carried" by nobody, invisible and un-takeable forever.
player.knockdown(0, 1, 0);
assertEq(player.carrying, null, 'the knockdown took it out of your hands');
ladder.update(DT, 0, {});
assert(!ladder.carried, 'the ladder knows it is no longer being carried');
const p = takeTarget.pos();
assert(p, 'and it is somewhere you can walk to');
assertClose(p.x, 4, 1e-6, 'it fell where you did (x)');
assertClose(p.z, 2, 1e-6, 'it fell where you did (z)');
assert(takeTarget.canUse({ carrying: null, climbY: 0 }),
'and you can pick it up again — this is the assert that fails if the reconcile is reverted');
});
t.test('ladder: the place prompt names the structure it is under, and where the ladder is', () => {
const world = realLadderWorld();
const interact = new Interact();
const player = new PlayerSim({ start: { x: 4, y: 0, z: 2 } });
const ladder = createLadder(null, world, interact, player);
const placeAt = (id) => [...interact.targets.values()].find((x) => x.id === `ladder_place_${id}`);
const empty = { carrying: null };
// QA pass: this said "the fascia" while you stood under a carport beam.
assert(/fascia/.test(interact.labelOf(placeAt('h2'), empty)), 'the house bracket IS the fascia');
assert(/carport/.test(interact.labelOf(placeAt('cb1'), empty)),
`a carport beam is not a fascia — got "${interact.labelOf(placeAt('cb1'), empty)}"`);
assert(!/fascia/.test(interact.labelOf(placeAt('cb1'), empty)),
'and it must not call it one');
// ...and it must not lie about where the ladder is once the wind has taken it.
assert(/by the shed/.test(interact.labelOf(placeAt('cb1'), empty)), 'stowed: it is by the shed');
[...interact.targets.values()].find((x) => x.id === 'ladder_take').onDone(player, 0);
ladder.update(DT, 0, {});
player.knockdown(0, 1, 0);
ladder.update(DT, 0, {});
assert(!/by the shed/.test(interact.labelOf(placeAt('cb1'), empty)),
'dropped: the shed is exactly where it is NOT');
});
t.test('ladder: keys on the MECHANISM a site declares, not on the anchor type', () => {
// SPRINT10 gate 1. The failure mode is the point: when needsLadder says false, interact's
// canReach returns TRUE UNCONDITIONALLY — so a mis-keyed anchor doesn't error, it silently