·
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.
80+items
▲ 0↓ import
# fl
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
# VagantCamera
The frame the vagant is seen in. It sits on the `Vagant` PlayerPrototype's
`CameraRig`, beside the `Camera`, the `AudioListener` and the
`controller.third_person_follow` rig, and it does three things.
**It frames for the screen that is actually there.** Every framing number comes
out of `fl.cameraFit()` and the live `ui.screenSize()`, re-read whenever the
viewport changes shape. A tall frame comes in closer, cranes higher and puts the
vagant near the middle; a wide one pulls back and sets them off one shoulder.
Nothing in it is a pixel or a constant chosen for one aspect. Three constants
re-base fl's numbers into this rig's frame, which is not the frame fl states
them in: `third_person_follow` measures `shoulderOffset` in the CAMERA's own
axes rather than in world up, so fl's `height` is a lift up the SCREEN here.
**It hands the rig the game's own controls.** `look` carries a mouse delta, a
right stick and a right-side drag at once, so putting the game's `.inputMap` in
the rig's slot is the whole of making the camera aimable from all three device
families. The rig subscribes to that slot once, in its own `awake` and never
again, which is why this component declares `executionOrder = -120` — before the
rig's `-90`, so the map is in the slot before the subscription is made.
**It answers the state of the night.** The wig closes the view down (the camera
comes in and drops while `fl.isHidden()`), and being hunted unsettles the frame
by a drift that grows with `fl.state.hunted` and stops the moment they lose you.
The `staging` slice is the only other thing allowed to move the gameplay camera.
This component stands down by itself while the phase is one staging owns
(`opening`, `won`, `lost`), and `:release()` / `:resume()` say so explicitly.
## Public fields
- `gameMap: AssetRef<inputMap>` — the controls the rig is aimed with. Defaults
to the game's own `vagant` map.
- `huntShake: number` — how hard the frame answers a hunt; `0` turns it off.
## Methods
- `:release()` — stop driving the camera. `staging` calls this before taking the
gameplay camera for a scripted beat.
- `:resume()` — take it back and re-frame for the live screen.
## Lifecycle
- `awake()` — resolves the follow rig and the Camera, applies the framing, puts
the game's map in the rig's slot, and publishes itself as `fl.state.cameraRig`.
- `start()` — the same, for the case where the rig had not attached yet.
- `update(dt)` / `editorUpdate(dt)` — re-frames on a screen resize or a wig
change, and drives the hunt shake.
## Usage
```luau
local rig = layers.active.players.localPlayer.avatar.parent.getChildren()
entity.find("CameraRig").component.get("VagantCamera"):release()
```
▲ 0↑ born
# VagantBody
The vagant — the thing the player IS. It sits on the `Vagant` PlayerPrototype's
`body` entity, so the engine clones one per joining player, and every vagant on
the fen is driven by its own copy.
On `awake` it takes the stand-in avatar back off, builds the figure out of
`vagant.rig` over `vagant.parts` — coat, wraps, boots, satchel, the broad hat,
the lantern and the jasey — and poses it. Every frame after that it measures how
fast its own entity is travelling, turns that into a gait, and hands the whole
of what the vagant is doing to `vagant.anim`, which writes every joint.
It also owns the lantern: the point light the player sees the fen by, the flame
that gutters as the oil runs out, the glass that goes dead when the flame does,
and the way all three are smothered to `fl.TUNE.WIG_LIGHT_SCALE` while the wig
is down. And it makes the noise a body makes — footfalls on grass, on mud, in
water, and the splash going in and coming out.
It READS `fl.state` and never writes it.
## Public fields
- `netWig: boolean` — the wig is down. Written by the owning client, read by
every peer.
- `netWet: number` — how soaked the wig is, 0..1, quantised to twentieths.
- `netLit: boolean` — the lantern is burning.
- `netOil: number` — what is left in it, 0..1, quantised to twenty-fifths.
- `netWade: number` — 1 while standing in a cut.
- `netReach: number` — 1 while a relight is being held.
- `netCaught: boolean` — the fen has you.
- `lanternIntensity: number` — the point light's intensity at a full lantern
(default 6.0). The single biggest lever on how the game looks: high enough
that the reeds a few metres out are legible, low enough that the coat half a
metre from the flame stays wool rather than going to white.
- `lanternRadius: number` — its radius in metres at a full lantern (default 24).
- `gameMap: AssetRef<inputMap>` — the game's control scheme (`vagant`). Used
only to know when a relight is being HELD, so the vagant reaches for the lamp
instead of standing beside it — from a key, a pad button or a thumb alike.
The seven `net*` fields exist because `fl.state` is the LOCAL client's night.
The owning peer copies what a remote peer cannot see into them, on change only,
and every peer poses from them — so another player's vagant is hooded and
guttering on your screen too.
## Lifecycle
- `awake()` — drops the stand-in avatar, builds the rig, subscribes to `relight`
and to the `caught` signal.
- `start()` — re-checks whether this body is the local player's, and rebuilds if
`awake` ran before the scene could answer.
- `update(dt)` — measures speed, blends every state, poses the rig, drives the
lantern and the wig, fires footfalls.
- `editorUpdate(dt)` — the same, guarded on `engine.paused`, so the figure
stands, breathes and holds a burning lantern in edit mode too.
- `onDestroy()` — releases the input map and despawns the rig's root, which
cascades the whole body.
## Usage
The scene already carries it. To retune the light on a live body:
```luau
local body = layers.active.players.localPlayer.avatar.component.get("VagantBody")
body.lanternIntensity = 8.0
```
▲ 0↑ born
# JaseyDirector
The Commissioners. This component builds them, drives them, and is the only
place the rest of the game hears from them.
It sits on `mount_jasey` in `scenes/main.scene` and spawns nothing into the
scene file: every Jasey it makes is a temporary entity built from
`jasey.model`, and every one of them is **local to this peer and unsynced**.
That is deliberate. `fl.conspicuity()` and `fl.isHidden()` are one vagant's
answers about one lantern, so a shared set of hunters would be chasing several
people with one set of senses. Every player on the fen gets their own five,
which is also the only reading of the fiction that works — they come for
whoever is carrying the light.
A Jasey is about seventy small pieces: legs and ruined boots, the flared skirts
of a frock coat with a wet band at the hem, a narrow torso with tarnished
buttons, arms that hang too long and end in a soaked cuff, two linen bands at
the throat, a head that is a hole, and the jasey itself — a powdered dome,
three tiers of curl massed round the back and sides, a rolled buckle over each
ear, two lappets down the chest and a queue behind. They are built one a frame,
because seventy entities times five in a single frame is the shape that makes a
component's `awake` fail quietly.
## Public fields
- `count: number` — how many are out on the fen. `0` takes `fl.TUNE.JASEY_COUNT`.
- `running: boolean` — drive them, or leave them where they stand. A staged
beat turns this off to freeze the fen without removing anybody.
- `rustleVolume: number` (0–1) — how loud the wig is at the listener's ear
standing next to one. Scales with how fast the figure is moving.
- `wadeVolume: number` (0–1) — how loud one is dragging itself through a cut.
## Methods
- `:jaseys()` — every Commissioner on the fen, as entity proxies.
- `:nearest(x, z)` — the nearest one to a world point, and its distance.
- `:hunterCount()` — how many are hunting the vagant this instant.
- `:report()` — one row per Commissioner: mode, speed, wetness, hood glow and
position. The read for a test or a debug pass.
- `:signals()` — `{ hunt, lastHunt, caught, notice }`, a tally of what this
slice has told the rest of the game, so a test can prove a signal fired
rather than infer it from a side effect.
- `:place(index, x, z, mode?)` — stand one somewhere in a named state. Used to
stage a beat and to put a Commissioner in a known place for a test.
## Signals
Emits `caught(jaseyEntity)` once a Commissioner reaches an unhooded vagant, and
`hunt(count)` whenever the number chasing changes — the HUD, the score and the
fog all answer that one. Listens for `lampLit` (a share of the drifting ones
walk to the new light) and `phase` (a fresh round puts everybody back where the
night starts).
It asks the `fen` slice for `fen.waterDepthAt(x, z)` and, if the fen publishes
one, `fen.groundHeightAt(x, z)`. Neither is required: without them the
Commissioners walk a flat dry fen.
## Lifecycle
- `awake()` — reads `fl.TUNE`, resolves its four clips, subscribes to `lampLit`
and `phase`.
- `update(dt)` — builds one Commissioner a frame until the set is up, then
ticks every brain while the game is in the `play` phase.
- `editorUpdate(dt)` — the same, but only while the gameplay clock is held, so
a scene running unpaused in edit does not tick the same brains twice.
- `onDestroy()` — unsubscribes and despawns every Commissioner.
## Usage
```luau
local jd = entity.find("mount_jasey").component.get("JaseyDirector")
jd:report() -- what all five are doing
jd:place(1, 12, -8, "hunt") -- stand one out on the fen, coming for you
jd.rustleVolume = 0.45 -- turn the wigs up
```
▲ 0↑ born
# uipause.inputMap
One control: **Pause**. It is a map of its own so that holding the night is
never entangled with the scheme the vagant walks by.
| Control | Kind | Keyboard | Gamepad | Touch |
|---|---|---|---|---|
| `pause` | button | Escape | Start | the HUD pause pip |
- `group = "uipause"`, and it suppresses nothing. Pausing must not stand the
player's own controls down as a side effect — the pause card does that, by
activating `uimenu`, which names both groups.
- `uimenu` suppresses `uipause` while a card is up, so the same Escape cannot
close the card and immediately re-open it.
- Touch is declared `false`: the pip in the HUD's top-left corner is a real
tap target of its own, placed where the fiction wants it rather than where a
generated overlay would put it. The clock has the top-right.
▲ 0↑ born
# Staging
The moments of *First Light: Vagant* — the beats where the game takes the camera
off the player, and the voice of the whole script.
Mounted once, on `mount_staging`. It places nothing in the scene and owns no
entity; it listens to the game and answers with a shot.
## The beats
| Beat | What starts it | What it is |
|---|---|---|
| `opening` | the round begins | The fen, low over the water, then the first dark standard, then the vagant at the sluice house. The Commissioner is heard before anything is seen. |
| `seventh` | the last lamp catches | Off the lamp head and up, until all seven lights are in one frame. |
| `firstLight` | the night is won | The crane up off the vagant, out to the dawn, and out into the light. |
| `caught` | a Commissioner reaches you | The camera falls to the ground and the wig fills the frame while your entry is read. |
| `dawnLost` | first light, lamps still dark | The same rise, over a fen that never came on. |
A night ends one way: a named ending — caught, or first light — displaces the
dark-fen one, even mid-shot.
## Skipping
Every beat is skippable, from a keyboard (`Space`, `Esc`, `Enter`), from a pad
(`south`, `east`, `start`), from a thumb (the **Skip** button, bottom right) and
from a mouse (the **SKIP** pill, top right). `staging.inputMap` carries that one
control and stands the `player` group down while a beat runs, so the gameplay
controls leave the screen along with the gameplay camera and come back with it.
A skipped beat keeps its consequences and drops its remaining lines: what has not
been said yet is not said over the game you have just been handed back.
## Every shape of screen
No shot in here is a fixed camera position. Each is a direction and a distance
from what the shot is about, resolved against the live `ui.screenSize()`:
- a **laterally wide** subject — the fen, the line of seven lights — needs more
room across than a tall frame has, so a tall frame stands back;
- a **tall** subject — the vagant, a Commissioner filling the frame — is the
other way round, and a tall frame comes closer;
- the seven-lamp vista is fitted rather than placed: `flbeats.fitEye` solves the
distance at which the whole fen fits the narrower of the frame's two half
angles, which is the horizontal one on a phone held upright and the vertical
one on a television.
## The voice
Staging decides **when** a line happens and emits `say(key)`; the sound of it
belongs to `SoundDirector`, and the words on screen belong to `Screens`. Every
key staging fires is in `staging.flscript`, with its written form beside it — so
a line whose audio never arrives is a quiet line rather than a lost one.
Beyond the beats, staging speaks over live gameplay without taking the camera:
the first relit lamp, the fourth, the sixth, the first time something notices
you, the wig going on, the wig soaking through, and the oil running short.
## Public
- `playBeat(name)` — play one now, whether or not it has already played.
- `skip()` — skip whatever is running.
## Signals it raises
- `stagingBeat(name)` — a beat began.
- `stagingDone(name, reason)` — it ended: `completed`, `skipped` or `stopped`.
▲ 0↑ born
# Screens
Puts every authored screen of *First Light: Vagant* on the glass, and drives
them. It is mounted once, on `mount_screens`, and needs nothing else on that
entity.
## What it draws
| Screen | Layer | What it is |
|---|---|---|
| `fl-menu` | 960 | whichever card the phase calls for |
| `fl-hud` | 120 | dawn band, clock, pause pip, the seven standards, oil, wig |
| `fl-alert` | 118 | the hunt vignette and the relight prompt |
| `fl-say` | 980 | the subtitle line, above the cards |
The subtitle sits **above** the cards on purpose: a staged ending reads you
your entry in the minute-book while the card is on the glass, and a line
nobody can read is a line the game did not say.
## What decides which card is up
`fl.state.phase`, which the `loop` slice owns.
| Phase | Card |
|---|---|
| `boot`, `title` | the title card |
| `opening` | none — a staged shot, with only the words over it |
| `play` | none — the HUD |
| `paused` | the pause card |
| `won` / `lost` | first light, or the entry in the minute-book |
*How to play* is an overlay over whichever card opened it, not a phase.
When the player takes a line, this component emits `uiRequest(action)` —
`"start"`, `"pause"`, `"resume"`, `"restart"`, `"title"` — and waits. If
nothing has moved the phase after a moment it moves the phase itself, so the
game is reachable from its own title card whatever else is or is not listening.
## Controls
`ui.uimenu` is activated the instant a card goes up and released the instant
the last comes down; it stands the player's own scheme down while it is live.
`ui.uipause` carries the one control that has to stay live during play.
- **Focus** moves on `navigate` (arrow keys / d-pad) and `navigateStick` (left
stick), wraps at both ends, and lands on something the instant a card opens.
The focused line carries a brass ring, a lit edge marker and a diamond.
- **Choose** on `confirm` (Enter, Space, south), **leave** on `back` (Escape,
right mouse, east), and an end card also answers `restart` (R, north).
- **A pointer or a thumb** takes a line by touching it. Doing so moves the ring
to that line, so a player who mixes a mouse and a pad never loses their place.
- Each card shows the legend for the family actually in the player's hands,
read from `/runtime/input/device`.
## Public fields
- `menuMap: assetRef(inputMap)` — the menu scheme. Default `ui.uimenu`.
- `pauseMap: assetRef(inputMap)` — the pause control. Default `ui.uipause`.
## Methods
- `:repaint()` — force the next tick to rebuild every screen. The screens are
only repainted when their own inputs change, and a hot reload of a style
module is not one of those inputs, so this is how an edit to `ui.flui`
reaches the glass without restarting anything.
## Lifecycle
- `awake()` — subscribes to `line`, `caught` and `dawn`, activates the pause
control, and paints the first frame.
- `update(dt)` / `editorUpdate(dt)` — one tick either way: reads the device,
ages the subtitle, resolves the card the phase asks for, and repaints only
the screens whose inputs changed.
- `onDestroy()` — drops every subscription, releases both schemes, and
unregisters every screen it put up.
▲ 0↑ born
# SoundDirector
The sound of *First Light: Vagant*, and the library every other part of the
game reaches for. It sits on `mount_sound` in `scenes/main.scene` and needs no
sibling components: it spawns its own audio sources under a runtime entity
called `snd_root`, and despawns that root when it goes away.
It does four things.
**The library.** On `awake` it fills `fl.clips` from `audio.clips`, so nothing
else in the game ever holds a `.soundClip` reference. Everyone asks for a noise
by name — `fl.playSfx("lamp.catch", lampEntity)` — which arrives here as the
`sfx` signal. A name with no clip is a quiet game, not a broken one.
**The score and the bed.** A held D-minor string loops all night; a second,
grinding layer fades up as the Jaseys hunt and back down when they lose you; a
warm major cue replaces both when the seventh lamp catches. Under all of it the
fen's own air runs continuously, thinning as the sky opens. Each lamp that comes
back on gets its own small spatial fire.
**The voices.** `say(key)` plays the line from `audio.voice`'s script and emits
`line(key, text, speaker, seconds)` so the subtitle can be shown — whether or
not the clip exists, so a line whose audio failed to generate is spoken quietly
rather than lost. `lineEnd(key)` follows when it finishes, or immediately if
another line replaces it.
**The mix.** Five channels — `music`, `ambient`, `sfx`, `ui`, `voice` — and a
duck that pulls the score and the air down under anything spoken.
## Public fields
- `master: number` — the whole mix, 0..1 (default 1.0).
- `musicLevel: number` — the `music` channel (default 0.60).
- `ambientLevel: number` — the `ambient` channel (default 0.80).
- `sfxLevel: number` — the `sfx` channel (default 0.95).
- `uiLevel: number` — the `ui` channel (default 0.70).
- `voiceLevel: number` — the `voice` channel (default 1.0).
- `footsteps: boolean` — drive footsteps from the vagant's own movement
(default true). It switches itself off the moment another slice emits a
`step.*` or `splash.*` sound of its own, so the two never double.
## Methods
- `:playSound(name, where?)` — play a library sound by name. `where` may be an
entity proxy, an entity id, `{x, y, z}` or `{x = , y = , z = }`; omit it for a
sound that belongs to the player rather than to a place.
- `:speak(key)` — speak a line of the script, the same way the `say` signal does.
- `:currentLine()` — the line being spoken right now (`key`, `text`, `speaker`,
`seconds`, `elapsed`, `remaining`), or nil.
- `:report()` — what the mix is doing: phase, music state, the three layer
volumes, whether it is ducked, the live line, and the mixer's own audible
voice count.
## Signals
Answers `sfx`, `say`, and — as a fallback that any slice's own `sfx` call
suppresses for a third of a second — `lampLit`, `allLamps`, `dawn`, `caught`,
`lantern`, `wig`, `oil`, `hunt` and `phase`. Emits `line` and `lineEnd`.
## Usage
```luau
local snd = entity.find("mount_sound").component.get("SoundDirector")
snd:playSound("lamp.catch", lampEntity)
snd:speak("open_comm_1")
print(snd:report().musicState)
```
▲ 0↑ born
# FenBuilder
One-paragraph description of what this component does and what it
attaches to. Mention any required sibling components (e.g. Model,
Transform).
## Public fields
- `exampleNumber: number` — what it controls, units, valid range.
- `exampleString: string` — what it controls.
- `exampleBool: boolean` — what it controls.
## Methods
- `:methodName(arg)` — what it does and when to call it.
## Lifecycle
- `awake()` — same-frame attach hook. What initial state this component
sets up.
- `start()` — first-frame-after-awake hook. Cross-component setup that
needs the other components on the entity to have finished `awake`.
- `update(dt)` — per-frame while the gameplay clock runs. What this
component does each tick.
- `onDestroy()` — cleanup performed on detach / entity despawn.
See `man components` for the full hook list (`onEnable`, `fixedUpdate`,
`onPropertyChanged`, etc.) and the timing details.
## Usage
```luau
entity(id).component.add("FenBuilder", { exampleNumber = 1.0 })
entity(id).component.get("FenBuilder"):methodName("foo")
```
▲ 0↑ born
# GameLoop
The rules of *First Light: Vagant*, on the `mount_loop` entity. It is the
only writer of `fl.state`; every other slice reads that table or subscribes
through `fl.on`.
It owns the dawn clock, the lantern and its oil, the relight, the jasey going
on and off and getting soaked and dried, the vagant's walking and wading
speed, and the win/lose machine. It owns `vagant.inputMap` — the world's one
control scheme, carrying keyboard, gamepad and touch on every control — and
therefore the on-screen touch buttons the night is played with.
## Public fields
- `inputMap: assetRef(inputMap)` — the scheme to run. Defaults to `vagant`.
- `autoStart: bool` — start the night without waiting for a title card to be
taken. Off by default: the loop sits in `title` until something calls
`fl.beginRound()`, which is what the `screens` slice's title card does.
## The one scheme
The engine's `CharacterController` (on the vagant's body) and
`third_person_follow` (on the CameraRig) each activate an input map of their
own, defaulting to `@builtin::inputMaps.default`. Left alone that map is live
beside this game's: two movement sticks, five touch buttons that do nothing,
and `hood` fighting the default `look` for the right mouse button.
So at the frame the local player is ready, this component walks the avatar
and camera-rig subtrees and points every component carrying an `inputMap`
field at `vagant.inputMap`. That field is read once, when a controller arms,
and none of them watch it afterwards — so the gameplay clock is held for ONE
frame and let go, which is the hook they already register
(`CameraRig.driveWhileRunning`) to hand their controls back and take them
again, re-reading the field on the way in. It has to be a real frame: holding
and releasing inside one call re-arms them on the map they already had.
Two things then still draw the engine's own buttons on a phone, and both are
cleared once every controller is re-armed: whatever still holds
`@builtin::inputMaps.default` at the scheme layer is released, and the
compatibility action registry the touch overlay also draws from is displaced
with an empty one. After that the overlay carries exactly this game's five
buttons — Relight, Hood, Run, Climb, Pause — plus the movement stick and the
look-drag zone.
## Driving the night from another slice
`screens` and `staging` call these rather than writing `fl.state`:
- `fl.beginRound()` — a title card was taken; run the staged opening.
- `fl.openingDone()` — the opening beat has finished; hand the fen over.
If nothing calls it, the night starts anyway after
`fl.TUNE.OPENING_MAX_SECONDS`, so a missing cutscene can never strand a
player on a dead screen.
- `fl.setMenu(open)` — a card went up or came down. Holds the clock and the
vagant while it is up.
- `fl.restart()` — an end card was taken; walk out onto the fen again.
## Phases
`title → opening → play → won | lost`, with `paused` sitting beside `play`.
Every change fires `phase(new, old)`.
## Lamps
The `fen` slice dresses the seven anchors and hands each one over with
`fl.registerLamp`. If nothing has by `fl.TUNE.LAMP_REGISTER_GRACE` seconds
into the night, this registers the bare scene anchors instead and gives each
a stand-in warm light when it is relit — a night is always winnable. A fen
that shipped registers first and none of that runs.
## Water
`fl.waterDepthAt(x, z)` answers how deep the vagant is standing. The `fen`
slice hands the probe over with `fl.provideWater(fn)`; until it does the
answer is dry ground, which is a walkable fen rather than a broken one.
Past `TUNE.WET_DEPTH` the wig soaks; past `TUNE.WADE_DEPTH` the walk drops to
`TUNE.WADE_SPEED` and running is refused; past `TUNE.DOUSE_DEPTH` the lantern
goes out.
## Lifecycle
- `awake()` — resolves the scheme, registers the loop driver on `fl`,
subscribes to `caught` and `hunt`, and enters `title`.
- `update(dt)` — the night, one frame at a time. Play mode only.
- `editorUpdate(dt)` — hands the scheme back whenever the gameplay clock is
held, so the pointer belongs to the editor's camera while authoring.
- `onDestroy()` — releases the scheme and every subscription.
## Usage
```luau
entity("mount_loop").component.get("GameLoop") -- the mount the scene carries
fl.beginRound() -- start a night
```
▲ 0↑ born
# vagant.inputMap
The one control scheme of *First Light: Vagant*. Eleven controls, each
carrying keyboard, gamepad and touch, so the night is playable on a desktop,
on a pad and under a thumb without a second scheme existing anywhere.
| Control | Kind | Keyboard / mouse | Gamepad | Touch |
|---|---|---|---|---|
| `move` | axis2 | `WASD` | left stick | left virtual stick |
| `look` | axis2 | mouse (pointer locked) | right stick | right-side drag |
| `sprint` — "Run" | button | `Shift` (held) | left-stick click, `east` | Run |
| `jump` — "Climb" | button | `Space` | `north` | Climb |
| `relight` | button | `E` (held) | `south` (held) | Relight |
| `hood` | button | `Q`, right mouse | `west`, left trigger | Hood |
| `pause` | button | `Escape` | `start` | Pause |
| `confirm` | button | `Enter`, left mouse | `south` | — the card's own control |
| `back` | button | `Escape`, right mouse | `east` | — the card's own Back |
| `navigate` | axis2 | arrow keys | d-pad | — tap the control |
| `restart` — "Again" | button | `R` | `north` | — the card's own Again |
## Why the names are what they are
`move`, `sprint`, `jump` and `look` are read BY NAME by the engine's own
`CharacterController` and `third_person_follow`. Renaming `sprint` to `run`
would leave the character with no way to run at all, so the control keeps the
engine's name and shows the player its label, which is **Run**.
## Why four controls carry no touch class
`confirm`, `back`, `navigate` and `restart` are menu controls, and on a phone
a menu is driven by touching the control you want. An overlay button for them
would be a second, unlabelled way to press the button already on screen, and
it would spend one of the four slots the night itself is played from. The
`screens` slice draws those controls at a thumb size; this map says so in the
record, where a reader sees it.
## The four the night is played with
`relight` and `hood` render first, largest, and adjacent — they are the two a
thumb has to find in the dark without looking, so they share the `act` group
and take the two lowest priority numbers. `Run` sits above them. `Pause` is
last and smallest, deliberately away from the act cluster, so a thumb
reaching for Relight in a hurry cannot stop the game instead.
## Shared bindings, and why none of them are ambiguous
`Escape` is `pause` and `back`; `south` is `relight` and `confirm`; `north` is
`jump` and `restart`. Each pair is answered in a different phase — `pause`
only while the night runs, `back` only while a card is up, `restart` only from
an end card — so one key opens the pause card and the same key closes it, and
nothing has to be learned twice.
`look`'s gate declares `rightButton = "off"` because `hood` binds the right
mouse button as a game action: in this world a right-drag pulls the wig down
rather than swinging the camera.
## Who runs it
The `loop` slice's `GameLoop` component activates it, and points the avatar's
CharacterController and the camera rig's behaviour at it too, so exactly one
scheme is ever live. `screens` stands the whole `player` group down with its
own `ui` map while a card is open.
▲ 0↑ born
# uimenu.inputMap
The controls a **menu** answers to in *First Light: Vagant*, and nothing else.
`Screens.component` activates it the instant a card goes up and releases it the
instant the last one comes down.
Its `group` is `ui` and it `suppresses`:
- `player` — the vagant's own scheme, so nobody walks into a ditch while
reading the how-to card.
- `uipause` — the control that opens the pause card, so one Escape cannot
close a card and re-open it in the same frame.
## Controls
| Control | Kind | Keyboard / mouse | Gamepad | Touch |
|---|---|---|---|---|
| `navigate` | axis2 | arrow keys | d-pad | — |
| `navigateStick` | axis2 | — | left stick | — |
| `confirm` | button | Enter, Numpad Enter, Space | south | — |
| `back` | button | Escape, Backspace, right mouse | east | — |
| `restart` | button | R | north | — |
**Touch is declared `false` on purpose, not by omission.** Every line on every
card is a control at thumb size carrying its own handler, so a finger chooses
by touching the thing it wants. A floating overlay button that points at a
menu item the finger can already reach is worse than no button.
`navigate` and `navigateStick` are two controls because an `axis2` evaluates
exactly one binding per device class, and a controller should answer to both
its d-pad and its left stick. `Screens.component` subscribes both to one
handler.
▲ 0↑ born
# Texture
Managed texture asset. `data.ztex` is the encoded payload the renderer uploads; compression settings live in the `.metadata` `settings` block (edit to re-encode).
▲ 0↓ import
# Texture
Managed texture asset. `data.ztex` is the encoded payload the renderer uploads; compression settings live in the `.metadata` `settings` block (edit to re-encode).
▲ 0↓ import
# Texture
Managed texture asset. `data.ztex` is the encoded payload the renderer uploads; compression settings live in the `.metadata` `settings` block (edit to re-encode).
▲ 0↓ import
# Texture
Managed texture asset. `data.ztex` is the encoded payload the renderer uploads; compression settings live in the `.metadata` `settings` block (edit to re-encode).
▲ 0↓ import
# pause.inputBinding
Hold the night from inside the game. Escape on a keyboard, Start on a pad; touch reaches it through the HUD's own pause pip in the top-left corner, which is a real tap target rather than a generated overlay button.
▲ 0↑ born
# back
Leave the card you are on.
`Escape` or the right mouse button · `east`. It shares `Escape` with `pause` on purpose — `pause` is answered only while the night runs and `back` only while a card is up, so one key opens the pause card and the same key closes it. No touch class: a card carries its own Back control at a thumb size.
▲ 0↑ born
# confirm
Take the focused thing on a card. The `screens` slice drives focus with `navigate` and activates on this.
`Enter` or the left mouse button · `south`. Deliberately no touch class: on a phone a card is confirmed by tapping the card's own control, so an overlay button here would be a second, unlabelled way to press the button already on screen.
▲ 0↑ born
# hood
Pull the jasey down over your head, or push it back off. A TAP toggles it: being hidden is a state you are in, not a button you hold for the length of a chase.
`Q` or the right mouse button · `west` or the left trigger · the Hood button. Worn and dry it hides you completely; ditch water ruins it until a lit lamp dries it out.
▲ 0↑ born
# jump — "Climb"
A scramble up a ditch bank. The fen is walked, not platformed: this exists so a vagant who has waded into a cut can get out of it again, which is the one place a walk alone can strand you.
`Space` · `north` · the Climb button.
▲ 0↑ born
# look
Where the vagant is looking. The `CameraRig`'s follow behaviour reads it, and the `vagant` slice's own camera work rides on the same control.
Mouse (with the pointer locked) · right stick · a drag in the right-hand zone. Its gate declares `rightButton = "off"` because `hood` binds the right mouse button as a game action in this world: a right-drag pulls the wig down rather than swinging the camera.
▲ 0↑ born
# move
Where the vagant walks, as a direction the player means rather than a set of keys. `CharacterController` reads it and projects it against the live camera basis, so "up" is always away from the camera however the rig is aimed.
`WASD` · left stick · left-side virtual stick. A small radial deadzone keeps a resting thumb still; the reading is linear, so a half-pushed stick is a half-speed wade.
▲ 0↑ born
# navigate
Move the focus around a card. The `screens` slice reads it and moves its brass focus ring; the arrow keys and the d-pad therefore reach every menu without a mouse.
Arrow keys · d-pad. A large deadzone, because this is a discrete chooser and a resting thumb must not walk the focus down a list. No touch class: a thumb navigates a card by touching the control it wants.
▲ 0↑ born
# pause
Stop the night. The `loop` slice holds the clock and the vagant, and the `screens` slice puts its pause card up.
`Escape` · `start` · the Pause button — last in the touch band, smallest, and deliberately away from the act cluster, so a thumb reaching for Relight in a hurry cannot stop the game instead.
▲ 0↑ born
# relight
The whole point of the night. HELD at a dark standard within reach: the `loop` slice counts the hold against `fl.TUNE.LAMP_RELIGHT_SECONDS`, spends a slug of oil when it completes, and the lamp comes back on.
`E` · `south` · the Relight button — the lowest priority number in the scheme, so it renders first, largest, and beside Hood in the `act` cluster. It is the button a thumb has to find in the dark without looking.
▲ 0↑ born
# restart — "Again"
Walk out onto the fen again. Answered only from an end card, which is why it shares `north` with `jump` without ever being ambiguous: a night that is over has nothing left to climb.
`R` · `north`. No touch class: the end card draws its own **Again**.
▲ 0↑ born
# sprint — "Run"
The vagant runs. It is HELD, not tapped, so letting go returns them to a walk on the drop frame; running is refused outright while wading.
`Shift` · left-stick click or `east` · the Run button. The control is named `sprint` because `CharacterController` reads that name; the player only ever sees the label, which is **Run**.
▲ 0↑ born
# back.inputBinding
Leave the card that is up. Escape, Backspace or the right mouse button; east on a pad. On the title card there is nothing behind it, so back does nothing there.
▲ 0↑ born
# confirm.inputBinding
Take the focused line. Enter, Numpad Enter or Space; the south face button on a pad. The mouse is not bound here — a pointer confirms by clicking the control it is over, and a bound left button would fire the focused line from anywhere on the screen.
▲ 0↑ born
# navigate.inputBinding
Move the focus ring around a card. Arrow keys, or the d-pad — a d-pad is the menu device on a controller. Touch is suppressed on purpose: a finger taps the line it wants, which is the direct form of the same action.
▲ 0↑ born
# navigateStick.inputBinding
The left stick doing what the d-pad does. An axis2 evaluates one binding per device class, so a control cannot carry both; this is the stick half, and Screens subscribes it to the same handler as navigate.
▲ 0↑ born
# restart.inputBinding
Walk the night again, from an end card. R on a keyboard, north on a pad; a thumb taps Again on the card itself.
▲ 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.