·
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.
42+items
# Screens
<!-- 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
# Stage
The moments of *First Light: Crowfeet*, and the phase machine that runs the
game from the title to an end card. One instance, on the scene's `stage`
entity.
## What it owns
**The beats.** `game.stage.Beats` writes each staged moment down as a shot —
a duration and a list of timed cues. `Stage` plays one at a time and emits
around it, so the rest of the game can answer a moment without knowing what is
in it.
| Beat | When | What the camera does |
|---|---|---|
| `opening` | `start` (the title card's Play) | Opens on the sea in the dark, lifts its eyes up the whole face, climbs it, and finds the crow on the strand. 11.4 s, skippable. |
| `firstLight` | the `firstLight` event | Leaves the crow, turns up to the roost where eleven birds are waking. 4.4 s, skippable, and deferred while the crow is airborne so a beat never lands mid-hop. |
| `won` | phase → `won` | Pushes in on the roost, the murder lifts, the Old Crow goes up with it, and the frame washes to first light. 9.6 s. |
| `lost_sea` | phase → `lost` (`sea`) | Drops with the crow, kicks, pulls back over the water and the sea takes the frame. |
| `lost_starved` | phase → `lost` (`starved`) | Pushes in close, then drifts up and away as the frame goes out. |
| `lost_late` | phase → `lost` (`late`) | Up to the roost, the murder goes without you, and back down to one bird alone. |
**The voice.** All nine Old Crow lines, each said once a round, through
`CF.say` — so the words reach the caption band whether or not the sound slice
has a recording of them. `Beats.LINES` is where the text lives.
**The murder.** `game.stage.Flock` builds eleven birds on the roost under one
temporary root. They sleep, stir at first light, and take wing at the end.
**The skip.** `game/stage/skip.inputMap` is activated for exactly as long as a
skippable beat is playing and stood down when it ends, so a Skip button is on
the touch overlay during the crane and gone afterwards. Space or Enter, the
pad's south face or Start, or the on-screen button — all three families, and a
skipped shot still fires the cues it had left, so it still says its line and
still leaves the game where the shot was going to leave it.
## Public fields
- `skipMap: AssetRef<inputMap>` — the map the Skip control lives in. Defaults
to `game.stage.skip`; if the scene predates the field the component resolves
that identity itself rather than losing the control.
- `autoStartAfter: number` — seconds on the title card before the opening
starts itself, so a recording is never wedged on a menu. `0` disables it.
## Events it emits
| Event | Payload | Meaning |
|---|---|---|
| `stage.beat` | `{ name, duration }` | a staged moment started |
| `stage.cinema` | `{ active, beat }` | the frame is being staged — **hide or inset the HUD while this is true** |
| `stage.resolved` | `{ outcome, reason }` | the ending has FINISHED playing — **put the end card up on this, not on the phase change**, or the card lands on top of the shot that earns it |
| `phase`, `line` | via `CF` | the phase machine and the Old Crow's voice |
It listens for `start`, `restart`, `reset`, `phase`, `firstLight`,
`hungerLow`, `eat` and `crumble`.
## Rehearsing it
```lua
local S = require("game.CF").stage
S.rehearse("opening") -- play a moment without earning it
S.status() -- beat, clock, cues fired, the staged frame, the flock
S.skip() -- as if the player pressed Skip
S.clear() -- take the staged frame off and hand the shot back
```
## One thing to know
`game.CF` belongs to the climb slice, and every edit of it hands back a NEW
module table with a NEW, empty event bus. A component that subscribed to the
old one goes silently deaf — no error, no warning, a game whose ending simply
never gets staged. So this component re-reads `game.CF` every frame and
re-arms the whole slice against a table it has not registered on.
Owned by the staging slice. Design: `/zero/source/design/spec.md`.
▲ 0↑ born
# game.audio.Sound
Everything *First Light: Crowfeet* is heard through. One component, on the
scene's `sound` entity; nothing else in the game plays a sound.
## The mix
| Channel | What is on it | Level |
|---|---|---|
| `ambient` | the two beds — the sea below, the roost above | 0.62 |
| `music` | the two score decks | 0.50 |
| `sfx` | every one-shot | 1.00 |
| `voice` | the Old Crow's nine lines | 1.00 |
Master 0.9. The bed sits under everything: it is the room, not an event.
## The climb is audible with your eyes shut
Two ambience beds run at once and cross with the crow's height. `amb_sea` is
loudest on the strand and thins to about a quarter of itself at the roost;
`amb_roost` — air over the summit and a few birds that have not settled — comes
up to meet it. So the last ledge sounds nothing like the first, and the light
takes a little more of the sea away as it comes.
## The score turns over with the light
`music_night` and `music_dawn` are the same sixteen-second drone on the same E,
one with the minor third and one with the major. Both decks run in parallel and
are crossfaded by `CF.state.dawn` between 0.15 and 0.85 — at dawn 0.5 each sits
at exactly half. There is no track change: what the player hears is a third
turning over as the sky does.
## One line, spoken and printed
`CF.say(speaker, text, key)` fires `line`. The presentation slice prints the
words; this component plays `game/audio/voice/<key>.soundClip` if one exists.
The two are independent on purpose: a key with no clip is a line that is quiet,
never a line that is lost. While a line is speaking the beds and the score duck
to 0.40 and come back.
The nine keys are `open_1`, `hunger_low`, `eat_1`, `crumble_1`, `first_light`,
`won_1`, `lost_sea`, `lost_starved` and `lost_late`.
## What it answers
`hop` · `land` (by hardness — soft under 0.5, hard over) · `grab` · `pullup` ·
`drop` · `peck` · `eat` (by `food.kind`: grub / limpet / crowfoot) · `crumble` ·
`fall` · `tooWeak` · `hungerLow` · `firstLight` · `phase` (the flock lifting on
a win; the sea, the collapse or the murder leaving without you on each loss) ·
`reset` · `pause` · `line` · `ui`.
`CF.emit("ui", which)` takes `move` / `confirm` / `back` / `pause` and their
aliases (`nav`, `select`, `start`, `restart`, `cancel`, `resume`, `menu`, …);
anything else answers with the quiet tick, so a new screen is never silent.
## What another slice can ask of it
```lua
local sound = entity.find("sound").component.get("game.audio.Sound")
sound.speaking() --> the line key being spoken, or nil
sound.play("caw", 0.6) --> any recipe by name, for a noise with no event
```
## Notes
Every source is non-spatial: the listener rides the camera and this is a mix,
not a room. The beds loop with the `Audio` component's own `looping` field and
are baked `codec = "pcm"` so they join without a click. Clips come from
`game/audio/recipes` via `game/audio/bake.luau`; the voice lines were generated
once and cached as assets — nothing is synthesised or generated at play time.
The blackboard is a module, and a module that reloads under a running session
either becomes a new table or re-runs into the same one with an empty listener
list. Either way a component that registered against the old bus hears nothing
and says nothing about it — the whole soundtrack goes quiet with every reading
still green. So this component does not trust its subscription: every couple of
seconds it emits a private event through the module `require` hands back now,
and if its own listener did not hear it back, it moves onto the live bus.
Owned by the `sound` slice. See `/zero/source/design/spec.md`.
▲ 0↑ born
# game.CrowVisual
What the Old Crow looks like, and what its body is doing. Sits beside
`game.CrowController` on the player prototype's `body` and owns everything under
a single child named `crow_visual`, rebuilt on every awake so a clone made for a
joining player carries exactly one bird.
Three modules under it, each with one job:
| Module | Job |
|---|---|
| `game.crow.shapes` | arrays in, geometry out — the sweep every part is made by |
| `game.crow.rig` | the anatomy: which mesh, on which joint, where |
| `game.crow.poses` | what the body does, and the springs that get it there |
The bird is built at whatever size the anatomy came out and then scaled once so
it stands exactly `CF.RULES.crowHeight` from claw to crown — the reach the climb
slice's `CF.grabbable` catches a lip with. Change the anatomy and the scale
follows; nothing here is a measured constant.
## What drives it
The pose is chosen from `CF.state` every frame — hanging, airborne, weak, moving,
still, won, lost — and interrupted by one-shots the CF events fire: `hop`, `land`
(longer for a harder landing), `grab`, `pullup`, `drop`, `peck`, `eat`, `fall`.
`crumble` and `tooWeak` set a startle that snaps the neck up and flicks the
wings. `reset` puts it back to idle.
On top of the pose blend sit the overlays — the things a body does continuously
rather than in poses: the breath, the wingbeat, the stride while sidling, the
head keeping itself level against the hunch below it, the toes closing on what
they are standing on, the tail answering the fall, and a blink.
## API
```lua
local cv = entity.component.get("game.CrowVisual")
cv:setPose("fly", 3) -- force a pose for N seconds — a staged moment
cv:poseState() -- { pose, scale, restHeight, yaw, shot, shotT }
```
Owned by the `crow` slice. See `/zero/source/design/spec.md`.
▲ 0↑ born
# CrowCamera
The camera of the climb, and the lens every staged moment is shot through. It
sits on the PlayerPrototype's `CameraRig` beside the `Camera` component, so
every joining player gets one of their own.
## The frame
Perspective, standing off the cliff face (the plane `z = 0`) at `distance`,
looking at a point on that plane. The **vertical** field of view is what is
fixed, so the same world height shows on every screen and a wide screen simply
sees more cliff to either side. Nothing here is a number chosen for
1080x1440.
Whatever else happens, **the crow is in frame**: after the follow, the landing
spring and the shake have all had their say, a last clamp holds the crow inside
`keepIn` of the LIVE frame's own half-extents, measured from the lens and the
live aspect. That clamp is what makes one set of numbers hold at 3:4 and at
21:9. Measured over 186 follow frames of keyboard play: `lost = 0`, worst
offset exactly `0.56` of the half-frame in both axes — the clamp, doing its job.
## The follow
- **Lead up**, because the climb goes up, and harder while the crow is rising
(`leadY` plus a term in the crow's own vertical speed).
- **Deadzone** in both axes (`deadX`, `deadY`), so a sidle does not swim the
frame.
- **Asymmetric tracking** — `tauUp` chases a rising crow harder than `tauDown`
lets it fall away.
- **Landing weight** — the frame drops with the crow on a landing and springs
back, scaled by the landing's hardness.
- **Kicks** on a hard landing, a crumble, a fall and the weak state.
- Only a share of the crow's x (`followX`), because there is little width to
give away on a portrait screen; the clamp above is what stops that share
from ever losing the bird.
- While the crow hangs, the lead drops so the lip its feet are on is in shot.
## The staged shot — `CF.camera`
Filled in when the component wakes, and re-filled whenever `game.CF` reloads:
| Call | What it does |
|---|---|
| `panTo(x, y, seconds, ease)` | where the camera stands |
| `aimTo(x, y, seconds, ease)` | where it LOOKS — the tilt a crane needs |
| `dollyTo(distance, seconds, ease)` | in or out from the face |
| `zoomTo(fov, seconds, ease)` | the lens |
| `snapTo(x, y, distance, fov)` | a cut, declared to the renderer with `camera.cut()` |
| `release(seconds)` | hand the shot back to the crow; the aim eases home |
| `kick(amount)` · `weight(amount)` | shake, and the weight of a landing |
| `isPanning()` · `held()` · `pose()` | what the shot is doing |
| `frameHalf()` · `aspect()` | the live frame's half-extents and shape |
| `bars(frac, seconds)` · `veil(r, g, b, a, seconds)` · `clearFrame(seconds)` | the staged frame (see `game.stage.Cinema`) |
Eases: `linear`, `inOutQuad`, `inOutSine`, `inOutCubic`, `outCubic`, `inCubic`.
## Public fields
`distance` · `leadY` · `followX` · `tauX` · `tauUp` · `tauDown` · `deadX` ·
`deadY` · `fov` · `keepIn`.
## One thing to know
`game.CF` belongs to the climb slice, and every edit of it hands back a NEW
module table with an empty event bus and no `CF.camera` on it. So this
component re-reads it every frame and puts its listeners and its camera hooks
back on whatever table the rest of the game is talking to.
Owned by the staging slice. Design: `/zero/source/design/spec.md`.
▲ 0↑ born
# CrowController
The rules of the climb, on the Old Crow's body.
It reads the `game/input/crow` map — sidle, hop, peck, pause — and turns it
into the crow's position, the two clocks, and the events every other part of
the game answers. Only the local player's copy drives; a remote crow is left
to its owner.
## The move set
| Move | How | What it costs |
|---|---|---|
| Sidle | `move` x, on a shelf | the standing drain |
| Hop | `hop`, on a shelf | `RULES.hopCost`, and it is refused below `RULES.weakBelow` |
| Catch a lip | happens on its own: airborne, beside a shelf's near edge, crown level with it, no longer rising hard | — |
| Hang | the state after a catch | `RULES.hangDrain`, the fastest drain in the game |
| Pull up | `hop`, or `move` y up, while hanging | `RULES.pullUpCost` — allowed even when too weak to hop, so a hang is never a death sentence |
| Let go | `move` y down, while hanging | — |
| Peck | `peck`, on a shelf, within reach of food | refills by `RULES.food[kind]` |
| Pause | `menu`, during the climb | emits `pause` |
One hop rises `CF.layout.apex`. Every SHORT gap in the layout is under that
and is landed on; every TALL gap is over it, so the only way up is the lip.
Coyote time (`RULES.coyote`) keeps a hop pressed just after walking off a lip,
and a hop pressed just before touching down is remembered for
`RULES.hopBuffer`. Holding a direction in the air steers; letting go bleeds
the sideways speed off, which is what makes a lip-catch aimable.
## Crumble shelves
Landing on — or hanging from — a `crumble` shelf emits `crumble` with it and
starts `RULES.crumbleDelay` on the clock. When that runs out the shelf is
marked `fallen`, `crumbled` is emitted, and anything standing on it drops.
Both ledging tests ignore a fallen shelf. The layout puts the shelf above a
crumble back over the shelf below it, so a crumble that has gone never seals
the climb.
## How a round ends
- **won** — the crow is standing on the roost, whether it hopped onto it or
hauled itself over the lip.
- **lost `starved`** — hunger reached 0.
- **lost `sea`** — the crow fell past `RULES.seaY`.
- **lost `late`** — first light finished breaking (`dawn` reached 1) with the
crow still on the face.
`restart` puts the round back (through `CF.reset`): the shelves stand again,
the food is back, the crow is at its spawn.
## What it writes
`CF.state.crow` (x, y, vx, vy, facing, grounded, hanging, ledge),
`CF.state.hunger`, `CF.state.dawn`, `CF.state.time`, `CF.state.altitude`,
`CF.state.eaten`, `CF.state.hops`, `CF.state.crumbled`, and the phase.
Events: `hop` `land` `grab` `pullup` `drop` `peck` `eat` `tooWeak` `crumble`
`crumbled` `fall` `hungerLow` `firstLight` `pause` `phase`.
It also stands down the engine's builtin `default` bindings when it arms, so
the game's own controls are the only ones live and the touch overlay draws
only the three buttons and the stick this game has.
▲ 0↑ born
# Cliff
The place the Old Crow climbs: a basalt sea cliff on a night coast, and the walk
of its light from moonlight to first light.
Mounted once, on the scene's `cliff` entity. Everything it makes lives under one
temporary child called `cliff_gen`, rebuilt whenever the component wakes, so the
scene file never carries a generated ledge.
## What it stands up
- **The face** — one displaced grid of columnar basalt: prisms at their own
depths with flat sides and hard seams, broken into stacked blocks by
cross-joints, ending in a jagged skyline at the summit.
- **A shelf for every ledge in `CF.layout`** — a real lip, a rolled front edge
and an undercut, tucked into whatever depth the face has behind it. Crumble
ledges are thinner, rust-brown and slightly tipped, so an untrustworthy shelf
reads as one before you land on it. The roost carries a pale crust, two old
nests of driftwood and three worn stubs.
- **The food** — glow-grubs, bone limpets and crowfoot blossoms, each an emissive
body and a point light that pools colour on the shelf. The blossoms are folded
shut in the dark and swing open as first light comes.
- **The sea** — a plane on `game.cliff.water`, which shades itself: four
travelling waves, wind ripple, a specular track, crest foam and a wash where
the water meets the rock.
- **Two headlands and a low moon** behind it all, so no aspect ratio ever shows
sky beside the cliff.
## The dawn walk
One number, `CF.state.dawn`, drives the key light's colour, strength and
direction, the ambient, the sky's gradient and stars, the warmth of the stone,
the sea's palette and the sea mist. Night is a thin blue moon rake over near-black
water; first light is a low amber sun raking the columns with the fill pulled
down, so the light arrives as contrast rather than as a wash.
The air is a post-process pass of its own, `cf_seamist`, registered on the
`"scene"` layer so it never fogs the HUD.
## What it answers
| Event | What happens |
|---|---|
| `eat` (food) | the food shrinks, spins and goes |
| `crumble` (ledge) | the shelf tips, shrinks and drops out of frame, throwing eleven chips on their own arcs |
| `reset` | the whole cliff is rebuilt |
## Fields
`dawnOverride` — freeze the scene's light at one dawn value for a shot or a
check. Below zero (the default) the cliff follows `CF.state.dawn` as it should.
Geometry lives in `game.cliff.geo`; the look lives in `game.cliff.basalt`,
`game.cliff.glow`, `game.cliff.water` and `game.cliff.seamist`.
▲ 0↑ born
# crow
Sidle, hop, peck, pause — the whole climb, on every device a player might hold.
| Control | Keyboard | Touch | Controller |
|---|---|---|---|
| `move` (axis2) | A / D, ← / → to sidle; W / ↑ to pull up off a lip; S / ↓ to let go | the stick, lower left | left stick |
| `hop` | Space | **Hop**, lower right | south face button |
| `peck` | E | **Peck**, lower right | west face button |
| `menu` | Escape | **Pause**, lower right | Start |
`hop` is both the hop and the pull-up: pressed while hanging it hauls the crow
over the lip, which is why it is never refused for weakness there.
The map's group is `player`. The menu map (`game/input/console`) suppresses
that group while a card is open, so the climb cannot be driven from behind a
menu.
An `axis2` control takes exactly one binding per device class, so "WASD or the
arrow keys" is written as one vector whose arms are themselves vectors — a
vector arm reads held / not-held, which makes it an OR of the keys in it. See
`move.inputBinding/init.luau`.
▲ 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.