diff --git a/LANE_PROMPTS.md b/LANE_PROMPTS.md index 8d7251c..71c8806 100644 --- a/LANE_PROMPTS.md +++ b/LANE_PROMPTS.md @@ -668,3 +668,86 @@ E 8828; integration holds 8823). > 0.22/0.30/0.35 hints from B's re-audit once the sim reads them — the > numbers are yours to defend or move, with B's audit as the evidence. The > tree-move stays cancelled. + +--- + +# SPRINT 13 prompts (the garden matters, the night looks like a night) + +Same rules: own clone, own branch, rebase onto latest main FIRST (your local +branch may be BEHIND origin after integration fast-forwards — start with +`git fetch origin && git reset --hard origin/lane/` on a clean tree). Read +THREADS from the last two [I] entries — the QA pass entry is this sprint's +evidence base — then SPRINT13.md. Per-clone launch.json: copy the example, +pick your port (A 8824, B 8825, C 8826, D 8827, E 8828). Baseline selftest +335/0/0; keep it green after every landing; new asserts get mutation-checked. +The game is PUBLIC now (partly.party/hardyards) — main must always be +shippable. + +## Lane A — Sprint 13 +> You are Lane A on SHADES 3D, Sprint 13. Rebase onto main, read THREADS' +> last two [I] entries, then SPRINT13.md. Gate 3 is yours and it's the front +> door of a public game: pin the Enter-exploit fix with a regression assert +> (the hot-fix is already in your main.js with a comment — an advance() +> reachable from 'storm' must go red; mutation-check by reverting the guard), +> then the splash card (premise + controls + START, one more .card, not a +> menu system), P pause / M mute, and the touch-visitor notice. Gate 2 gives +> you two camera fixes: spawn framing (no pole through the player on boot) +> and the aftermath cloth-swallow (dead sail joins the camera's solid set). +> Two rulings will route to you: C's garden separation target (gate 1) and +> whether GARDEN_DRAIN moves once the shadow geometry is honest. Move the dev +> fps line out from under the anchor panel. Do NOT start reputation, site_03, +> or heatwave — gate 4 decides Sprint 14. Shepherd as always. + +## Lane B — Sprint 13 +> You are Lane B on SHADES 3D, Sprint 13. Rebase onto main, read THREADS' +> last two [I] entries, then SPRINT13.md. Gate 1.2 is yours: the audit's +> "cover%" told three people a $20 rig was bad while the sim paid it +$97 — +> once C lands the shadow-geometry fix, make the audit PREDICT the sim's +> garden outcome (same quantity, two harnesses) and re-post the per-night +> winnable-lines table; propose fee/bonus retunes in THREADS if night balance +> re-breaks, A rules. Gate 3 smalls in your files: BLOWN label collision for +> adjacent corners, setHardware() must not silently no-op on a bad key, +> standing-kN preview per corner in the prep panel (D's "first lesson costs +> $60 blind"), and rig.t must reset between nights. Stretch, only if room: +> sweep mixed-hardware fuse lines (D's +$147 exhibit) and rule-or-flag +> whether cheap-corner-as-fuse is depth or a hole. + +## Lane C — Sprint 13 +> You are Lane C on SHADES 3D, Sprint 13. Rebase onto main, read THREADS' +> last two [I] entries, then SPRINT13.md. You carry this sprint. Gate 1: the +> shadow GEOMETRY is the bug — measure rain/hail shadow over the bed (held +> rig vs bare bed, both yards, five storms), fix the model not the constant +> (hail's damage share, bed-level occlusion, storm hail timing — your pick, +> measured), and propose the separation target to A BEFORE tuning to it. The +> sim must make "sail up" vs "sail dead" read alive-vs-dead on wild nights. +> Gate 2: storm grade (sky/light/shadow keyed on intensity — the noon-blue +> 65 km/h sky is the QA pass's biggest visual finding), ground the front +> wall's base on the horizon and feather its hard vertical seam (judge from +> IN-YARD eye height, not your bench), and a handful of deterministic leaves +> streaming with the wind from ~30 km/h. Everything (dt, t) as always. + +## Lane D — Sprint 13 +> You are Lane D on SHADES 3D, Sprint 13. Rebase onto main, read THREADS' +> last two [I] entries, then SPRINT13.md. You are the verdict on both big +> gates. Gate 1: replay the QA pass's three scenarios exactly (night 2 cheap +> line; night 3 carport line with the sail dead at t=3; night 3 honest line) +> after C's model lands — losing the sail must COST the garden, holding it +> must SAVE it, numbers filed. Gate 2: judge the storm grade, the wall from +> inside the yard, the leaves, and wire E's wind clips in player.js +> (thresholds off wind.speedAt(player.pos), brace on the existing C key). +> Fix your two pool nits: the ladder label says "fascia" on a carport +> bracket, and the dropped spare's whereabouts after a knock. Also run down +> the ghost-white sliver near the shed table in aftermath — it smells like +> your ladder's placement ghost. + +## Lane E — Sprint 13 +> You are Lane E on SHADES 3D, Sprint 13. Rebase onto main, read THREADS' +> last two [I] entries, then SPRINT13.md. One job, done to your own standard: +> wind clips for the player — lean / stagger / brace, staged by wind band +> (calm, working breeze, gale), through the Mixamo pipeline. Deterministic +> factory, byte-identical across runs, dims verified, and LOOK at the +> silhouette before you ship (your bike rule: the verify can't answer "is +> this the right shape"). D wires them; agree the clip names and band +> thresholds with D in THREADS before you export. Stand by for retune +> arguments if gate 1's garden fix moves your bonus numbers — yours to +> defend or move, evidence in THREADS. diff --git a/SPRINT13.md b/SPRINT13.md new file mode 100644 index 0000000..6a31c07 --- /dev/null +++ b/SPRINT13.md @@ -0,0 +1,129 @@ +# SPRINT 13 — THE GARDEN MATTERS, AND THE NIGHT LOOKS LIKE A NIGHT + +*Sprint 12 made the trap real and the paperwork beautiful, and the integrator's +QA pass (THREADS, last [I] entry — read it FIRST, it is this sprint's evidence +base) found the gap that's left: the game PLAYS dramatically and LOOKS calm. +The sail died at t=3 on the funnelled buster and the bare bed still finished +83%; a 65 km/h southerly ran under a noon-blue sky; and the public URL +(partly.party/hardyards is LIVE — strangers can reach this game now) had an +Enter exploit that paid full price for a storm that never ran. 335/0/0 at +integration; the Enter fix is hot-fixed and deployed, unpinned.* + +Baseline: selftest **335/0/0**. Every landing keeps it green and adds asserts +that can actually fail — mutation-check anything you'd call coverage. + +## Gate 1 — THE GARDEN MATTERS (C owns the model, B the audit, D the verdict, A rules) + +Three independent sightings of one variable (QA entry, 🌱 section): the sim's +garden outcome barely responds to whether a sail is up. A's GARDEN_DRAIN +comment in main.js names the suspect — the rain shadow decays to ~nothing as +wind builds (driving rain walks under the sail), so a perfect rig is ~23% +drier than a bare bed and NO drain constant can separate good rigging from +none. The core fantasy ("the seedlings are the whole point") is not currently +true in the sim. + +1. **C — the shadow geometry is yours.** Diagnose where protection actually + goes: measure rain-shadow-over-bed and hail-shadow-over-bed across wind + speeds for (a) a held honest rig, (b) a bare bed, both yards, all five + storms. Then fix the MODEL, not the constant. Candidate levers, yours to + choose with measurements: hail carrying more of the damage budget on windy + nights (stones fall ≤20° off vertical — a sail honestly stops them; rain + at a 73° lean honestly doesn't), a bed-level occlusion term (the bed has + sides; driving rain at 73° hits the planting from the side the FENCE and + sail edge shadow, not the sky), or storm-profile hail timing. The DESIGN + target A rules on (propose it in THREADS before you tune to it): **a held + honest rig vs a bare bed must separate by enough that the garden bonus + reads as earned — think alive-vs-dead on the wild nights, not 88-vs-83.** +2. **B — cover% and bed-HP must become the same quantity.** Your audit's + "cover" told three people a $20 rig was bad while the sim paid it +$97. + Whatever C lands, your audit must PREDICT the sim's garden outcome — same + number, two harnesses, or the tool goes back to lying politely. Re-post + the per-night winnable-lines table once C's model lands; expect the cheap + lines to finally price honestly. If the fix re-breaks night balance + (nights 4–5 were already bank-funded), propose fee/bonus retunes in + THREADS with the table as evidence — A rules. +3. **D — the verdict.** Replay the three QA scenarios exactly: night 2 cheap + line, night 3 carport line (sail dead at t=3), night 3 honest line. The + acceptance is felt, not asserted: losing the sail must COST the garden, + holding it must SAVE it, and the invoice's garden line must feel earned in + both directions. File numbers like always. +4. **A — two rulings.** The separation target (C proposes, you rule), and + whether GARDEN_DRAIN itself moves once the geometry is honest (your + comment says the constant was compensating; it may want lowering back). + +## Gate 2 — THE NIGHT LOOKS LIKE A NIGHT (C + E + D judges; A wires camera) + +The QA 🌤 section, in priority order. All sim-visible work stays deterministic +`(dt, t)` — no Date.now, no Math.random in the render path keyed off wall time. + +1. **C — storm grade.** Sky colour, light intensity, and shadow softness keyed + on storm intensity: as the wind builds the sky dims toward slate, the sun + loses its noon edge, the yard reads WEATHER. Cheap version first (lerp the + sky/hemisphere/directional intensities off the same intensity curve the + rain already uses); a dusk baseline palette for the whole week is in scope + if it stays one constant away from reversible — it is the NIGHT shift. +2. **C — the wall's edges.** From in-yard eye height (not the bench): kill + the hard vertical seam (soften/feather the bank's ends) and ground the + base ON the horizon — blue sky under the wall reads as a floating slab. + D re-judges from inside the yard this time. +3. **C — ambient debris.** A few leaves streaming with the wind from ~30 km/h + sells the gale better than any HUD number. debris.js is yours; keep the + count tiny (single digits) and deterministic. +4. **E — wind clips for the player.** Lean/stagger/brace Mixamo clips, staged + by wind band (calm / working breeze / gale). Ship them like every clip: + deterministic factory, byte-identical, dims verified, and LOOK at the + silhouette — your own bike rule. **D wires them** (player.js is D's): + thresholds off `wind.speedAt(player.pos)`, brace pinned to the C key that + already exists. +5. **A — two camera fixes.** Spawn framing: the boot camera puts a pole + dead-centre through the player on every single first impression — bias the + spawn yaw so the opening frame is player + bed + sail line, no pole. And + aftermath: the dead draped sail can swallow the camera whole; the cloth + needs to join the camera's solid set (you own camera.js and its setSolids). +6. **D — judge all of it in play** and fix your two pool nits while you're in + there: the ladder label says "fascia" on a carport bracket, and the dropped + spare's whereabouts after a ladder knock are unknown. + +## Gate 3 — THE FRONT DOOR (A owns; the public URL earns it) + +1. **Pin the Enter fix.** The hot-fix is in main.js with a comment; write the + regression assert — an `advance()` reachable from 'storm' via keydown must + go red. Mutation-check it by reverting the guard. +2. **Splash card.** Name, one line of premise ("rig shade sails; keep the + client's garden alive through the storm"), controls (WASD · mouse orbit · + [ ] tension · S spare · E repair · C brace · Enter commit), one START + button. It is the game's real front door now — a stranger from + partly.party's arcade should know what to do in five seconds. Keep it in + hud.js's card system (.card, .go) — it is one more card, not a menu system. +3. **Pause + mute.** P pauses the fixed-dt accumulator (storm only; cards + already pause by construction), M mutes C's audio bus. Two keys, shown on + the splash and the help line. +4. **Touch notice.** A coarse-pointer/no-keyboard visitor gets a polite card + ("HARD YARDS needs a keyboard and mouse — grab a laptop") instead of a + dead canvas. +5. **Small ones, spread by ownership:** BLOWN label collision when adjacent + corners die together (B — marker layout is rigging.js); `setHardware()` + silently no-ops on an unknown key — throw or ticker it (B); dev fps line + sits under the anchor panel (A); ghost-white sliver near the shed table in + aftermath — identify and fix or explain in THREADS (D, it smells like the + ladder ghost); standing-kN preview per corner in prep (B — the panel is + yours; D's "first lesson costs $60 blind" find); `rig.t` never resets + between nights (B). **B stretch, only if the gate-1 re-audit leaves room:** + sweep mixed-hardware lines for fuse behaviour (D's +$147 exhibit) and say + whether cheap-corner-as-fuse is emergent depth to keep or a hole to close. + +## Gate 4 — JOHN PLAYS (six sprints standing, and the URL makes it easy) + +partly.party/hardyards, five nights, three sentences in THREADS. The Sprint 14 +branch — reputation/warranty vs site_03 vs heatwave days — stays undecided +until they land. Nobody builds any of the three this sprint. + +``` +gate 1: shadow geometry fixed by measurement · separation target ruled and hit · + audit cover% predicts sim garden · D feels the difference both ways +gate 2: storm grade in · wall grounded and seamless from in-yard · leaves fly · + player leans into the gale · spawn frame clean · camera can't drown in cloth +gate 3: Enter assert pinned · splash, pause, mute, touch notice shipped · + the small-ones list empty or argued in THREADS +gate 4: John's three sentences +``` diff --git a/THREADS.md b/THREADS.md index abe9558..91f5bbb 100644 --- a/THREADS.md +++ b/THREADS.md @@ -4511,3 +4511,53 @@ anchors are your GLB), but the tooling is now waiting, not TODO. **Gate 4 is OPEN: Sprint 13's branch — reputation/warranty vs site_03 vs heatwave — waits on John's three sentences, and the game is the best argument for playing it that it has ever been.** + +[I] 2026-07-17 — 🔍 **INTEGRATOR QA PASS — I played it. Three nights, both yards, took the carport + bait on purpose. HARD YARDS is live at partly.party/hardyards, and this entry is the snag list + the deploy earned.** Everything below was seen in the running game, not reasoned about. + + **⚠️ FIXED AT INTEGRATION, A to pin: Enter skipped the storm and paid in full.** main.js's + keydown fell through to `game.advance()` in EVERY phase, so Enter during a storm jumped straight + to a perfect invoice — I banked +$90 on a night that never ran; garden 100%, "every corner + held", clean bonus, on the public URL. Hot-fixed (`if (game.phase !== 'prep') return;` before + the commit path — forecast/aftermath already advance through their cards, which `hud.cardOpen` + catches). Selftest 335/0/0 after; Enter-in-prep still commits; Enter-spam in storm verified + inert. **A: the fix is in your file with a comment; give it the regression assert it deserves — + an advance() reachable from 'storm' must go red.** + + **🌱 THE BIG ONE — the garden barely matters, and this is now THREE sightings of one variable.** + 1. D's replay table: their in-sim $20 flat rig banked 39/45 garden bonus on night 2 where B's + audit calls that line "29% cover". + 2. My night 2: $20 all-carabiner line, P4 blown mid-storm — garden 88%, +$97. + 3. My night 3: sail DEAD at t=3 (carport line, both cb corners gone in the settle), bare bed + through the entire funnelled buster — garden 83%, bonus +$37 of $45. + A's own GARDEN_DRAIN comment names the suspect: the rain shadow decays 0.38→0.04 as wind builds + (driving rain walks under the sail), so a perfect rig is only ~23% drier than a bare bed and no + drain constant can separate good rigging from none. The game's core fantasy — "the seedlings + are the whole point" — is not currently true in the sim. This is Sprint 13 gate 1. + + **🌤 The night doesn't look like a night.** At 65 km/h with driving rain the sky is noon-blue, + shadows are razor-sharp midday, the player stands bolt upright and unbothered, and debris reads + 0 through night 3. All the drama is mechanical, none of it is atmospheric. Also seen: C's front + wall from IN-YARD eye height (not the bench) shows a hard vertical seam on its edge and its + base floats above the horizon with blue sky underneath — direction and timing are excellent, + the edges need licking. Sprint 13 gate 2. + + **🚪 Front-door gaps, now that strangers can reach it:** no splash/onboarding (a cold visitor + lands on the job sheet and learns the controls only from prep's help line), no pause, no mute + (and C just added audio), no restart short of reload, nothing shown to a phone/touch visitor + but a dead canvas. Spawn framing puts a pole dead-centre through the player on every boot; in + aftermath the dead draped sail can swallow the camera whole (no cloth-vs-camera handling). + + **Smaller, seen in play:** adjacent BLOWN labels overlap (CB1/CB2 died together and typeset on + top of each other); `setHardware()` silently no-ops on an unknown hardware key; the dev fps + line sits under the anchor panel; a ghost-white sliver floats near the shed table in aftermath + (the ladder's placement ghost?). Plus the carried pool from D: standing-kN readout in prep, + rig.t never resets between nights, ladder label says "fascia" on a carport bracket, dropped + spare's whereabouts, mixed-hardware fuse lines unswept. + + **The good news, so nobody reads this as a bad report card: the invoice is the best thing in + the game** — the .void strike-through, the −$126 in red, "THE GARDEN MADE IT. The sail didn't" + — a bad night reads as a story you did to yourself. The trap fires as theatre, the Vasilaros + brief is perfect bait, and the loop is solid. The gap between how the game PLAYS and how it + LOOKS is the whole of Sprint 13. diff --git a/web/world/js/main.js b/web/world/js/main.js index 2b801ad..e216420 100644 --- a/web/world/js/main.js +++ b/web/world/js/main.js @@ -875,15 +875,18 @@ export async function boot(opts = {}) { addEventListener('keydown', (e) => { if (e.key !== 'Enter' || hud.cardOpen) return; - // Leaving prep means committing the rig — Lane B's session refuses if it - // isn't four corners, and says so in the ticker. - if (game.phase === 'prep') { - if (!rigging.commit()) return; - // Off the bank, not off START_BUDGET — see the note on showTonight(). - spentThisNight = week.bank - rigging.summary.budget; - player.sim.carrying = null; - if (rigging.summary.spares > 0) pushEvent(`spare shackle on the shed table — grab it before you need it`); - } + // Enter means ONE thing: commit the rig and start the night. It used to + // fall through to game.advance() in every phase, which made Enter DURING + // a storm skip straight to a perfect invoice — the storm never ran, every + // corner "held", full pay. Found in the SPRINT12 QA pass, live on the + // public deploy. Forecast/aftermath advance through their cards (cardOpen + // catches those above); nothing else may advance the phase machine. + if (game.phase !== 'prep') return; + if (!rigging.commit()) return; + // Off the bank, not off START_BUDGET — see the note on showTonight(). + spentThisNight = week.bank - rigging.summary.budget; + player.sim.carrying = null; + if (rigging.summary.spares > 0) pushEvent(`spare shackle on the shed table — grab it before you need it`); game.advance(); });