# game.house.HouseBuilder The twelve areas of **The House That Knows You**, as data and one builder. `HouseBuilder.build()` is called from `game.house.sceneContent`, which the scene build calls, so what it makes is baked into `scenes/house.scene/scene.json` and is there the moment the world opens. ## The plan is data - **`ROOMS`** — each area's interior rectangle: `x0..x1`, `z0..z1`, `y0..y1`. The entrance hall is `HALL`, and is built by the scene skeleton, not here. - **`DOORS`** — a doorway is declared by `(a, side, at, other)`: room `a` cuts an opening on the wall named by `side`, centred at `at` measured along it. It is declared by room-and-side rather than by a coordinate because two rooms never share a wall: interiors are spaced so neighbouring walls **abut** and never coincide, and each room cuts its own. Two coplanar walls look perfect in a still frame and shimmer the moment the camera moves. - **`STAIRS`** — the three places the house changes level, each with the room it starts in, the room it arrives in, and the item that locks it. The hole a stair needs is derived from the same entry, so a stair and its hole cannot disagree. - **`PROPS`** — what each room is furnished with; `hide = true` marks a place the player can get inside. - **`UNLIT_ROOMS`** — the basement, secret room, attic and storage room carry no light on purpose. They are torch territory. ## What it exposes - `build()` — build it all. Called from the scene build. - `area(id)` — the centre of an area, for any slice that needs to place something in a room. `roomOf(id)` gives the rectangle. - `doorInfo(id)` — a doorway's lock, for the systems slice. - `hidingPlaces()` — every `hide_<room>_<n>` entity, by name. ## What it names, so other slices can find it `room_<area>` is each room's root; `light_<area>` its bulb; `door_<id>` a door leaf; `door_stair_<id>` a locked stair door; `hide_<area>_<n>` a hiding place; `prop_<area>_<n>` furniture; `spawn_resident_<area>` and `patrol_<area>` the two anchors the monsters slice uses. The furniture is **blocked out**: named, in the right place, at the right size, in a plain material, so the game runs and the polish pass can put the real prop exactly there.

# game.systems.Player Everything the player is and does. Attached to the player's own avatar (the `body` entity inside the player prototype, so every peer gets one). It owns the torch and its battery, sprint and crouch with stamina, health, what is carried, which clues have been read, how far along the objective chain the player is, and what happens when they press E at something. It publishes all of it as fields so the interface can draw it and the creatures can hear it. ## What it does not own The house owns the doors and the hiding places; this reads an `Interactable` marker on them and decides whether the player may pass. The run — objectives, clues, the ending — lives in `game.systems.PlayerState` and in the shared store, so a reload cannot lose it. ## How it touches the engine Two patterns worth keeping, both learned the hard way here: - **Finding what the player can use** goes through the `scene.find` *tool*, never `queryEntitiesFlex`: that function ignores a component filter and answers with every entity in the scene, so "nearest thing in front" becomes a wall. - **Changing a field** is a write onto the component object (`comp.brightness = v`). There is no `component.set`. - **Reach is three-dimensional.** The house is stacked — the living room sits under the attic — so a distance test on x/z alone lets a player take the attic key from the room below. ## Fields `active`, `difficulty`, `health`, `stamina`, `battery`, `torchOn`, `hiding`, `objective`, `prompt`, `carrying`, `clues`, `ending` — all read-only mirrors of the state, for the interface.

# game.systems.Interactable A thing in the house the player can use. **It marks the spot, it does not behave.** It carries what a thing *is* — a door, a pickup, a note, a switch, a place to hide, the way out — and what it is worth; the `Player` component reads it, decides whether the player may have it, and does it. So the house never has to know about keys, and the keys never have to know about hinges. The scene build attaches one to every door leaf and hiding place the house put down, to the front door, and spawns the pickups, notes and the power switch with one already on them. That is what lets a single query find everything the player could be looking at, of every kind. ## Fields | Field | What it is | |---|---| | `kind` | `"door"`, `"pickup"`, `"note"`, `"switch"`, `"hide"` or `"exit"`. | | `ref` | What it is: a door id, an item id, a clue id, or a switch's id. | | `lockedBy` | The `GameRules.ITEMS` id that opens it. Empty means never locked. | | `label` | What the player reads when they look at it. | | `range` | How close the player has to be. | | `spent`, `taken` | A switch already thrown, a pickup already taken. |