# vheight The shape of Amagiri, as one function. `VH.height(x, z)` is the authority on where the ground is. The rendered terrain mesh and the physics heightfield are two samplings of that same function, so what you see and what you stand on are the same surface by construction rather than by agreement. ```luau local VH = require("valley.vheight") local y = VH.height(12.0, -40.0) -- world Y of the ground there local d, py = VH.nearestOnPath(x, z) -- distance to the cliff path, and its height local e, handle = VH.buildGround(root, material) ``` ## What the function is made of Read in order, each term laid over the last: 1. the drowned floor at `Game.FLOOD_FLOOR`, with only a little relief — the water surface fades out where the column it crosses is very short, so a floor that wanders breaks the flood into plates of bare ground; 2. the south shelf rising out of the flats to the landing; 3. the north massif, measured **from the flood floor** — a massif based at zero takes the maximum against the drowned half of the valley and lifts the whole floor to exactly water level; 4. a shallow basin under the flood, so the water has a depth to read through; 5. rock relief, scaled by how far above the water a place already is; 6. the rim — walls of last resort, so the valley is closed by slope rather than by an invisible plane at the edge of the map; 7. the places that have to be exactly where `Game.ANCHORS` says they are; 8. the cliff path, cut in last so it always wins over the rock it crosses. ## The grid 193 vertices over 236 metres — a 1.23 m cell, fine enough for a seven-metre cliff ledge to read as a ledge. Collision is a `HeightfieldCollider` over the same grid: one cell lookup per test rather than a walk down a triangle tree, which is what makes a valley this size collide for nothing.

# game.Game The shared interface of **Amagiri: Hollow Bell**. Every part of the game talks through this module and nothing else. ```lua local Game = require("game.Game") ``` It holds: - **the anchors** — `Game.ANCHORS`, `Game.CLIFF_PATH`, `Game.WATER_LEVEL`, `Game.FLOOD_FLOOR`: one set of world coordinates the valley builds to and the cast stands on. - **the vocabularies** — `Game.EMOTION`, `Game.RESONANCE`, `Game.ENDING`, `Game.CHARACTERS`. - **the run state** — resonances held, how far the Fading has advanced, per-character flags, and the ending, mutated through `grantResonance`, `setFading`, `endRun`, `resetRun`. - **an event bus** — `Game.on(event, fn)` returning an unsubscribe, and `Game.emit(event, payload)`. - **three registries** — interactables (what the player can walk up to), dialogue scripts, and character portraits. - **the mounting** — `Game.boot()`, `Game.rebuild(slice)`, `Game.tick(dt, mode)`, called by the scene's entrypoint. It owns no entities, no UI and no behaviour. It is the contract.

# vprops The things standing in Amagiri, as geometry. A mesh builder and the shapes to put in it. Nothing here knows about Amagiri — it is boxes, cylinders, beams, roofs, torii, lanterns, houses and grass, and `valley` decides where they go. ```luau local P = require("valley.vprops") local b = P.builder() b:at(x, y, z, yaw, pitch, roll) -- place everything emitted from now on P.torii(b, 5.0, 5.0, 1.4) -- span, height, how deep it stands P.lantern(b, 1.0) b:box(0, 1.5, 0, 2, 1.5, 3) local mesh = renderer.mesh.create(P.geometry(b, "my_props")) ``` ## Why a builder A prop emitted into a shared mesh costs a few dozen quads and no entity. Every torii, house, post and lantern in the valley wearing one material becomes one mesh and one draw, so the whole place is a dozen entities rather than a thousand. The builder carries a transform, so a shape is written once in its own local space and placed anywhere. ## Shapes `quad` · `tri` · `box` · `cylinder` (tapering, optional caps) · `beam` (a four-sided prism between two arbitrary points — a branch, a rafter, a span of an arch) · `gableRoof` · `hipRoof` · `torii` · `lantern` · `houseBody` / `houseFrame` / `houseRoof` (three parts, so walls, frame and roof can each go into the mesh of the material they are made of) · `deadTree` · `boulder` · `grassTuft`. `grassTuft` writes `uv.y` from 0 at the root to 1 at the tip, which is what `@builtin::shaders.grass_material` bends a blade by, and emits each blade on both faces so a back-face-culled material still shows it from every side. ## One rule the shapes follow No two surfaces sit at the same depth. A cap rests *into* the box below it, an eave board sinks into the wall head, consecutive steps interpenetrate, and the back face of a grass blade is pushed a millimetre off the front. Two faces at one depth look perfect in every still and shimmer for everyone who walks past them.