# sound.clips The fen's clip library, and the bake that makes it. Every sound the game plays that is not a spoken line is declared here and baked into a `.soundClip` under `/source/audio/`. `Clips.ref(name)` is how the rest of the game reaches one. It answers `nil` for a clip that was never baked, which is a real answer — a slice that plays a sound the library does not carry should be quiet, not broken. ## The library **The score** — `bed_fen` (the fen at rest), `bed_press` (the same drone with the tide in it), `bed_lament` (one reed pipe, for the title and both endings), `bed_crest` (played once, when the water goes over the deck). **The place** — `amb_air` (wind through the reed beds with the far birds under it), `amb_water` (brackish water against the posts, which comes up with the tide). **What the world does** — `sfx_gate`, `sfx_splash`, `sfx_creak`, `sfx_swell`. **What the score does** — `answer_right`, `answer_wrong`, `tide_notch`, `yowe_toll`, `hail_lean`, `gate_give`, `phase_won`, `phase_lost`. **The interface** — `ui_click`, `ui_hover`, `ui_back`, `ui_page`. ## How each kind is encoded, and why | kind | codec | because | |---|---|---| | **bed** — the score and the ambience | `pcm` | these loop, and an Opus clip loses its first few milliseconds on decode ([#8873]) — a step in the waveform, which is a click, every cycle | | **one-shot** — a gate, a splash, a toll | `opus` | no seam to keep, and the file is a twentieth of the size | | **transient** — a click, a page turn | `pcm` | the whole sound *is* its attack; losing five milliseconds off the front is losing the sound | Compression goes in `asset.create`'s `settings`. Creating a clip and calling `setSettings` afterwards re-encodes the PCM *through* Opus and undoes the choice ([#8872]), so it is never done that way here. Loop *points* are stored and never read ([#8874]), so the beds are authored seamless end to end and looped with the `Audio` component's own `looping` field. ## The bake `Clips.bake { only, force }` is idempotent — a clip already on disk is skipped, so a re-run costs no credit and re-encodes nothing. A bed decodes and resamples tens of megabytes of samples, so pass `only` and work through the library in batches. Beds are cut with `Synth.bestLoop` and **refused** above a seam ratio of 3, so a clicking loop cannot be written by accident. A bed is levelled by its RMS rather than its peak: a generated water take is a handful of splashes over near-silence, and peak-normalising it leaves a bed nobody can hear. `Clips.SOURCES` records what `audio_gen` was asked for, so a bake on a machine that never had `/source/generated` can regenerate the source rather than failing — and a source already on disk is never re-bought. `Clips.verify()` reads every baked payload's header back off disk. A duration of zero, one frame, or the wrong channel count is exactly the failure that otherwise ships silently, so this is the proof, not the bake's own return. [#8872]: an asset's compression settings must be set at creation [#8873]: an Opus clip loses its head on decode [#8874]: a clip's loop points are stored and never read

# 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.

# sound.script The cast, and the bake that gives every written line a voice. This game is voiced. Somebody has to own turning the written script into audio exactly once and keeping it, and that is this module. It harvests `tongue.lines` and `stage.lines` — the two slices that write words meant to be said aloud — and bakes each line into a `.soundClip` under `/source/audio/voice/`. **46 lines, 6 speakers, 197 seconds of speech, 1.96 MB.** ## The cast | Speaker | Voice | Treatment | |---|---|---| | The Lingster | a low, measured British read | none — he is a person | | Ithkeel | young, flat | +7% pitch, 7.5 Hz throat | | Haalwen | clipped, impatient | +12% pitch, 9.0 Hz throat | | Skerr | territorial | −11% pitch, 5.5 Hz throat | | Vrannock | old, slow | −7% pitch, 4.5 Hz throat | | Oonhraa | quiet, uncertain | +3% pitch, 6.5 Hz throat | Measured on the shipped clips, the six read at fundamentals of 100, 209, 214, 189, 190 and 134 Hz — the Lingster an octave under every bird. The hernsews are birds saying words, so their reads are shifted off the human centre by resampling (which moves pitch and rate together, the way a smaller throat actually does), pushed through a resonance a chest does not have, and given a flutter. Not a disguise — the phonetics still have to arrive, because the player is matching them against glyphs. ## Three rules it is built around **Generate once.** A line whose clip already exists is skipped. A hot reload, a re-run, a second agent calling `bake()` — none of them re-buy a line. **Never invent a voice id.** Every id in `CAST` is a documented premade voice, and each was proved against this service before it was used: the same text through two of them comes back as two different reads of different length. An id the service does *not* know does **not** fail — it quietly returns the default read — so a made-up id would ship six characters sharing one voice and nothing would say so. **Keep the text.** Nothing here deletes a line it could not voice. The written form is owned by the slice that wrote it and drawn by the screens slice regardless; a failed generation leaves the line printed and unvoiced, which is quiet, not lost. ## The generated bank `Script.writeBank()` writes `sound.voicebank` — a module of **literal** `asset.resolve` calls, one per baked line. Gameplay reaches a clip through that rather than by building the identity string at play time, because a computed identity is a reference the world cannot record, and a reference the world cannot record is a silent gap in the world that installs this content. Re-run the bake and the bank regenerates. Do not hand-edit it. ## Surface - `harvest()` — every line meant to be said aloud, deduped, core-first - `bake { only, limit, force, priority }` — generation is a network call per line, so pass `limit` and work in batches - `status()` — how many lines there are, how many carry a clip, which do not - `writeBank()` — regenerate `sound.voicebank` - `castOf(who)`, `clipName(id)`, `identity(id)`, `voiced(id)`

# sound.voicebank **Generated.** Written by `sound.script`.`writeBank()`; do not hand-edit. One literal `asset.resolve` per voiced line in the game. Gameplay reaches a spoken clip through this rather than by building the identity string at play time, because a computed identity is a reference the world cannot record — and a reference the world cannot record is a silent gap in the world that installs this content. `Bank.ref(lineId)` answers the clip, or nil when that line was never voiced. `Bank.ids()` lists every line this bank carries. Re-run the voice bake to regenerate it.