# HazardDirector The wreck's temper. Lives on the scene's `RunDirector`, attached by `game/wiring/hazard`. It owns the two decisions no individual hazard can make for itself. **When a structural member lets go.** Past `RULES.CFG.collapseAtInstability` (2) a timer runs down and the next cross-brace in the truss releases. The interval shortens with every plate taken off the wreck, so the shaft you flew in through is not the shaft you fly out of. **How much junk is adrift.** Past `RULES.CFG.debrisAtInstability` (3) chunks wake up, four more per point of instability. A disabled entity does not tick, so a sleeping chunk cannot wake itself — this is the one place that decides. Which brace and which chunks is **by sorted name, never random**: every peer runs the scene entrypoint and builds its own copy of the rig, so two players in the same shaft must be dodging the same beam. (`entity.findAll` returns matches in whatever order the world holds them, which is not spawn order and is not the same on two peers — hence the sort.) ## `collapseNow()` ```lua local name = entity.find("RunDirector").component.get("HazardDirector"):collapseNow() ``` Force the next member to let go, now, and get its name back (or `nil` when the wreck has nothing left to shed). The hazard slice's own test lever, and the hook another slice would use to stage a scripted beat. ## Reading a run from outside Component VMs are their own worlds, so the slice's counters are mirrored onto public fields here every frame and can be read from any `execute`: `instability` · `ventsArmed` / `collapseArmed` / `debrisArmed` · `nextCollapseIn` · `collapses` · `lastCollapse` · `ventFires` · `ventHits` · `debrisHits` · `impacts` · `awakeChunks` · `frames` and, for the route into `flight`: `impulseEntry` (the method name and arity it resolved — `applyImpulse/3` in this world) · `impulses` · `impulsesDropped`. A run where `impulsesDropped` climbs and `impulses` does not is a hazard slice that is damaging you but not moving you.

# game.hazards The shared ground of HULLBREAKER's **hazard** slice — the wreck fighting back. `require("game.hazards")` ## What is in here | | | |---|---| | `CFG` | the hazard slice's own numbers: vent rhythm and reach, collapse interval, debris speeds, contact radii. The numbers that cross a slice boundary (`ventShove`, `impactDamage`, the instability gates) stay in `game.rules`. | | `VENTS` / `BRACES` / `DEBRIS_COUNT` | the manifests. Where the danger is bolted to the Kestrel Wake — seven pressure vents down the shaft, six cross-braces of truss, fourteen chunks adrift. | | `armed(kind)` | `"vent"` / `"collapse"` / `"debris"` — reads `state.instability` against the gates in `RULES.CFG`. The single place the escalation is decided. | | `quiet()` | the run is `won` or `lost`; nothing swings any more. | | `playerBody()` | the local player's body, re-resolved every call. | | `impulse(x, y, z)` | **the only way this slice moves the player.** | | `reportImpact(amount, source)` | `RULES.emit("impact", …)` plus the counter. | | `buildRig()` | spawns the whole rig under one `HazardRig` root. | | `stats` | live counters every hazard writes; `HazardDirector` mirrors them onto public fields so a run is readable from outside the component VMs. | ## The two contracts this module keeps **Hazard never writes the player's position or velocity.** Every shove goes through `impulse`, which resolves the impulse entry point on `flight`'s `Scrapper` component from the component's own declared surface (`asset.inspect`) and calls it. In this world that resolves to `Scrapper:applyImpulse(x, y, z)` and the resolution is logged at startup. If `Scrapper` is not on the body, or declares no matching entry point, the shove is **dropped and counted** (`stats.impulsesDropped`) rather than faked by writing the transform. **Hazard never writes `state.integrity`.** Contact reports `RULES.emit("impact", amount, source)` and `shell` decides what it costs. `source` is `"vent"`, `"collapse"` or `"debris"`. ## Determinism This world is always multiplayer, and every peer runs the scene entrypoint, so every peer builds its own copy of this rig. Nothing here calls `math.random`: a chunk's whole trajectory comes from `debrisRow(i)`, a hash of its index, and `HazardDirector` picks the next member to let go by sorted name. Two scrappers in the same shaft are dodging the same beam. ## The rig `buildRig()` despawns any existing `HazardRig` before spawning a new one, so ownership is re-derived from the world rather than from a module-local list — a hot-reload or a mode flip cannot leave two copies of the wreck's danger standing. It runs from `game/wiring/hazard`'s `onSceneReady` in **both** edit and play, so a vent can be looked at while authoring.