# game.rules.exposure — the physics of the plate What a betafite crystal does to a photographic plate, in arithmetic. The `Game` component runs it every tick; the board draws what it writes. ```luau local Exposure = require("game.rules.exposure") ``` ## The kernel A crystal deposits `Core.EXPOSURE.rate` per second on its own cell, times a weight that falls with the SQUARE of the distance in cells: ``` w(d) = 0.25 ^ (d*d) while d <= Core.EXPOSURE.radius, else 0 ``` Which makes an exposure TIME into a SHAPE — the thing the whole game is played on: | distance | weight | per second | past `clearMax` | reaches `darkAt` | |---|---|---|---|---| | 0 — the crystal's own cell | 1.0000 | 0.340 | 1.0 s | 2.9 s | | 1 — a side | 0.2500 | 0.085 | 4.1 s | 11.8 s | | 1.41 — a diagonal | 0.0625 | 0.021 | 16.4 s | 47.1 s | | 2 | 0.0039 | 0.0013 | 264 s | 754 s | | beyond 2.2 | 0 | — | never | never | - **~3 s → a dot.** The crystal's own cell alone; its four sides sit at 0.26, under `clearMax`, so nothing around it is spoiled. - **~12 s → a plus.** The cell and its four sides. The diagonals sit at 0.26, still clear. This is the workhorse mark. - **~47 s → a block.** The full 3x3, and expensive in both dose and night. Nothing is spoiled by a single well-timed mark. A frisket is what you reach for when two marks stand close enough that their skirts ADD past `clearMax`, or when a plus has an arm you did not want — which is what makes the masks a puzzle rather than a tax. ## The surface | call | what it does | |---|---| | `newCells()` | a fresh plate: 70 cells, nothing exposed | | `applyTarget(cells, target)` | write a plate's `#`/`.` target into the cells | | `applyMasks(cells, pieces)` | recompute which cells stand under a frisket | | `deposit(cells, pieces, dt)` | run the crystals for `dt` seconds; returns how many stood | | `crystalCount(pieces)` | how many crystals are out — what doses the apprentice | | `score(cells)` | share of cells reading right, 0..1 | | `audit(cells)` | the same count with the missed and spoiled cells named | | `render(cells)` | ten strings: `#` dark, `:` spoiled, `-` masked, `.` clear | | `weight(dc, dr)` / `kernel()` | the kernel itself, for anything that wants to draw it | ## Simulation A plate is authored by writing down how it is SOLVED and reading the target off the result, so no plate can ship that cannot be played to 100%. ```luau local sim = Exposure.simulate(plate.target, plate.solution) --> { cells, match, audit, crystalSeconds, seconds, peakCrystals } Exposure.simulateUnmasked(plate.target, plate.solution) -- the same crystals, no masks Exposure.trayDemand(plate.solution) -- what the tray has to hold ``` A solution is a list of phases; each states the whole board — the friskets standing and the crystals lying — and how many seconds it is held. Between phases the player lifts and lays; the glass keeps what it has.

# game.rules.plates — the five plates of Lucina Five nights, five signals. A plate is a name, a caption, the target the signal has to carry, what the lead case holds, and how long the dawn takes. ```luau local Plates = require("game.rules.plates") Plates.count --> 5 Plates.get(3) --> the third plate Plates.darkCells(plate) --> how many cells must go dark ``` | # | plate | what it teaches | case | tray | dawn | |---|---|---|---|---|---| | 1 | The Long Dash | a plus is a mark, a mask carves it | 1 crystal | 2 bars | 80 s | | 2 | L for Lucina | exposure TIME is the shape — a dot is not a plus | 1 crystal | 2 discs | 90 s | | 3 | The Reef Mark | mask what must survive, then expose around it | 2 crystals | 5 discs | 85 s | | 4 | Two Ships | two marks close together share a skirt | 2 crystals | 4 bars | 75 s | | 5 | The Rose of Lucina | all of it, on a dose | 3 crystals | 4 discs | 70 s | ## Every target was read off a solution Each plate carries its own `solution` — the phases a player lays to expose it perfectly. That is not documentation. The solution was written FIRST, run through `game.rules.exposure`, and whatever the glass held became the target. So a plate that cannot be played to a full 100% cannot ship. ```luau local checks, ok = Plates.verify() ``` `verify` re-derives every claim this file makes from the live numbers in `Core.EXPOSURE` and `Core.DOSE`: | field | the claim | |---|---| | `solvable` | the authored solution leaves not one cell wrong | | `frisketsEarned` | the SAME crystals without the friskets FAIL — the masks are the puzzle | | `trayFits` | the tray holds what the solution stands at once | | `doseFits` | the solution costs less than a full dose | | `timeFits` | its exposure time fits inside the night, before any handling | Run it after retuning anything in `Core.EXPOSURE` or `Core.DOSE` — a change to the rate, the radius, the falloff or `passMatch` moves every plate at once, and this is what says whether they all still stand. ## A solution phase ```luau { friskets = { { shape = "bar", col = 3, row = 4, rot = 0 } }, crystals = { { 4, 4 } }, seconds = 12 } ``` The whole board, and how long it is held. Between phases the player lifts and lays; the glass keeps whatever exposure it already has.

# game.core The one table every slice of *First Light: Lucina* reads. ```luau local Core = require("game.core") ``` | What | Where | |---|---| | The plate grid, cell ↔ world conversions | `Core.GRID`, `Core.PLATE`, `Core.cellToWorld`, `Core.worldToCell`, `Core.cellIndex` | | The five piece shapes and the placement rules | `Core.SHAPES`, `Core.SHAPE_ORDER`, `Core.footprint`, `Core.canPlace`, `Core.pieceAt` | | The exposure and dose numbers | `Core.EXPOSURE`, `Core.DOSE` | | The phases and the level shape | `Core.PHASES`, `Core.LEVEL_COUNT`, the `Level` type | | The live game state, held across hot reloads | `Core.state` — the `State` type says which slice writes each field | | The signal bus | `Core.on(name, fn)`, `Core.off`, `Core.emit(name, ...)` — the signal list and its senders are in the source | | The three shorthands | `Core.request(action)`, `Core.sfx(name, opts?)`, `Core.say(lineId)` | | Which component mounts where | `Core.MOUNTS`, `Core.mount()` — the scene entrypoint calls it on every load | Subscribe in `awake`, subscribe again from `onModuleReload` (a duplicate is dropped), release in `onDestroy`. The rules of the game are stated in `design/spec.md`; this module carries the numbers and the shapes they share.