# rules <!-- zero:scaffolded-readme --> <!-- Replace the line below with what this module provides and who consumes it, then delete both comment lines. --> TODO: describe this module.

# screens.hud The screens the game wears while it is being played, as pure functions of a view table: the tide gauge, the yowe tally, the station ladder, the phrasebook, the encounter panel and the caption band. Nothing here reads world state or registers a screen — `screens.frontend` does both. ## The geometry, and why it is these numbers The frame is 1080 × 1440. The one thing that cannot be solved by stacking is a full-height meter and a full-width panel wanting the same pixels, so the layout is fixed rather than discovered: | | | |---|---| | x 20 – 104 | the tide column, top to bottom, never covered by anything | | x 124 – 1050 | everything else, in bands down the screen | | y 34 – 130 | the yowe tally (left) and the station ladder (right) | | y 610 – 1410 | the encounter panel, when a hernsew is speaking | | foot | the phrasebook, when one is not | The phrasebook moves **into** the encounter panel while a bird is being answered, because reading the new glyphs against the earned ones is the whole move the game asks for, and hiding the book at that moment would take the game away. Every absolute box is placed by `top` plus an explicit `height`, never by `bottom`: a bottom-anchored box whose height comes out of its own wrapped content lands at the wrong y here, and the caption band and the phrasebook both ran off the foot of the frame that way. ## The encounter panel Driven by `tongue.book`. It draws the call as glyphs and as the Lingster's romanised transcription, the bird's own hint under it, the phrasebook to read them against, and the answers as full-width stacked plates — three side by side do not fit in 1080 and never will. After the answer it holds: the right option lit, the wrong choice marked, and the literal word-for-word reading in place of the hint, so a player who guessed can see why the right answer was right. ## The caption band `H.caption(line, progress, placement)` — `low` over gameplay, `aboveEncounter` while a bird is being answered, `overCard` over a title or an ending, where the card's own type owns the foot of the frame. The bar under the text is the line's own progress: proof on screen that a voice is still speaking, whether or not a clip was ever generated for it.

# tongue.book — Hernsew, and the phrasebook that grows `require("tongue.book")` Hernsew is the tongue the herons of Yowe Fen speak, and this module is all of it: twelve glyphs, one rule of grammar, five calls built out of them, and the phrasebook the Lingster fills in as the run goes on. It is a **model**. It draws nothing. `screens` renders what is in here. ## The tongue Twelve morphemes. Six are **roots** — things. Six are **affixes** that hang on a root and change it. A word is built by one rule: ``` [prefix-] root [-suffix] ``` and a phrase is words in the order they are meant. | | | | |---|---|---| | `kraa` | water | the tide, the sea coming in | | `sinn` | bird | a hernsew; a bird says it of itself | | `wold` | walker | the two-legs. You. | | `mell` | flock | the many | | `thrup` | stands | a standing-place, a stage-post | | `gis` | shelter | a fold of stone; the high ground | | `-eth` | rises | that thing rises, comes, grows | | `-ok` | falls | the mirror of `-eth` | | `-un` | not | alone, with nothing to hang on: *no* | | `-ar` | ? | makes a question of the phrase | | `ha-` | my | belonging to the speaker | | `ne-` | your | belonging to the one spoken to | So `ha-kraa-eth` is *my-water-rises*, and it can be read by anyone who has met `ha-`, `kraa` and `-eth` separately. That is the whole design: **meaning composes, so a fifth glyph can be reasoned about from four.** The Lingster begins the run knowing `kraa`, `sinn`, `wold` and `-eth`. The rest are earned at the posts. ## The five posts | post | call | teaches | |---|---|---| | The Reedgate | `Sinn thrup. Kraa-eth.` | `thrup` | | The Sluice | `Mell-ok. Kraa-eth.` | `mell`, `-ok` | | The Drownway | `Ha-thrup. Ne-mell-ok.` | `ha-`, `ne-` | | The Eelbank | `Ha-kraa-eth. Ne-thrup-ok.` | **nothing new** | | The Last Post | `Wold. Kraa-eth. Ha-gis ne-gis-ar?` | `gis`, `-ar` | The Eelbank is the point of the game. Every scrap of that call was earned at the three posts before it, so the reading is *deducible* rather than remembered — and a player who gets it can say why. ## The glyphs are marks, not letters Roots are pictographic — `kraa` is two running waves, `wold` is two legs under a head, `gis` is a roof over a base, `sinn` is a bill, an S-neck, a body and two legs. Affixes are single strokes: a rise, a fall, a cross, a hook, a stem with one dot or two. Every glyph record carries the mark two ways: - **`svg`** — a complete SVG document, already stroked in the phrasebook's ink. Hand it straight to an `svg` widget: `{ type = "svg", props = { svg = g.svg } }`. It carries only a `viewBox` (120 × 150), so it scales to whatever box it is dropped into. In a gloss, an **unearned** glyph's `svg` comes back dimmed — it is on the page, and it is the thing the player cannot read yet. - **`path`** — the bare path data in a 0–100 box, for restyling. It is meant to be **stroked**, never filled. `Book.glyphSvg(id, { stroke, width, size, opacity })` builds the document with your own ink. An open encounter carries `glyphs` — the marks of the call, in order, as full glyph records — and `glyphIds`, the same list as bare ids. ## The interface ```lua local Book = require("tongue.book") Book.open(stationId) -- open the beat at a post -> Encounter? Book.answer(optionId) -- give a reading -> boolean (true = right) Book.close() -- drop the open encounter Book.current() -- what is open, or nil Book.gloss(enc?) -- word by word, with `?` where a glyph is unearned Book.learned() -- the phrasebook, in the order earned Book.alphabet() -- every glyph, `known` flagged Book.glyph(id) -- one glyph Book.glyphSvg(id, o) -- one mark as a ready-to-draw SVG document Book.knows(id) -- boolean Book.encounters() -- all five, unopened, for the voice bake Book.state() -- { encounter, learned, attempts, total } Book.reset() -- back to the starting phrasebook ``` A **right** answer teaches that post's glyphs, closes the beat and raises `ANSWERED(stationId, true)`. A **wrong** one raises `ANSWERED(stationId, false)`, marks the option tried and **leaves the post open** — the bird is still in the way, and the tide has just cost you. After two wrong readings the encounter's `hint` is worth putting on screen. `Book.gloss()` is what a screen draws: one entry per word, each carrying its glyph parts, their marks, and `meaning = nil` where the player has not earned the glyph yet. That hole is the puzzle. ## What it writes `Rules.state[Rules.KEY.ENCOUNTER]` — the open station id, or nil. `Rules.state[Rules.KEY.LEARNED]` — how many glyphs are in the phrasebook.

# screens.captions The written form of every line anybody speaks. This game is voiced, and a spoken line ships with its text on screen at the same time: it is how the line survives a failed generation, a muted player and a noisy room. local Captions = require("screens.captions") Captions.say("The tide's early. It's always early.", "The Lingster") Three routes reach the same queue, so a slice that cannot require this module still gets its line on screen: 1. `Captions.say(text, who, seconds?)` — the direct call. 2. `Rules.emit("hernsew:say", text, who, seconds?)` — the signal, no require. `sound.voice` already raises this for every line it speaks **and** every line it fails to speak. 3. `Rules.state["hernsew.caption"] = { text = …, who = … }` — the blackboard. `who` is the speaker's name as it should read on screen ("The Lingster", "Skerr"). Pass `seconds` when the clip's real length is known — `audio.info(bytes).durationMs / 1000` is the right number — so the text is up for exactly as long as the voice is. Left out, it is estimated from the line's length, which is close enough for a line nobody voiced. A line arriving while another is up waits its turn rather than stamping over it; past three waiting it is dropped, because a caption nobody can read in time is not a caption. `screens.frontend` calls `Captions.tick` once a frame and draws whatever it returns.

# screens.cards The screens that stop the game: the title, the how-to-play sheet, the pause card and the two endings. Each is a whole 1080 × 1440 composition rather than a dialog dropped in the middle — the fen fills the top of the frame, the type stacks down the tall axis, and the controls are a column of full-width plates at the foot. - `C.title(v)` — the causeway at dusk with a hernsew standing on the near post, the title in Garamond, the pitch, and two stacked plates. - `C.howto(v)` — a page out of the Lingster's own field notes: aged paper, ink, a drawn mark in the margin beside each of the five rules, and a sketch of the fen at the foot. - `C.pause(v)` — the lantern, a held run, three stacked plates. - `C.ending(v)` — both endings in one shape. `v.won`, `v.yowes`. Six yowes drawn as a tally, the ones the water took as empty outlines; the bird's wing is open on a win and the picture is desaturated on a loss. There is no row of buttons in this file, because a row of buttons does not fit in 1080 and pretending otherwise is how a portrait screen breaks.