·
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.
67+items
# 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
```luau
local M = require("@<youridentity>::modules.core")
M.exampleFn("foo")
```
## Notes
- Anything callers need to know about THIS module: required runtime
ordering, state ownership, side effects.
▲ 0↑ born
# Conductor
<!-- 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
# Cloister
Raises the Verdigris Cloister. Put it on an entity under the scene's
`Greenhouse` anchor and every load of the scene rebuilds the room under that
entity — floor, walls, piers, the brass vault and its cracked glass, the
irrigation, the hanging censers, the shafts of sun, the vapour and the spores —
along with the scene's sun and ambient, the sky, and the game's post-process
chain.
```luau
entity.spawn("Cloister", { parent = entity.find("Greenhouse") })
.component.add("Cloister", {})
```
Fields: `ownsLighting`, `ownsPost`, `ownsSky` — whether this component also sets
the sun and ambient, the post chain and the sky. All on by default; turn one off
if something else takes that job over.
It despawns the skeleton's `sk_*` placeholders on the anchor, since this slice is
what replaces them. There is no `update()`: the room does not tick, and the
motion in the spores, the shafts and the vapour is evaluated in the shaders from
`time`.
▲ 0↑ born
# Screens
The campaign's front of house: the title screen, the mission briefing, the
between-mission seed catalogue, the botanical herbarium codex, and the two end
cards — plus the progression that strings them into a campaign of four rooms.
One instance, on a root entity named `Screens`. It registers a single screen,
`vc_campaign`, and re-registers it whenever the page changes.
```lua
local s = entity.find("Screens").component.get("Screens")
s.show("codex") -- title | briefing | catalogue | codex | ending | playing
s.currentPage() -- the page on the glass
s.isModal() -- true whenever a page is covering the game
s.finishMission("won", "The hall held.", units) -- units is Core.state().units shape
s.refreshVoice() -- re-check whether this page's line has a clip, and redraw
```
Methods are **dot-called**, not colon-called: `s.show("codex")`, not
`s:show("codex")`.
## The campaign it drives
`game.campaign` owns the data: the four rooms, the wound table, the run, and
`Campaign.settle()`, which turns a finished mission's unit table into wounds and
deaths. The run lives at `Core.state().campaign`, so any slice can read it.
The flow:
```
title ──Take up the tools──> briefing ──Go in──> playing
^ │
│ missionEnded
│ v
catalogue <───────── (won, more rooms)
│
(lost, or the last room)
v
ending
```
`playing` is not a page — it takes the screens down and hands the frame to the
board. The component leaves it when the rules slice fires `missionEnded`, or
when the `Director`'s `snapshot()` grows an `outcome` (polled at 0.75 s while a
mission runs; it only reads, so it is not a clock).
## What it consumes
| From | How | Degrades to |
|---|---|---|
| rules | `Director:startMission(missionId, { squad, mission })` | the mission starts anyway, board only |
| rules | `Core.SIGNAL.missionEnded { outcome, reason }` | `finishMission(...)` called by hand |
| rules | `Director:snapshot()` → `.outcome`, `.units` | no wounds recorded, campaign still advances |
| audio | `game.audio.lines`' `NARRATION[key].text` | the abbot's own written briefing is printed instead |
| audio | `Conductor:narrate(key)` on `Ambience` | the line is printed and marked TEXT ONLY |
| hud | `game.ui.hud.hud`'s `SCREENS` map | nothing; the hud stays up over the page |
The narration keys are the audio slice's: `title`, `brief_<missionId>`,
`victory`, `defeat`. **Whatever is spoken is printed word for word** — the page
renders the audio slice's `.text`, so a muted player reads exactly what a
listening one hears, and a line that failed to generate is a quiet line rather
than a lost one. The mark beside it reads SPOKEN when a clip exists and TEXT
ONLY when it does not; clicking it replays the line.
## What it publishes
| Signal | Payload | Meaning |
|---|---|---|
| `screens:modal` | `{ open, page }` | a full-screen page is up (or has come down) |
| `screens:missionStart` | `{ mission, squad }` | the player pressed "Go in" |
| `screens:narrate` | `{ id, key, text, voice, mission }` | this line wants speaking |
It also emits `Core.SIGNAL.playSfx` (`ui_click`, `ui_confirm`, `ui_back`) and
`Core.SIGNAL.playMusic` (`title`, `briefing`, `mission`, `victory`, `defeat`).
## Two things about the frame
**The hud is hidden while a page is up.** Its screens are rooted in `area`
nodes, and an `area` is a floating window, so it draws above any ordinary
screen at any layer — a modal page at layer 8000 still has the initiative queue
sitting on top of it. `screens:modal` is published for whoever would rather
listen than be hidden, and the stand-down is re-asserted four times a second so
a hud hot-reload cannot put the queue back over a title screen.
**Motion is off in edit mode.** Edit pauses time, so an entrance animation whose
first keyframe is `opacity: 0` would hold that frame forever and the page would
read as blank while every data query said it was there. `kit.setMotion()` is the
switch; the component flips it on every render.
## Keeping the entity
`Screens` is a root entity spawned at runtime, not part of `main.scene`'s
`build.luau` (which the plan phase owns). It replicates as a `WorldEntity`, so
it is live for every session in this world, but it is a **pending scene change**
until someone accepts it. `/source/game/ui/screens/install.luau` re-creates it
idempotently if it ever goes missing:
```
run /source/game/ui/screens/install.luau
```
▲ 0↑ born
# Tactical
The camera, the board, and the staged moments — the `cam` slice of
Verdigris Cloister, in one component. It lives on the **`Board`** anchor
(or on a child of it) and owns three things:
1. **The camera.** A raised three-quarter station — yaw, pitch, distance
and a target on the board — eased every frame onto the scene's main
camera. It orbits, it zooms, and it refuses to swing anywhere the
1080x1440 portrait frame cannot hold the whole board (see
`game.cam.camrig`).
2. **The board.** The 80 `tile_<x>_<y>` plates: their tint, their grid
lines, the reachable-range wash, the previewed path, the selection ring
and the destination pin (see `game.cam.board`).
3. **The staging.** The greenhouse reveal, the beat where the blight turns
decisive, and the campaign's closing shot (see `game.cam.staging`).
It **reads** the rules and never writes them. Clicking a monk calls
`Director:select`; clicking a tile calls `Director:move` and shows the
referee's own refusal wording when it says no.
## Controls
`game.cam.tactical` — the commander's input map. Every control carries
keyboard, gamepad and touch.
| Control | Keyboard / mouse | Pad | Touch |
|---|---|---|---|
| Select | Left click | South | Select button |
| Turn the view | Hold right (or middle) button and drag | Right shoulder + right stick | Turn button + drag the right half |
| Zoom | Scroll wheel | Left stick Y | Pinch |
| Recentre | `F` / `Home` | North | Recentre button |
## Fields
| Field | Default | What it does |
|---|---|---|
| `inputMap` | `game.cam.tactical` | The controls. Point it elsewhere to rebind. |
| `orbitSpeed` | `0.26` | Degrees of yaw per pixel dragged. |
| `pitchSpeed` | `0.16` | Degrees of pitch per pixel dragged. |
| `zoomSpeed` | `2.2` | World units of dolly per zoom unit. |
| `autoReveal` | `true` | Play the greenhouse reveal once on entering play. |
| `ownSfx` | `true` | The board answers the pointer with its own clicks. |
| `sfxVolume` | `0.45` | How loud those clicks sit under the mix. |
| `blightBeatShare` | `0.42` | The share of the board the blight must hold before the game stops and looks at it. |
## What other slices can call
```lua
local board = entity.find("Board").component.get("Tactical")
board:hovered() -- { x, y, elev } under the pointer, or nil
board:selectedCell() -- { x, y } last clicked, or nil
board:selectedUnitId() -- the unit the player has selected, or nil
board:selectUnit(id) -- select one, and tell the referee
board:reachable() -- the referee's reachable cells, keyed by Core.key
board:pathPreview() -- { path, target, plan } under the pointer
board:station() -- the live camera station
board:setStation(s, snap)-- move the camera; any field may be omitted
board:focusTile(x, y) -- lean toward a tile without losing the board
board:recentre() -- back to the composed station
board:playReveal() -- the opening
board:playBlightTurn(x, y, share)
board:playClosing(outcome)
```
## Signals
**Obeys** `cameraFocus`, `unitSelected`, `unitMoved`, `phaseChanged`,
`missionEnded`.
**Emits** `unitSelected` (when the player picks a monk), `tileClicked`
(`{ x, y, unitId?, enemy?, refused? }` — the tile inspector's cue, and the
place a refusal arrives in plain words), `requestMove` (only when the
referee has no mover yet), `playMusic` (from the staged moments), and
`narrate` (`{ id, text, speaker }` — the audio slice may voice a staged
line; the text is on screen either way).
## Sound
The board's own clicks — `camTick`, `camSelect`, `camDeny`, `camSweep` —
are synthesised from raw PCM by `game.cam.camsfx` and cached as
`.soundClip` assets under `game/cam/`. They cost no credit and cannot fail
for a network reason. Clear `ownSfx` if the audio slice takes them over.
## No clock
Nothing here changes game state on a timer. The eased camera, the
breathing highlight and the cutscene clocks are presentation; the game
waits indefinitely for the player.
▲ 0↑ born
# UnitBodies
Every body standing on the board — the four gardener-monks and the Blight's
crystalline forms. It builds them, moves them, and gives each one a life of its
own: a distinct idle, an attack with anticipation and follow-through, cloth that
lags the motion, and a death that topples.
It changes **no game state**. Every clock in it drives a transform.
## Where it lives
On `MonkHost`, a child of the `Units` anchor. If it is not there — a fresh
engine, a scene reload — put it back with one line:
```luau
local host = entity.find("MonkHost")
or entity.spawn("MonkHost", { parent = entity.find("Units") })
if not host.component.get("UnitBodies") then
host.component.add("UnitBodies", {})
end
```
Each unit's body is a child of `MonkHost` named `unit_<unitId>`, and every part
of it is named `unit_<unitId>_<part>` (`_hips`, `_torso`, `_head`, `_armL`,
`_armR`, `_tool`, `_chain`, `_ember`, `_pack`, `_core`, `_halo`).
## Fields
| Field | Meaning |
|---|---|
| `demo` | stand a demo squad when no Director has published units (default true) |
| `stepTime` | seconds a body takes to walk one tile (default 0.30) |
| `attackTime` | seconds an attack takes, anticipation to recovery (default 0.95) |
## Calling it
Get it, then call with a colon:
```luau
local host = entity.find("MonkHost").component.get("UnitBodies")
```
| Call | Does |
|---|---|
| `host:spawnUnit(unitId, kind, x, y, facing)` | build a body — `kind` is a monk id or a blight form id |
| `host:despawnUnit(unitId)` | take it off the board |
| `host:placeUnit(unitId, x, y, facing?)` | put it on a tile with no animation |
| `host:moveUnit(unitId, path)` | walk a committed path; returns the seconds it will take |
| `host:attack(unitId, tx?, ty?)` | play the attack, turning to face the target first |
| `host:hurt(unitId)` | flinch |
| `host:kill(unitId)` | topple, and stay toppled |
| `host:setFacing(unitId, facing)` | turn on the spot; the hood arrives after |
| `host:bodyOf(unitId)` | the root entity — what a camera follows |
| `host:busy()` | is anything mid-move or mid-attack |
| `host:list()` | every unit id that has a body |
| `host:rebuild()` | flush the cached geometry and rebuild every body |
`path` is an array of `{ x, y }` tiles. `facing` is `"n"`, `"e"`, `"s"` or
`"w"`; `"n"` is up the board, away from the camera, toward the blight.
## It follows the referee on its own
Nothing has to tell it what is on the board. Three times a second it reads the
`Director` component's `snapshot()` and mirrors `snapshot.units`: it builds a
body for a unit that has none, drops a body whose unit has gone, moves one whose
tile has changed, and topples one whose `alive` is false. The unit's `kind`
picks the model; a `kind` it does not recognise falls back to a monk or a blight
shard by `side`, so an unfamiliar unit is still visible rather than invisible.
It also listens on the shared bus, so these arrive for free:
| Signal | What it plays |
|---|---|
| `unitMoved` | walks the `path` (or straight to `to`) |
| `unitActed` with `action = "attack"` / `"overwatchFired"` / `"signature"` | the attack |
| `unitDamaged` | the flinch |
| `unitDied` | the topple |
Until a Director publishes any units it stands a demo squad — the four monks and
one of each blight form — so the slice is provable on its own. The moment a
snapshot carries units, the demo squad is removed.
## What the animation is made of
- **A follower, not a keyframe.** Each body keeps a smoothed copy of its own
position and yaw. Everything that lags — hood, sleeves, censer chain, the roll
through the hips — is driven by the GAP between where the body is and where
the follower has got to. One piece of maths covers a turn, a walk, and the
recoil off an attack, and cloth settles instead of stopping dead.
- **Idles that are not the same sine wave.** Anselm breathes slowly and scans;
Meridia is quick and always working her apron; Cassian sways under the pack
and rides a pressure surge through it; Vespera barely moves while the censer
swings a cone on its chain and the ember breathes. The blight does not
breathe at all — the shard ticks and snaps, the spire's halo turns, the hulk
heaves.
- **An attack in four beats** — anticipation away from the target, a strike that
passes neutral, a follow-through that decays, then recovery. Each monk's own
weight is in it: Anselm swings the whole body through the arc, Meridia's sling
loops back and flicks, Cassian leans his mass in, Vespera's censer overshoots
her on the chain.
- **`editorUpdate` as well as `update`,** because a still board of monks reads
as a screenshot of a broken game.
## Two things to know
- `execute` gets its own require registry, so `Core.emit` from an `execute` call
does **not** reach this component's signal bus. Drive it with the methods
above when you are testing from `execute`; the signals work between components.
- The geometry is cached per model, so editing `monkbody` or `blightform` needs
`host:rebuild()` to be seen.
▲ 0↑ born
# Garden — the growing floor, on screen
The referee decides that a round has closed. This component is what you SEE
happen next: every plant easing into its next stage, a root-knot heaving its
flagstone up a step, a lightwood rising until the lane behind it is gone, and
the Blight taking the tiles it took.
It lives on `garden_keeper`, a child of the scene's `Garden` anchor, and owns
the bodies under it plus the HEIGHT of the tile plates under `Board`. It owns
no unit and no rule.
```luau
local G = entity.find("garden_keeper").component.get("Garden")
```
## The round
```luau
G:gardenTurn(round?) -- the garden's turn; returns the changes it animated
G:blightTurn(round?) -- then the Blight's
G:runRound() -- both, and the round number they belong to
```
It also listens for the referee's own signals and needs no call at all:
- `roundEnded { round }` runs both phases;
- `phaseChanged { phase = "garden" | "blight", round }` runs the matching one.
Each phase is guarded by the round number, so a phase delivered twice — by both
signals, or by a signal and a direct call — resolves once. **Pass the round**
when calling directly; without one it reads `state.round`, and a referee that
never advances it will see the second call decline.
What the garden did to whoever is standing in it is handed to the `Director`
component's `gardenEffect(effect)` if it declares one, and emitted as a
`unitDamaged` signal otherwise. The garden never writes a unit.
## Gardening
```luau
G:sow(x, y, kind) -- { ok, reason } — reason is written to be shown as-is
G:burn(x, y)
G:flood(x, y, rounds?)
G:cut(x, y) -- Anselm's Cut Back
G:floodRow(y) -- Cassian's Open the Line
G:seedBlight(x, y, stage?)
```
## Reading
```luau
G:describeTile(x, y) -- the tile inspector: terrain, detail, NEXT growth stage, cover, elevation, marks
G:coverAt(x, y) -- 0 none / 1 half / 2 full
G:blocksSight(x, y) -- true when a sightline dies on this tile
G:hazardAt(x, y) -- damage for ending a turn there
G:snapshot() -- every occupied tile + blightShare + threshold
G:blightState() -- { share, tiles, threshold }
```
## Rebuilding
```luau
G:layoutMission("heart_chamber") -- clear the floor and plant a room's opening garden
G:rebuild() -- rebuild every body from the board, no animation
```
`rebuild` throws the mesh cache away too, so it is also how a change to the
plant geometry reaches what is already standing on the board.
## Fields
| field | default | what it does |
|---|---|---|
| `autoLayout` | `true` | lay the mission's opening garden out on wake, when nothing is growing yet |
| `mission` | `""` | which room to open with; empty means whatever `state.mission` says |
| `sway` | `true` | cosmetic sway on the living plants — the Blight never moves |
| `growTime` | `0.75` | seconds a growth animation takes |
## The clock it does not have
`update` / `editorUpdate` move cosmetic tweens only — a stalk easing into its
new size, a plate rising, a vine breathing. No game state changes on a tick.
While the simulation is frozen no tick arrives, so growth started then arrives
at full size instead of leaving a half-grown plant standing on the board.
▲ 0↑ born
# Hud
The in-mission interface of Verdigris Cloister. It mounts four screens on a
1080x1440 portrait frame, keeps them fed from the board, and answers clicks
from the ability bar.
entity.spawn("HudRoot").component.add("Hud")
local hud = entity.find("HudRoot").component.get("Hud")
One instance is enough; it lives on its own root entity and needs no transform.
## Where the board comes from
1. the `Director` component's `snapshot()`, when the rules slice answers;
2. otherwise a worked demonstration board, so the interface always draws
something real. Turn that off with `demoWhenUnbound = false`.
## What it draws
- **The initiative queue** across the top: up to six painted portrait cards,
front first, each with its monk's tint down the left edge, an HP bar, an
overwatch mark, and a dagger over the dead. The wrap into next round is
marked with a numbered divider, so the queue reads far enough ahead to plan
against. Beside it, the round in roman numerals and the blight's share of
the greenhouse.
- **The board overlay**, which never takes pointer input: floating damage
numbers with weight (a critical is bigger, brighter and slower), the
destination chip naming the AP cost and the cover of the tile about to be
entered, and a short banner when a phase turns over.
- **The inspector**: the hovered tile's botanical plate, its name, its stage,
its cover and elevation chips, and — set off in gold — what it becomes next
round. When a shot is aimed it becomes the hit-chance stack instead: the
honest percentage on a dial, and every modifier itemised line by line with
its reason, then the damage range and critical chance.
- **The ability bar**: the active monk and their AP pips, the six standing
actions, that monk's own signature ability, Hold, and End Turn.
## The surface other slices call
hud:hoverTile(x, y) -- the pointer is over this tile
hud:clearHover()
hud:pinTile(x, y) / hud:unpinTile()
hud:previewDestination(x, y, apCost, cover, warn?)
hud:clearDestination()
hud:designate(attackerId, targetId, fallback?) -- open the hit-chance stack
hud:clearTarget()
hud:selectAction(actionId, hint?)
hud:setActionStates({ burn = { usable = false, reason = "no action points" } })
hud:floatAt(unitId, text, kind, sub?) -- damage / crit / heal / miss / death
hud:floatAtTile(x, y, text, kind)
hud:announce(title, sub?, tone?)
hud:report() -- what it is drawing right now
hud:rehearse() -- stage every state at once, for a look
Nothing is required. The picking slice owns `hoverTile` / `previewDestination`
/ `designate`; until it calls them the HUD finds the tile under the pointer
itself, by projecting every tile centre and taking the nearest.
## Signals it listens for
`unitDamaged` throws a number, `unitDied` a dagger, `phaseChanged` and
`roundBegan` a banner, `blightGrew` a mark on the tile, `unitSelected` and
`unitActed` clear the aim. It assumes no publisher exists.
## Sounds it asks for
Through `Core.sfx`, by the names the audio slice publishes: `ui_click` on an
ability, `ui_confirm` on end turn, `unit_select` on aiming a shot, `ui_hover`
as the pointer crosses onto a new tile.
## Callback ids
`hud.action.<id>` for every ability tile and `hud.endturn`. Each is a
transparent `button` laid over the styled tile, addressable as
`hud-action-<id>` and `hud-endturn` for `gui clickElement`.
▲ 0↑ born
# Director — the referee, standing in the scene
The rules live in `game.rules`. This component is the one place in the world
that **holds** them: it lays the mission out, mirrors the headline board state
onto fields anything can read, paces the Blight's own turn so a human can watch
it, and publishes the entire rules surface as methods.
That last part matters more than it looks. A module required from an `execute`
call and a module required from a component are the same instance here, but the
component is the copy the game is actually running — so **every other slice
reaches the board through this component**, and nothing has to know how the
rules are put together.
## Getting hold of it
```luau
local D = entity.find("rules_referee").component.get("Director")
```
It is hosted on `rules_referee`, a child of the `Director` anchor. If it is not
there — a fresh engine, a scene reload — put it back with one line:
```luau
local ref = entity.find("rules_referee")
or entity.spawn("rules_referee", { parent = entity.find("Director") })
if not ref.component.get("Director") then
ref.component.add("Director", { mission = "propagation_hall" })
end
```
## Fields
| Field | Meaning |
|---|---|
| `mission` | which mission to lay out (default `propagation_hall`) |
| `autoStart` | lay it out as soon as the referee wakes |
| `autoBlight` | let the referee play the Blight's turn by itself |
| `aiPace` | seconds between two actions of the **Blight's** turn |
| `phase` `round` `activeUnit` `outcome` `blightShare` `missionName` | read-only mirrors of the board |
`aiPace` is the only number in this game measured in seconds, and it only ever
paces the **enemy**. Nothing anywhere puts a clock on the player's own turn.
## Reading
`snapshot(opts?)` · `brief()` · `queue(count?)` · `tileInfo(x, y)` ·
`reachable(unitId)` · `pathTo(unitId, x, y)` · `hitChance(a, b)` ·
`targets(unitId)` · `abilities(unitId)` · `overwatchCone(unitId)` ·
`missions()` · `carried()`
`hitChance` returns the percentage **and** `mods`, an ordered list of
`{ id, label, value }` — base aim, range, cover, flank, elevation, wounds,
reaction — which is exactly the stack the HUD prints.
`reachable` and `pathTo` report `cover` (what the tile buys against the enemies
that can actually see it — the honest number for a cover indicator) alongside
`bestCover` (the best it holds in any direction).
## Asking permission
`canMove` · `canAttack` · `canOverwatch` · `canGarden` · `canUndo` — each
returns `{ ok, reason }`, and the reason is a sentence a screen can print:
*"It is Brother Anselm's turn, not Sister Vespera's."*
## Doing
`select` · `move` · `undo` · `attack` · `overwatch` · `garden` · `hold` ·
`endTurn` · `phaseDone` · `aiStep` · `startMission` · `setSeed` ·
`gardenEffect` · `setTile`
`gardenEffect({ unitId, amount, heal?, source?, cause? })` is how the garden
slice reports what its growth did to whoever was standing in it — the garden
decides what grew and who it touched, the referee owns health and death.
`setTile(x, y, patch)` is the one door through which growth reaches the board
the referee owns; it recomputes cover and the Blight's share for you.
## What it does per frame
Nothing, unless it is the Blight's turn and `autoBlight` is on — then one
enemy action every `aiPace` seconds until that turn is over. `update` is play
mode only; every method above works in edit mode too, which is how the board
can be inspected without running the game.
▲ 0↑ born
# tactical.inputMap
The commander's controls at the Kessrel Line, in three device classes.
| Action | Mouse + keyboard | Touch | Controller |
|---|---|---|---|
| Select a regiment | click it, or its card; `1`..`0` | tap it, or its card | `LB` / `RB` cycle |
| Select all | `Ctrl+A` | the ALL slab | `L3` |
| Add to the selection | hold `Shift` | the ADD slab latches | hold `LT` |
| Post here | click the ground | tap the ground | left stick aims, `A` confirms |
| Order cursor | the pointer | the finger | left stick |
| Cycle stance | `F` | the card's stance strip | `X` |
| Orbital Lance | `Q`, then click | Lance button, then tap | `Y`, then `A` |
| Mortar Barrage | `E`, then click | Barrage button, then tap | `RT`, then `A` |
| Rally | `R` | Rally button | `D-pad left` |
| Cancel an armed ability | right click | tap the lit button again | `B` |
| Pan the view | `A`/`D`, `←`/`→`, `↑`/`↓`, edge pan | drag the canyon | right stick |
| Zoom | wheel, `W`/`S` | pinch | `D-pad` up / down |
| Recentre | `C` / `Home` | the RECENTRE pip | `D-pad right` |
| Pause | `Esc` / `P` | the pause pip | `Start` |
Group `commander`; it suppresses `player`, which takes the engine's default
touch floor off the screen so the HUD is the only thing a finger meets.
A control whose `touch` class reads `false` has its touch counterpart on the
HUD instead — that is the command slice's own on-screen control surface, and
`/zero/source/ui/hud/` draws it.
▲ 0↑ born
▲ 0↑ born
▲ 0↑ born
▲ 0↑ born
▲ 0↑ born
# orbit
<!-- zero:scaffolded-readme -->
<!-- Replace the line below with what this inputBinding provides and who
consumes it, then delete both comment lines. -->
TODO: describe this inputBinding.
▲ 0↑ born
# orbitDrag
<!-- zero:scaffolded-readme -->
<!-- Replace the line below with what this inputBinding provides and who
consumes it, then delete both comment lines. -->
TODO: describe this inputBinding.
▲ 0↑ born
# recentre
Return the view to the middle of the line at the composed distance.
▲ 0↑ born
# select
<!-- zero:scaffolded-readme -->
<!-- Replace the line below with what this inputBinding provides and who
consumes it, then delete both comment lines. -->
TODO: describe this inputBinding.
▲ 0↑ born
# zoom
Zoom the commander's camera in and out at a held rate.
▲ 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.