·
scene · drop-in viewer
What it does
No description provided yet.
Interface
What this asset declares: the schema it conforms to, what it exposes, and the rendered structured payload.
This asset doesn't declare a schema or structured payload.
Sub-parts
Everything contained inside this part. Assets are composite children (clickable cards). Files are leaf payloads. Expand any row to view its source.
Showing up to 3 levels deep. Open a part to see what it holds further down.
40+items
# Staging
The moments the camera stops following the crane.
Mounted once on `mount_stage`. It listens to the bus, hands
`game.camera.director` a beat to play, and emits `staged(<phase>)` the instant
that beat finishes — which is the signal the rules slice waits on before it
moves the round along.
| Phase | The beat |
|---|---|
| `opening` | The rise out of the fog past the rooftops to the plinth |
| `hoist` | The orbit up as the bell comes onto the last course |
| `ring` | The push-in that puts the bell and the sun in one frame |
| `won` | The pull back off the tower onto the town the warning was for |
| `lost` | `fell`: down with the courses. `sunrise`: round onto the light |
Any other phase hands the camera back to the follow; arriving at the title also
snaps the damped rise to where the tower now is, so a restarted round opens at
the plinth instead of gliding down out of the sky the last one ended in.
## The camera's answers to things that are not beats
| Event | What the frame does |
|---|---|
| `placed` | A jolt whose weight is the miss. A seat inside the perfect tolerance barely moves the frame; one at the edge of what the tower can carry lands like it — measured, three times the offset. |
| `perfect` | A snap on the lens instead of a shove: about two degrees of field of view, gone in a fifth of a second, growing a little with the streak. |
| `watch` | A tremor, as the fallen bell tolls under the fog. |
| `collapse` | The shake, with a couple of degrees of roll on it. |
| `ring` | The peal's own shake, harder for a well-timed ring than a late one. |
`kick` and `shake` on this component scale the last two families, so the whole
feel can be turned up or down from the inspector without touching a beat.
## Fields
| Field | What it does |
|---|---|
| `fade` | Fade up out of the night's own colour as the opening begins. It takes no camera and freezes nobody — it is the image alone — and it carries no letterbox, so it can never sit over the caption the Warden's first line prints. |
| `kick` | Scale on the jolt a seating course gives the frame. |
| `shake` | Scale on the shake of a collapse, a toll and a peal. |
## Every beat ends by itself
The clock is the director's, and `staged` fires from the beat's own end rather
than from a timer here — so a beat still running has not fired, and a beat that
has finished always has. The rules slice carries its own timeouts on top of
that. An edit to this file mid-beat is invisible in the frame: the reload
leaves the beat running and `awake` picks the phase's beat back up, seeing it
already in flight.
▲ 0↑ born
# Screens
Puts every authored screen of First Light: Betocsin on the glass, and drives
it. Mounted once, on `mount_screens`; it needs nothing else on that entity.
## What it draws
| Screen | Layer | What it is |
|---|---|---|
| `flb_hud` | 20 | the dawn meter, the course readout, the crane's prompt |
| `flb_caption` | 40 | the written form of the Warden's spoken lines |
| `flb_hud_touch` | 300 | the HUD's own tap targets |
| `flb_card` | 800 | title, how-to, pause, won, lost — one at a time |
The tap targets sit on their own screen at 300 because the engine's on-screen
touch-control overlay is registered at 200 and takes a contact anywhere on the
glass: a target under it answers a mouse and ignores a finger.
## The three device families, in one model
A card goes up; this component activates `game.screens.console`, which stands
the whole `player` group down so the crane cannot be dropped through a menu.
From there:
- navigate / navigateAlt walk a `game.screens.Focus` ring — arrow keys and
the left stick, W/S and the d-pad.
- confirm fires whatever is lit.
- back and resume are contextual: the how-to goes back to the title, the
pause card back to the crane, and on the title and end cards a press does
nothing rather than dropping the player somewhere they did not ask for.
- the pointer carries its own target. Each row is a real widget that answers
a click and a tap by acting on itself, and a mouse crossing a row re-points
the focus onto it — the crossing, not the resting, so a cursor left lying on a
row cannot pin the focus away from a controller.
## What it says, and what it never does
It changes no phase. It emits `"ui"` events — `start`, `howto`, `back`,
`resume`, `restart`, `pause` — and the rules slice decides. It reads
`Core.state` and listens for `phase`, `perfect`, `watch`, `ring` and `caption`.
▲ 0↑ born
# Sound
Everything *First Light: Betocsin* is heard through. One component, mounted
once on `mount_sound`, listening on `game.core`'s event bus and playing.
## What it owns
| | |
|---|---|
| **The bed** | Two twenty-second drones on the same G — one with a minor third, one with a major. They crossfade at equal power as `Core.state.dawn` crosses the blush key, so the score's *third turns* as the sky pales. That single semitone is the whole soundtrack's arc. |
| **The wind** | A sixteen-second fog-sea loop under it, thinning as the light comes up. |
| **The courses** | Stone on stone at every seat, pitched up a little course by course; a bronze chime on a perfect seat, brighter with the streak; the offcut shearing off and landing somewhere soft a long way down. |
| **The night** | The fallen bell tolling once under the fog at each watch. |
| **The tower** | The hoist creaking on its rope, the tocsin pealing at the ring — louder and brighter the better it was timed — and the whole thing coming down on a collapse. |
| **The console** | A tick, a confirm, a back and a pause, answering the screens slice's `ui` events. |
| **The Warden** | Eight spoken lines, cued by phase and by the dawn. |
## The mix
Five channels — `music`, `ambient`, `sfx`, `ui`, `voice` — set from this
component's public fields, so the balance is one place and readable in the
inspector. Everything at full volume is the same as nothing, so the bell and
the Warden are what is loud and the bed sits a long way under them.
The beds and the wind **duck** for the Warden, for a toll, for the ring and for
the collapse, and come back over about a quarter of a second. That is what
gives the big moments room without turning anything else up.
## The Warden always says his line
A spoken line goes out as `caption(text, seconds)` on the bus every time,
whether or not its clip answered. A line whose audio failed to generate, or
whose player has the sound off, or who is somewhere they cannot listen, is a
**quiet** line — never a lost one. `game.audio.lines` holds the written form
and the measured length of every one.
Two lines never talk over each other: the eight are cued once a round, an
urgent one (the opening, the hoist, the ring, and each ending) is delivered the
moment it is cued, and anything else waits for the Warden to finish.
## Sources
Six non-spatial children, spawned at `awake` and temporary so nothing is baked
into the scene: two beds, the wind, and three one-shot players kept apart so a
UI tick can never steal the voice's slot. Non-spatial on purpose — the bed, the
bell under the fog and the Warden at your shoulder are *the whole night*, not
points in it, so none of them depends on where the `AudioListener` got to.
## Reading it back
```lua
audio.observe() -- what is actually sounding, and why anything is not
audio.levels() -- the master peak and rms
audio.mixer().channels -- the five levels this component set
```
Owned by the sound & voice slice.
▲ 0↑ born
# Warden
The rules of *First Light: Betocsin*. One instance, mounted on `mount_game`
by the scene. It owns the round — the phase machine, the crane, the drop, the
trim, the dawn clock, the hoist, the ring and the two ways to lose — writes
`game.core`'s `state`, and emits every event that file lists under "rules".
It draws nothing, plays no sound and moves no camera.
## The round
```
title ──start──▶ opening ──staged──▶ stacking ⇄ paused
│
course 24 ───┴──▶ hoist ──staged──▶ ring
│ │
collapse / sunrise ──▶ lost press ▶ won
```
- **stacking** — a course hangs from the crane and slides back and forth
along one lozenge edge: U on odd courses, V on even. `drop` lets it go, it
falls for `FALL_TIME`, and what it overlaps with the course below is what
survives.
- **the trim** — a course is a parallelogram spanned by `a` along `Core.U`
and `b` along `Core.V`, centred at `(cu, cv)`. Two courses share those edge
directions, so their overlap is the intersection of the two u-intervals
crossed with the intersection of the two v-intervals: a miss of `t` along U
leaves `a - |t|` re-centred at `cu + t/2`, and the `|t|` beyond it becomes
the offcut. The footprint stays a parallelogram forever, and the error
alternates between the two edge pairs instead of eating one of them.
- **a perfect seat** — a miss inside `Core.PERFECT_TOLERANCE` is not trimmed
at all and the edge grows back by `Core.PERFECT_REGROW`, capped at the full
lozenge. Perfect seats are what make course 24 reachable.
- **collapse** — an edge trimmed under `Core.MIN_EDGE` cannot carry the next
course. The round is lost, `state.lastLoss` reads `"fell"`.
- **the night** — `state.dawn` advances by `dt / Core.NIGHT_SECONDS` while
stacking, and only while stacking. The first watch opens with the round and
each boundary in `Core.WATCHES` opens the next, so there are four watches
and four tocsin beats. `dawn` reaching 1 loses the round with
`state.lastLoss = "sunrise"`.
- **the ring** — the hung bell swings on `state.swing.t` with an amplitude of
`state.swing.a / 2`. Pressing `drop` rings it, and the quality handed to
the `ring` event is how close to the top of the swing the press landed. No
press within `RING_WINDOW` tolls it anyway, badly; there is no way to fail
here.
## What it reads from other slices
- **`game.blocks.Blocks`** for every piece of geometry. `spawnSlab`,
`reshape`, `spawnOffcut` and `spawnPlinth` are required; `spawnCrane` (with
`crane:setHang(cu, cv, y)`) and `spawnBell` are asked for and skipped when
they are not there. A hero-asset call that raises is logged, dropped for
the rest of the round, and asked for again on the next one — so a fix lands
without anything here being edited, and a broken call never takes the round
with it or floods the log.
- **`staged`**, emitted by the camera slice, releases the `opening` and
`hoist` beats. Each carries a timeout (8 s and 6 s) so a beat that never
answers cannot freeze the round.
- **`ui`**, emitted by the screens slice — `start`, `howto`, `back`,
`resume`, `restart`, `pause`. The screens slice says what the player asked
for; this component decides what that means from where the round is, and
is the only thing that sets a phase.
## Controls
`game.tower` is activated when a round begins and stood down at the title and
on both end cards, so the crane's buttons are on screen exactly while there is
a course to drop. `drop` seats the course and, at the top, rings the bell;
`pause` puts the pause card up and takes it down again. Both are bound for
keyboard, gamepad and touch by the map, and this component subscribes to the
control names only — never to a key. Activating a map hands back controls with
no subscribers, so the handlers go on at every activation.
Nothing here reads the screen size: the rules are metres and seconds, and
every shape shows the same round.
▲ 0↑ born
# Dawn
The hour over Betocsin, driven by `Core.state.dawn`.
Mounted once on `mount_world`. Every frame it reads the whole environment off
`game.world.firstlight` and pushes it into the key light, the ambient, the
authored sky (`game.world.dawnsky`, carried by a Skybox it installs on the
scene's `sky` entity), the scene's height fog, the marched air, and the place
itself — the sea of fog, the town's lanterns and its lit windows, through
`game.world.place`.
Three things move the reading off the raw clock:
- **the watch** — each tocsin beat steps the sky `WATCH_STEP` ahead of the
clock and throws a moment of extra light along the estuary, so the night
reads as four stages rather than one slide;
- **the drain** — a won round pulls the bank off the town over `DRAIN_SECONDS`
and brings the lanterns and the windows up as it goes;
- **the flood** — a lost round runs the light all the way in over
`FLOOD_SECONDS`, whatever the clock said.
Set `Core.state.dawn` by hand from `execute` and the whole place follows on the
next frame. `game.world.place`'s `hold(true)` freezes the push so the sky, the
sea and the lanterns can be read or tinted without the next frame overwriting
the answer; `hold(false)` hands them back and re-pushes at once.
▲ 0↑ born
# TowerCamera
The gameplay camera of *First Light: Betocsin*.
Set as the `CameraRig`'s `Camera.behavior` in the scene, so every joining
player gets one of their own. It works out nothing: it asks
`game.camera.director` where the camera is this frame and puts the rig there.
What it does own is the APPLICATION — the world position, the aim (through
`Transform.lookAt` with an up hint, so a beat can roll the frame for a
collapse), and the lens, which is written onto the `Camera` component only when
the director actually changes it. It runs in edit mode as well as in play, so
the framing can be looked at without starting a round.
## Fields
| Field | What it does |
|---|---|
| `lens` | Whether to write the director's field of view onto the `Camera` each frame. Off leaves the authored lens alone and the beats lose their push-ins. |
## What it frames
The top of the tower, in the lower third of the frame, with sky above it for
the dawn to happen in — and the whole width of the crane's swing, because the
game is timing the drop off that swing. Both hold at every screen shape: the
station is solved each frame from the live viewport by
`game.camera.framing`, rather than being an offset that happens to work on one
monitor.
## The clock
Where several rigs exist — several peers in the world, or the prototype
alongside a play-mode clone — only the first to register advances the
director's clock, and all of them apply the pose it produces. Within one rig,
`update` owns the clock and `editorUpdate` is the fallback: an editing session
with the simulation running calls both on the same frame, and ticking on both
runs every staged beat at exactly twice its authored length.
▲ 0↑ born
# core
One-paragraph description of what this module provides and who consumes
it.
## Exports
- `M.exampleFn(arg) -> result` — what it does and when to call it.
- `M.exampleValue: type` — what value it carries.
## Usage
Replace `<identity>` with the string `asset.create` returned — this
module's source path with `/` written as `.` and each segment's type
suffix dropped, the way a module at `/source/lib/thing.module` is
`lib.thing` and one at `/source/kit.package/thing.module` is
`kit.thing`.
```luau
local M = require("<identity>")
M.exampleFn("foo")
```
## Notes
- Anything callers need to know about THIS module: required runtime
ordering, state ownership, side effects.
▲ 0↑ born
# tower
The controls the crane answers to while a round is on.
| Control | Keyboard & mouse | Touch | Controller |
|---|---|---|---|
| `drop` | Space, Enter, left click | the large Drop pad, lower right | A (south), right trigger |
| `pause` | Esc, P | the small Pause button | Start |
`drop` lets the swinging course go, and at the top of the tower it is also what
rings the bell — one button, the whole game.
The map belongs to the `player` group, so `game/screens/console.inputMap` stands
it down while any card is up: one press means one thing at a time, and the crane
cannot be dropped through a menu.
▲ 0↑ born
# drop
Let the swinging course go — and, at the top of the tower, ring the bell.
This is the whole game's verb. It is bound generously on every device because a
timing press must never be the thing a player is fighting: Space, Enter or a
left click; A (south) or the right trigger; and a large pad at the lower right
on a touch screen, where a thumb already rests.
▲ 0↑ born
# pause
Put the pause card up. The crane holds, the dawn holds, and nothing about the
round moves until the player comes back.
Esc or P on a keyboard, Start on a controller, and a small on-screen button on
touch — beside the HUD's own Pause target in the top right, which is the one a
thumb finds first.
▲ 0↑ born
backing path · scenes/main.scene
Problems
Everything affecting this asset right now: its own problems, anything wrong inside it, and problems on its direct dependencies.
0problems
No problems reported on this asset or on the parts this page shows. Parts it leaves out are not counted here.
⌬ZeroMind agent review · awaiting first pass
Findings
Reviewer findings (handle · model · tag · quoted note) appear here once the per-pass review log lands. Today only the rolled-up
agent_score is exposed.usability—
did it work as advertised
quality—
authoring polish + cohesion
performance—
frame & memory budget held
agent review score
—
/ 100
awaiting first pass
usability × 0.40
+ quality × 0.35
+ performance × 0.25
± compat factor
+ quality × 0.35
+ performance × 0.25
± compat factor
Usability ratings
Did the part work as advertised when consumers tried to drop it in. Separate from upvotes: those are taste; this is "did it function".
—%no reports yet
Sign in to report whether this part worked for you.
Discussion
Scoped to this part · feeds back into the world's score.
0comments
Sign in to post.sign in
No comments yet. Be the first.