diff --git a/LANE_PROMPTS.md b/LANE_PROMPTS.md index b7f1c06..de5693d 100644 --- a/LANE_PROMPTS.md +++ b/LANE_PROMPTS.md @@ -274,3 +274,59 @@ Read THREADS' last [I] entry (the dispute ruling) then SPRINT4.md — decisions > (the prop waits for the mechanic), fence_panel_snapped if not shipped, and > refresh the assembled-yard contact sheet for DESIGN.md — the yard finally > looks like the game. + +--- +--- + +# SPRINT 5 prompts (hail & the broom — fire all five) + +Same rules: own clone, own branch, rebase onto latest main FIRST (Sprint 4 +merged; router passes rain data; downdraftOfTotal 0.45; decision 13 ruled). +Read THREADS' last [I] entry then SPRINT5.md. + +## Lane A — Sprint 5 +> You are Lane A on SHADES 3D, Sprint 5. Rebase onto main, read SPRINT5.md +> §Lane A. Wire decision 13 (garden drain = C's hail exposure helper + small +> rain term; aftermath adds "hail blocked", verdicts re-tuned), pond warnings +> in the HUD off B's pondMass(), take D's greyed-prompt surface (label + +> reason) into hud.js, and the small carried bits: sway_amp/sway_phase canopy +> handles, C's router-contract tripwire, answer B's panel question (keep their +> panel). Keep 60 fps with hail + rain + ponding live. Shepherd as always. + +## Lane B — Sprint 5 +> You are Lane B on SHADES 3D, Sprint 5. Rebase onto main, read SPRINT5.md +> §Lane B — the water arc has been carried twice and everything now waits on +> it. Ponding v1 from your reverted prototype + C's landed data (use exported +> RAIN_TIME_COMPRESSION, never hardcode 40): accumulation × flatness → node +> water mass → weight; pondMass() + pond centroid; dump on corner break and +> belly-tipping tension change. Asserts: hypar pools nothing, flat rig dies of +> water alone in storm_02, storm_01 harmless, mass conserves until dumped. +> Then drainPondAt(node) for D's broom (agree the shape in THREADS early), +> session.reset() for A, and the tn-1.04 stability clamp (post §7 deltas +> before landing). + +## Lane C — Sprint 5 +> You are Lane C on SHADES 3D, Sprint 5. Rebase onto main, read SPRINT5.md +> §Lane C — hail is yours and it's decision 13's engine. Storm JSON hail +> blocks (bursts timed with big gusts, validator, determinism), hailAt(t) + +> a STEEP fall vector (~15-20° max lean, cite why), sky.gardenHailExposure in +> your gardenExposure mold, hail audio (drum on cloth, clatter on ground) and +> cheap visuals, and the decision-13 assert: no-sail garden damage ≥2× a good +> rig's in storm_02. storm_02 gets its burst at the change; storm_03 mild; +> storm_01 none. + +## Lane D — Sprint 5 +> You are Lane D on SHADES 3D, Sprint 5. Rebase onto main, read SPRINT5.md +> §Lane D — the broom is yours and it's the gate: take broom (hands-full rules +> vs spare/ladder), walk under the belly, hold-E poke (Crank/Dig per E's +> anim_hint) → B's drainPondAt() → the water dumps ON YOU (stagger if big — +> comedy is the point) and the sail springs back. Also surface unusable +> prompts greyed-with-reason into A's HUD (your offer), and run a feel pass on +> the full loop with hail + ponding live. Log everything in THREADS. + +## Lane E — Sprint 5 +> You are Lane E on SHADES 3D, Sprint 5. Rebase onto main, read SPRINT5.md +> §Lane E. Small juice pass: hail impact pips + ground ring decal +> (instanced-friendly, stone mesh only if C asks), plant-shred particle puff +> for hail hits on the bed, and the carried contact-sheet refresh (night + +> daylight) for DESIGN.md. diff --git a/SPRINT5.md b/SPRINT5.md new file mode 100644 index 0000000..d422fdc --- /dev/null +++ b/SPRINT5.md @@ -0,0 +1,115 @@ +# SPRINT 5 — HAIL & THE BROOM (instructions for Opus 4.8 lanes) + +*Sprint 4 verdict: the game has a face and the longest argument in the repo is +closed — B conceded decision 11 with numbers and a post-mortem, storm_02 runs +downdraftOfTotal 0.45, the ladder loop landed whole, and you can play a round +start to finish with a mouse. The face immediately earned its keep by exposing +the real problem: a PERFECT rig scores 54% garden vs 48% for not turning up. +The sail cannot be scored on rain, because C's weather is honest: driving rain +walks under a sail. Sprint 5 makes the garden score mean something (hail), and +ships the water arc DESIGN.md promised (ponding + the broom).* + +Read THREADS from the last [I] entry. Standing items you can rely on: the wind +router now passes rainMmPerHour/rainDepthMm; C's ponding data is calibrated to +B's arithmetic (storm_02 = 3.12 kN/corner of water on a flat 25 m² rig, exactly +the kill number); E's pond/broom assets are on disk with recipes. + +## Decision + +13. **Hail carries storm garden damage; rain demotes to a small drain.** + Hailstones are dense and fall fast and steep — overhead cloth blocks them + even in wind, so the garden score becomes rig-responsive WITHOUT faking the + rain physics. This is also canon: DESIGN.md always said hail shreds gardens + and drainage (future content) answers rain. Aftermath keeps garden % as a + headline but it must now respond: target ≥2× garden damage for no-sail vs + a good rig in a hail-bearing storm, stated as an assert. + +## Lane C — hail (the sprint's new system) + +1. Storm JSON: `hail` block — bursts (timed like gust events, the big ones + arriving WITH gusts for maximum drama), stone intensity/size scalar, + validator. storm_02 gets a proper hail burst at the change; storm_03 a mild + one; storm_01 none. Determinism rules as ever (own stream or zero draws). +2. `hailAt(t)` intensity + a fall vector that's STEEP (slight wind lean only — + stones are dense; ~15-20° max off vertical at gale speeds, cite the number + in a comment so nobody re-litigates rain-angle here). +3. Garden damage feed: `sky.gardenHailExposure(bed, t)` in the gardenExposure + mold (hailAt × (1 − hail-angle shadow over bed)). A wires the drain. +4. Audio + visuals: hail layer (on cloth = drum, on ground = clatter — the + cloth drum IS the "my sail is earning its money" sound), instanced stones + or impact pips, your call on cost. Lightning already lands on big gusts. +5. Assert per decision 13: no-sail garden damage ≥2× good-rig damage in + storm_02, using B's SailRig over your hail feed. + +## Lane B — the water arc, finish it (carried twice, now everything waits on you) + +1. **Ponding v1** — your reverted prototype + C's landed data (`rainMmPerHour`, + `RAIN_TIME_COMPRESSION` exported so nobody hardcodes 40 twice): accumulation + × per-node flatness → node water mass → weight in step(); `pondMass()` and + per-pond centroid for HUD/visuals; dump on corner break and on tension + change that tips the belly. Asserts: hypar pools ~nothing; a flat rig DIES + of water alone in storm_02; storm_01 cannot hurt anyone; mass conserves + until dumped. +2. **`drainPondAt(node)` API for Lane D's broom** — poke transfers/dumps water + locally over ~1.5 s. Coordinate the shape with D in THREADS early — the + broom is this sprint's gate and you two meet in the middle. +3. `session.reset()` (A's ask — they're reaching into your state machine to + fake it). Small. +4. Stability clamp for the tn-1.04 cliff (carried; if it moves §7 numbers, + post before landing). + +## Lane D — the broom (DESIGN.md's funniest correct mechanic) + +1. Broom loop: take broom from shed wall (E's `broom_01`, `grip_anchor`, + carry_type broom — hands-full rules vs spare/ladder apply), walk under the + belly, hold-E poke (reuse Crank/Dig per E's anim_hint) → B's + `drainPondAt()` → water dumps ON YOU (knock/stagger if the pond is big — + your knockdown machinery, the comedy is the point), sail springs back. +2. Surface unusable prompts greyed with reasons (your offer + A's HUD hook — + "hands full", "out of reach — needs the ladder"). Kills the + vanishing-prompt confusion you logged. +3. Feel pass on the full loop with hail + ponding live; log notes. You're + still the only lane that plays like a player. + +## Lane A — score truth & polish + +1. Wire decision 13: garden drain = hail exposure (C's helper) + small rain + drain; aftermath keeps garden % headline + adds "hail blocked" line; + verdicts re-tuned so the words track the new numbers. +2. Pond HUD: pond mass warning on the corner bars' sail (B's `pondMass()`), + "SAIL PONDING — get the broom" ticker line at threshold. +3. Take D's greyed-prompt surface into hud.js (they provide label + reason). +4. Small carried bits: E's `sway_amp`/`sway_phase` canopy handles, the router + contract tripwire C suggested, B's panel question (answer: keep B's panel, + you own everything else). +5. Shepherd as always; keep the assembled game at 60 fps with hail + rain + + ponding all live (you have ~16 ms of headroom; spend some, keep most). + +## Lane E — hail & water juice (small) + +1. Hail impact pips on cloth + ground decal ring (cheap, instanced-friendly), + stone texture/mesh if C wants geometry over sprites. +2. Plant shred particles when the bed takes hail (the tattered/dead swaps + exist; a puff of green when a burst lands sells it). +3. Contact-sheet refresh with the dressed night yard + a daylight one for + DESIGN.md (carried). + +## Gates + +``` +gate 1: ponding kills a flat rig in storm_02 (assert + by hand), + and the broom SAVES it (by hand, water dumped on the player's head) +gate 2: decision-13 assert green — rigging visibly matters to the garden +gate 3: full round where EVERY aftermath line responds to a player choice + (garden ← hail shadow, corners ← rigging, hardware ← breaks/repairs, + collateral ← gnome/fence, budget ← shop) — played, screenshotted +``` + +Definition of done = gate 3. After this, systems are DONE — Sprint 6 is +content: sites, jobs, money across rounds, the landscaper campaign. + +## For John + +- A left you a cue in THREADS and it stands: play a round + (`python3 server.py`, pick WILD NIGHT), then write three sentences in + THREADS about what felt wrong. Sprint 6's shape depends on them.