·
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.
62+items
# fl
<!-- 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.
▲ 0↑ born
# Tawpy
The goura the player is. Sits on the `GouraPlayer` PlayerPrototype's `body`, so
every peer that joins the world gets one and each reads only its own controls
(`entity:isLocal()`).
## What she does
A crowned pigeon is heavy and a poor flier, and she moves like it.
| State | What it is |
|---|---|
| `idle` | standing |
| `walk` | a deliberate 2.2 m/s, reached and lost over about a fifth of a second |
| `gather` | holding Flurry roots her and builds the charge, 0.3 → 1 over `gatherTime`; she can still swing round slowly to aim |
| `flurry` | released: a hop off the floor to 0.85 m at up to 12.5 m/s, committed to the heading she launched on, veering and beating sideways as she goes |
| `boom` | the answer to the flock; roots her for 1.15 s wherever she stands |
| `startled` | the eagle's gaze found her; frozen for 0.9 s, charge lost |
| `caught` | taken |
| `roosted` | home |
The **stagger** off a landing is a ninth reading and not a ninth state: `state()`
reports `walk` (she is on the floor and still moving), `phase()` reports
`stumble`, and for about half a second she cannot boom, gather or steer while
her speed decays and her heading wobbles. That is the price of the flurry, and
it is why a flurry across open floor is a gamble rather than a free sprint —
8.6 m in about 1.8 s door to door against 2.2 m/s of walking, at the cost of
being unable to answer or turn for the whole of it.
A **flurry into the trunks** at the lane's edge ends the flight where it hit.
A **boom pressed while she is committed** (mid-flurry, mid-stagger) is
remembered for 0.4 s and fires the moment she can act, so a landing on the beat
still answers the flock.
## Tuning
The feel numbers are the `FEEL` table at the top of `init.luau`, not public
fields. A public field is serialised with the entity, so a baked scene keeps
whatever default it was written against and that copy silently wins over
anything changed in the component — which is exactly what happened to this one.
`state`, `subState`, `power` and `speed` stay public because the camera and the
art read them off the component.
## The surface
`FL.provide("player", …)` — the spec's shape, plus four additive readings the
art and the camera can use:
| Call | |
|---|---|
| `position()` | `{ x, y, z }`; `y` lifts during a flurry |
| `heading()` | unit `{ x, z }` on the floor |
| `state()` | one of the eight above |
| `phase()` | the same, plus `stumble` |
| `speed()` | metres per second this frame |
| `power()` | gathered charge, 0..1 |
| `airborne()` | feet off the floor |
| `stumbling()` | staggering off a landing |
| `entity()` | her entity |
| `startle()` | the gaze found her |
| `catch()` | the eagle took her; emits `caught` |
| `reset()` | back to the lane start for a new run |
## Events emitted
`boom`, `flurry` (`{ position, power }`), `step` (every 0.62 m of walking),
`roost`, `caught`.
## Controls
`goura.inputMap` beside this file — move, flurry, boom, pause, each bound on
keyboard+mouse, gamepad and touch. The pause control toggles `playing ⇄ paused`
from the same press on every device.
▲ 0↑ born
# Soundscape
The sound of the forest floor. Mounted once, on `mount_sound`.
Runs the ambience bed, the music deck, the mix, the shared one-shot library
and the narrator, and publishes the `sound` surface every other slice reaches
sound through.
It only ever **resolves** clips. Every sound was baked at author time by
`game.sound.bake` into `clips/`; this component synthesises nothing and calls
no generation service, so a player's machine does no DSP and reaches no
network.
## What it runs
- **Two beds at once.** `fl_bed_night` and `fl_bed_dawn` both play for the
whole session; only their levels move, mixed against `FL.light()`, so the
insects thin into the dawn chorus without either stream re-cueing.
- **One music deck.** `fl_title` under the menus and the opening beat,
`fl_score` from the moment the light passes `scoreLight`. The level goes to
nothing before the clip is swapped and comes back up on the new one.
- **The one-shot library**, wired to the `FL` event bus: `boom`, `call`,
`answered`, `failance`, `flurry`, `step`, `seen`, `caught`, `roost`. A slice
that emits one of those gets its sound without asking. Two hosts serve them
— one flat, one spatial for a shot that carries a world position.
- **Four mixer channels** — `ambient`, `music`, `sfx`, `voice` — held at
deliberately unequal levels, with a duck under every spoken line.
- **The narrator**, from `game.sound.lines`, with the spoken words drawn as a
caption at the foot of the frame, laid out from the live `ui.screenSize()`.
## The surface it publishes — `FL.get("sound")`
`play(name, opts?)` · `duck(seconds, depth?)` · `say(lineId) -> text` ·
`text(lineId)` · `speaking()` · `captions(on)` · `mix()`
`opts` on `play` takes `volume`, `pitch` and `position`. It also emits
`narration` on the `FL` bus as `{ id, text, seconds }`, so a slice that would
rather draw the spoken words itself calls `captions(false)` and listens.
## Fields
`ambientVolume`, `musicVolume`, `sfxVolume`, `voiceVolume` set the four
channel levels; `scoreLight` is the light reading at which the score enters;
`drawCaptions` turns the built-in caption off for a slice taking it over.
## Consumed by
Everything. `screens` for its interface answers, `tawpy`, `dawn`, `hero` and
`staging` through the events they already emit.
▲ 0↑ born
# Screens
Puts every authored screen of *First Light: Goura* on the glass and drives it.
Mounted once, on `mount_screens`; it needs nothing else on that entity.
## What it draws
| Screen | Layer | Up when |
|---|---|---|
| `fl_card` | 800 | The phase is `title`, `howto`, `paused`, `won` or `lost`. |
| `fl_hud` | 20 | The phase is `playing` or `paused` — the light, the lane, the six calls, the three failances. |
| `fl_top` | 24 | A call's answer window is open, or the narrator has a line on screen. |
| `fl_alert` | 40 | For a beat after `seen`, `failance` or `caught`. |
The trees come from `game.screens.flscr`, which is pure. This component holds
the state, the focus ring and the input.
## Reachable from every device
- **Pointer and finger** — every row carries `onClick`, so a click or a tap
fires it, and the pointer moves the focus ring as it crosses a row, so what
is lit is what a click will do.
- **Keyboard and pad** — `console.inputMap` is activated the instant a card goes
up and released the instant the last one comes down. `navigate` walks the ring
(arrow keys, left stick), `confirm` fires the lit row (Enter / Space, south),
`back` leaves the card (Escape / Backspace, east), `resume` puts a paused run
back on the floor (Escape, start). The map stands the goura's own scheme and
the engine's default player scheme down while it is live, so the floor cannot
be walked underneath an open card.
- **Touch** — the console draws exactly one on-screen button, a small `Confirm`
in the far corner, which acts on the lit row. Everything else a finger does,
it does by touching the row it means.
## The transitions it owns
`title → howto`, `title → intro`, `howto → title`, `paused → playing` (through
`FL.resume`), `won | lost → intro` (through `rules.restart`), and any card
`→ title`. `intro → playing` belongs to the staging slice; `playing → won|lost`
to the rules.
## What it reads
`FL.get("rules").ledger()` for the run's figures — including `window` and
`remaining` when the rules slice reports them, so the countdown agrees with the
run rather than with a constant — `FL.get("dawn").light()` for the meter,
`FL.get("player").position()` for how far up the lane she is, and the `call`,
`answered`, `failance`, `seen` and `caught` events for the marks and the pulse.
## Narration
Every line this game speaks also arrives as text, and it is drawn here.
The sound slice speaks a line through `say(id)` and announces it on the
`narration` event as `{ id, text, seconds }`; its own surface offers
`captions(false)` for a slice that would rather draw the words itself, and this
component takes that offer in `awake` and hands it back in `onDestroy`. So one
caption exists, in the type and the palette the rest of the screens use, and it
sits directly under the call band rather than in a second place. A card carries
its own words and covers that band, so nothing is drawn up there while one is
open — the title card puts the opening line on the page itself, taken from
`sound.text("open")` so the page and the voice say the same thing.
With no sound slice at all, the written line still goes up from here: a line is
never lost for want of a voice.
The ids are the sound slice's own — `open`, `begin`, `first_call`,
`first_failance`, `first_seen`, `won`, `lost_caught`, `lost_failance`,
`lost_light`. `FL.get("sound").play(name)` is used for `ui_move`, `ui_confirm`
and `ui_back`.
## Fields
| Field | What it is |
|---|---|
| `inputMap` | The scheme a card is driven by. Live exactly while a card is up. |
| `alertSeconds` | Seconds the pulse stays on the frame. |
| `subtitleSeconds` | Seconds a narrated line's text stays on screen. |
| `card` | Which card is up, or `none`. Live output. |
| `focus` | The id of the row the focus ring is on. Live output. |
▲ 0↑ born
# FloorCam
The one camera of *First Light: Goura*, and the four moments it takes itself
away from Tawpy for. It lives on the `GouraPlayer` prototype's `CameraRig`
beside the `Camera` component, so every joining user sees through their own;
only the peer that owns the rig runs the beats, the opening and the floor
effects.
## The follow
`game.staging.follow` stands the camera `standBack` metres behind her and
`standHeight` above, and then **solves the aim so she lands at
`subjectScreenY` down the frame under the live field of view**. That is why the
framing holds on a 3:4 phone, a laptop and a television rather than only on the
shape it was authored at: a wider screen gets a shorter vertical fov, and a
shorter fov with a fixed aim point would slide her off the bottom, so the
solver simply tilts further down instead.
Measured, at `subjectScreenY = 0.72`: 3:4 puts the subject at 0.718 of the
frame height, 16:9 at 0.719.
Sideways the rig chases at `lateralChase` and up the lane at `chase` — the
difference is what makes a side-step read as movement rather than as a locked
rig. Three springs (a dolly, a lift and a lens) take the events: the gather
eases the camera in and tightens the lens, the flurry throws it back and opens
up, the boom leans in, the sighting snaps tight. A hand-held drift proportional
to her speed keeps the picture from being mechanically still.
Over the last fifth of the lane (`roostFrom`) the rig climbs `roostLift` and
closes `roostClose`, which keeps it out of the roost tree's buttresses. Her
place in the frame does not move — the aim is solved against the pose the rig
actually ends up in.
## The beats
| Phase / event | Beat |
|---|---|
| entering `intro` | the opening cutscene (`game.staging.beats`), which sets `playing` when it ends however it ended |
| first `seen` of a run | a 1.7 s drop to the floor behind her, looking into the sweep, with a heartbeat |
| entering `won` | a 7 s rise to the crown |
| entering `lost` | a 5.4 s climb to a wide shot of the floor the light has filled |
Each fires **once per run**: the guards reset on entering `intro`, and on
entering `playing` from anywhere but `paused`. A beat outranks an override, and
an override outranks the follow.
The opening cannot hang the game. If it has not handed the run back within
`Beats.DURATION.opening + 6` seconds, `update` starts the run anyway and says
so in the log.
## Skipping the opening
`staging.inputMap` is activated for the length of the opening and stood down
the moment it ends. It carries one control, `skip`, bound on all three device
classes — Space / Enter / left mouse, pad **south** or **start**, and an
on-screen **Skip** button. While it is live it suppresses `player` and `goura`,
so there is no flurry button under the letterbox.
Verified: the opening is skippable from touch (`inputSim tapButton "Skip"`),
from a keyboard (`inputSim key Space`) and from a pad (`inputSim padPress
south`); in each case `cutscene.status().playing` goes false and the phase lands
on `playing`. Escape is deliberately not bound: it is the pause control.
## The surface it publishes
`FL.provide("camera", …)`
| Call | What it does |
|---|---|
| `override(pose \| nil)` | Hold the camera at `{ position = {x,y,z}, lookAt = {x,y,z} }`, optionally with `fov`, `smoothing` and `snap = true`. `nil` releases it. |
| `position()` | Where the follow's own solved rig is. |
| `beat()` | Which beat holds the camera: `none`, `opening`, `seen`, `won`, `lost`. |
## Fields
`standHeight` · `standBack` · `aheadMetres` · `subjectScreenY` · `chase` ·
`lateralChase` · `lateralLead` · `subjectY` · `sway` · `roostFrom` ·
`roostLift` · `roostClose` · `crownHeight` · `crownBeyond` · `skipMap` ·
`beat` (live output).
`crownHeight` and `crownBeyond` locate the roost tree's head for the opening and
the win. The component prefers `FL.get("roost").crown()` where the floor slice
publishes one and falls back to these fields; **a published `roost` surface
would be the better contract**, because the landmark those two shots are aimed
at belongs to the floor slice and moves when it rebuilds.
▲ 0↑ born
# Eagle
<!-- zero:scaffolded-readme -->
<!-- Replace the line below with what this component provides and who
consumes it, then delete both comment lines. -->
TODO: describe this component.
▲ 0↑ born
# Dawn
<!-- zero:scaffolded-readme -->
<!-- Replace the line below with what this component provides and who
consumes it, then delete both comment lines. -->
TODO: describe this component.
▲ 0↑ born
# GouraArt
Tawpy's body as a thing on screen. Lives on the PlayerPrototype's `body` beside
`Tawpy`, and hangs the bird off that entity, so the controller moves her and the
art rides along.
The bird itself is `game.hero.gouraart`. This component's whole job is to keep
one rig alive on this entity, tell it which pose she is in, and drive its clock
once a frame.
## Where the pose comes from
Her state is read from the `Tawpy` component on this same entity when there is
one, so a peer's own bird poses from its own run rather than from whoever
happens to be local. The `player` surface answers when there is not. The eight
state names the controller uses are the eight pose names the rig knows, so the
mapping is the identity.
`boom` and `flurry` on the event bus each knock her out of the pose she is
easing into, so the beat lands before the pose has finished arriving.
## Fields
- `crownHeight` — metres from her feet to the top of the crest. The rig scales
to it.
- `pose` — live output: the pose the rig is holding, which is what a test reads
back.
## Notes
- The rig is re-derived from the world every frame: a hot reload of the art
module, a component reload or an edit/play flip each leave the handle this
component holds pointing at a rig nothing poses, and `gouraart.owns` is the
question that catches it.
- Paused in the editor she still stands there breathing, so the scene can be
composed against the real bird rather than against nothing.
▲ 0↑ born
# Floor
The forest floor of *First Light: Goura* — the place the run crosses. Mounted
once, on `mount_floor`.
It lays out 120 metres of New Guinea rainforest floor as a lane along world -Z
and builds every piece of it at runtime, under one root entity (`floor_root`)
it owns and despawns.
## What it builds
| Piece | What it is |
|---|---|
| ground | eleven chunks of grid displaced by a height field, painted per-vertex: darker in the cover pools, warmer down the worn trail, buried in shadow where it is low. The lane lies in a shallow hollow; the floor climbs away to the sides and, past the roost, into the ridge the flock's calls come down from. |
| gate trunks | sparse buttressed trunks close in on alternating sides, entering frame at its edges as she passes |
| trunk ranks | the forest behind them, in three bands per side, standing only outside a funnel that opens toward the roost — an evenly dense rainforest is a wall at twenty metres and the destination would never be seen |
| canopy | masses of foliage the trunks disappear into, with a corridor of open sky left over the lane. This is why the floor is dark and why the first light arrives down one strip of sky. |
| cover pools | a fallen log, a buttress root arch, or a bank of fern beds — with the floor darkened under it, moss on the rise beside it, and litter drifted against it |
| undergrowth | ferns, saplings, moss and litter on the banks, pushed out of the lane so it stays walkable |
| lane drift | leaf fall down the lane itself, which is the floor she actually crosses |
| the roost tree | a 62 m buttressed trunk, ten root arches, nine limbs carrying a crown of sixty-four foliage masses between 34 and 66 metres up |
## What it publishes
`FL.provide("cover", { spots })` — `{ x, z, r }` per pool. The pools are the
positions the objects were placed at, so what the eagle reads and what the
player sees are one thing. The dawn slice shrinks them as the light rises.
## The crown's gold
The roost crown catches the first light before the floor does. Each of the 64
crown masses carries its own exposure — how open it is to a low sun from
screen-right and from above — and the component writes colour and strength into
**instance-data lane 2** as `dawn.light()` rises. `fl_frond` and `fl_surface`
both read that lane as emissive, so one material serves every mass and each
catches the light at its own strength. Nothing else in the scene is touched.
## How it is built
Geometry comes from `game.floor.flora` as a small set of PROTOTYPE meshes, each
worn by many entities. What keeps two copies of one trunk from being the same
trunk is that `fl_surface` and `fl_frond` read their noise in WORLD space: the
same mesh standing somewhere else shades differently, for free.
Everything is spawned `temporary = true` under `floor_root`, the root is
re-derived from the world every frame (an edit/play flip can restore the
component without the entities it built), and the prototype GPU meshes are
released on rebuild and on destroy.
## Fields
| Field | Default | Means |
|---|---|---|
| `coverSpacing` | 9.0 | metres along the lane between cover pools |
| `coverRadius` | 2.8 | metres a cover pool reaches in the dark |
| `trunkSpacing` | 7.0 | metres between the rows of trunks closing the lane's sides |
| `density` | 1.0 | multiplier on how much scattered undergrowth is placed |
| `goldStrength` | 1.35 | how brightly the roost crown catches the first light |
## Materials
`mat_ground`, `mat_bark`, `mat_deadwood`, `mat_moss` on `fl_surface`;
`mat_fern`, `mat_litter`, `mat_canopy` on `fl_frond`. All seven live beside
this component.
▲ 0↑ born
# Rules
The run itself, mounted once on `mount_rules`. It advances the dawn clock,
sends the flock's six calls, keeps the failance ledger, and decides how the
night ends.
## The flock's rhythm
The calls do not fall on a metronome. `CALL_PLAN` in `init.luau` places them
against a 150 s run whose light begins to rise at 8 s:
| # | at | window | side |
|---|---|---|---|
| 1 | 13 s | 4.6 s | west |
| 2 | 27 s | 4.4 s | east |
| 3 | 55 s | 4.0 s | west |
| 4 | 84 s | 3.6 s | east |
| 5 | 106 s | 3.2 s | east |
| 6 | 126 s | 2.9 s | west |
Two close together early while the dark is still forgiving, a long silence
across the middle, then three in the last third with the windows closing — so
answering costs most exactly when the light makes standing still expensive. A
boom of 1.15 s inside a 2.9 s window is a third of it.
## How a night ends
- **Won** — she reaches the roost (`roost`, from Tawpy, at 99.5 % of the lane).
- **Lost** — the third failance, or `caught`, or the light fills the floor
(`FL.progress()` reaches 1) with her still out on it.
Entering `playing` from anything but `paused` clears the ledger and calls
`player.reset()`.
## The surface
`FL.provide("rules", …)`:
- `ledger()` — `answered`, `failances`, `failanceLimit`, `callIndex`,
`callCount`, `windowOpen`, `deadline`, `window`, `remaining`,
`windowFraction` (1 at the call, 0 at the deadline — draw the countdown from
this), `callSide`, `marks` (one entry per call: `"answered"`, `"failance"`,
`"open"`, or nil for one not yet sent), `runTime`, `light`.
- `schedule()` — the plan above, so a screen can lay the run out ahead of time.
- `restart()` — back to `intro` for a fresh run.
## Events emitted
`call` (`{ index, side, deadline, window }`), `answered` (`{ index, remaining }`),
`failance` (`{ index, count }`).
▲ 0↑ born
# Flock
The other gouras — the ones that call. Mounted once on `mount_flock`.
When the rules send a `call`, a caller stands at the lane's edge on the side the
call came from, a little ahead of Tawpy, turns to her and booms. She leaves
again when the window closes, answered or not; on an answer she gives one more
pulse before she goes.
A caller wears the same body Tawpy does — `game.hero.gouraart` — and holds the
boom posture the whole time she is up: chest puffed, crest flared, the pulse on
the beat. Each is a shade different in size and in the phase of her breathing,
so the flock reads as birds rather than as copies.
## Fields
- `ahead` — metres up the lane from Tawpy the caller stands.
- `edge` — metres inside the lane's half-width she stands, so `side = +1` puts
her at the east (screen-right) edge.
- `minScale` / `maxScale` — the range of caller heights, in metres to the crest.
- `calling` — live output: whether a caller is standing there.
## Provides
`flock` — `callerPosition()`, the caller of the open window or nil.
## Notes
- She keeps facing Tawpy while the window is open, so a bird who walks past her
is still being called to.
- A hot reload of the art module orphans her body; the update rebuilds it in
place rather than leaving a caller nothing poses.
▲ 0↑ born
# goura.inputMap
Tawpy on the forest floor: walk, flurry, boom, pause. Four controls, each bound
on all three device families, so a player on a keyboard, a phone or a pad
reaches every action the game has.
| Action | Keyboard + mouse | Touch | Controller |
|---|---|---|---|
| Move (axis2) | WASD / arrows | left-zone stick | left stick |
| Flurry (hold to gather, release to go) | Space / left mouse | Flurry button | south |
| Boom | E / right mouse | Boom button | west |
| Pause (toggles both ways) | Esc | Pause button | start |
The map lives in its own `goura` group and stands the engine's `player` group
down while it is live, so the standard scheme's look, jump and sprint never sit
beside hers on the screen or take the pointer. `console.inputMap` (the screens
slice) suppresses this group in turn while a card is up, so a menu never drives
the bird.
## The touch overlay
The engine draws the on-screen controls from these bindings — a floating stick
in the left 40 % of the screen and one circle per button up the right edge, in
priority order from the bottom-right corner inward. At 1080 x 1440 that lands
as **Boom** at the corner (984, 1344), **Flurry** above it (984, 1184), and
**Pause** at the top of the column (984, 1024).
Boom takes the corner because it is the control with a deadline on it: a call
opens a window of a few seconds and closes whether she answered or not, so it
has to be where the thumb already rests. Flurry is a hold-and-release and can
sit one place further in. Pause takes the highest priority number, which puts
it as far up the column as the overlay allows.
The positions come from the live screen size, not from these numbers — the
overlay lays itself out against `ui.screenSize()` every time the shape changes,
so the same three bindings read the same way on a wide screen.
Sizes are `large`, `large`, `small` as authored. Note that the overlay draws
every button at the largest declared size rather than at each one's own, so all
three currently come out at 72 px; the separation between Pause and the two
action buttons is the priority ordering, not the size.
▲ 0↑ born
# SoundClip
Managed audio asset. `data.zaud` is the engine-native ZAUD payload the runtime decodes and plays; compression settings live in the `.metadata` `settings` block (edit to re-encode).
▲ 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.