·
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.
68+items
# Penguin
How the rockhopper moves up the Luteway. It sits on the player body the scene
spawns, reads the `luteway.climb.climb` scheme, and writes `LW.state.player`
every frame. What the body LOOKS like belongs to the penguin slice, reached
through the handle `LW.provide.makePenguin` returns.
## The moves
| | |
|---|---|
| **Sidle** | `move` — one axis. Lute drags at it; ice takes the feet out from under a penguin not carrying enough lute to grip. |
| **Hop** | `hop` — the press launches, the hold decides the height. Letting go while still rising cuts it short. Coyote time after a ledge ends, and a hop asked for just before landing is kept. |
| **Cling** | Automatic. Airborne, falling, feet at `clingNeeds` or stickier, and steering into the cliff wall. The penguin sticks and slides down it slowly. |
| **Kick off** | `hop` while clinging. It leaves the wall at nearly twice the sidle speed and at FULL height whatever the feet carry — the wall is only reachable because they are sticky, so the lute does not shorten it. For a beat afterwards the kick owns the horizontal, or the steering still pressed into the wall would cancel it. |
| **Shake** | `shake` — sheds every trace of lute, grounded only, and roots the penguin for `shakeStun` seconds. That beat is its whole cost, and the sea keeps rising through it. |
## The numbers that matter
A clean full hop clears `LW.reach()`. One landing on lute takes that down by
about fifteen percent, two by a third, and `LW.hopHeight(sticky)` /
`LW.hopSpan(sticky, rise)` give the exact figures — which is how a route's
ledge spacing and this controller stay in agreement. Every one of them lives in
`LW.PENGUIN`.
## What it publishes
`LW.state.player` — `x y vx vy facing grounded clinging sticky shaking surface
entityId` — plus the events `hop`, `land`, `cling`, `slip`, `shake`, `sticky`,
and an `LW.sfx` one-shot beside each.
## Staying wired
Reloading `luteway.game` gives it a new event bus and a new blackboard while
this component keeps running, so the controller checks each frame that the
blackboard still names its body and that a probe on the bus comes back. When
either says otherwise it binds the controls and the reset listener again. It
does not re-place the penguin: a reload mid-run must not send it back down to
the beach.
▲ 0↑ born
# luteway.cliff.Cliff
The Luteway itself, and the dawn over it. It publishes the authored route
(`LW.provide.level`), stands that route up as rock, and paints the morning.
`LW.state.dawn.t` becomes the sky's colour, the colour and direction of the
light, and a band of first light creeping down the cliff face
(`LW.state.dawn.lightY`). The sea stands at `LW.state.tide.y` and rises with it.
Everything it spawns is temporary and rebuilt on every load, so none of it is
written into the scene file. The route's SHAPE lives in `luteway.cliff.level`;
the rock it is carved from lives in `luteway.cliff.geo`.
## Depth without perspective
The camera is orthographic, so depth cannot be read off convergence and the
procedural sky arrives as one flat colour — every view ray is parallel. Both are
answered the same way, by painting:
- Five layers drift with the camera by different fractions (`backdrop`, `sky`,
`far`, `mid`, `play`, `fore`), and the far ones barely move.
- The sky is a card, two graded bands and a disc that climbs out of the sea.
- The terminator between night and first light is two wavy sheets of shadow and
three stacked bands of glow.
## Fields
| Field | What it does |
|---|---|
| `dawnFrom` / `dawnTo` | The sky hour at each end of the run. |
| `seaZ` | How far in front of the play plane the sea stands, so a drowning penguin goes under it. |
| `dawnPreview` | Hold the morning at a point (0 = before sunrise, 1 = full first light) to look at it. Negative lets the run's own clock drive it. |
▲ 0↑ born
# Game
The loop of *First Light: Luteway*. It sits on `mount_game` and is the only
writer of `LW.state.phase`, `LW.state.run`, `LW.state.tide` and
`LW.state.dawn.t`.
```
title ──start──▶ opening ──(staging releases)──▶ play ──▶ won | lost
│ pause ▲ resume
▼ │
paused ───┘
```
A screen moves the loop with `LW.emit("uiRequest", action)` — `start`, `pause`,
`resume`, `restart`, `title` — and this answers. The opening is held while the
staging slice has `LW.state.stagingBusy` set, and released on its own after nine
seconds so a missing or mid-edit crane can never leave the player without
control.
## The two clocks
**The sea** is defined by WHEN it takes the rookery rather than by how fast it
rises, so a route of any height gets the same deadline and the same shape of
pressure: slow at first, gathering, over the crest at `RUN.drownSeconds`.
Standing on the beach doing nothing drowns in about fifteen seconds; a run that
keeps moving has room, and one that dawdles does not.
**The light** runs on the clock too, but it can never fall behind the penguin:
`dawn.t` is the greater of the clock's share and the climb's, and only ever
increases. A fast climber arrives into a dawn that kept up with them; a slow one
gets it anyway. The cliff slice turns that number into the sky, the sun and the
light line coming down the rock.
## Ends
Lose when the sea reaches the penguin's chest. Win when it is standing on the
rookery ledge — `dawn.t` goes to 1 and `firstLight` fires with it.
## Staying wired
Reloading `luteway.game` gives it a new event bus while this component keeps
running, and every subscription made against the old one is gone: the loop would
answer no button on any screen, and nothing would report an error. So it emits a
probe on the bus once a second and subscribes again when its own handler does not
answer.
▲ 0↑ born
# FollowCam — the camera of the Luteway
The one camera in *First Light: Luteway*, and the lens every staged moment
borrows. Orthographic, side-on, never rotating, never leaving the
`LW.CAMERA.z` plane. It sits on the scene's `CameraRig` as the `Camera`
component's `behavior`.
## The frame
The lens fixes the **height**: `LW.CAMERA.orthoHeight` world units, at every
aspect. So a phone held upright sees a narrow tall slice of cliff and a wide
monitor sees the same height with more cliff either side, and the climb reads
the same on both. Nothing here is a pixel — the only thing the screen's shape
decides is how much cliff stands beside the climb, which is recomputed from
the live `ui.screenSize()` every frame.
Two rules keep that honest at the extremes:
* **Narrow.** When the frame is narrower than the cliff it clamps to the level
and the horizontal deadzone starts doing work; when it is wider, the climb
is centred and the frame stops moving sideways at all.
* **Wide.** A frame wide enough to see past the dressed cliff
(`LW.CAMERA.dressHalfWidth`, ±15 units — the contract with the cliff slice)
closes the lens until it cannot, down to `LW.CAMERA.minHeight`. A 21:9
screen therefore sees 30 units across and 12.8 up, not 15 units of nothing.
## The follow
It tracks `LW.state.player` — the blackboard, not an entity, because the climb
slice runs its own 2D sim. A horizontal deadzone the penguin moves inside
freely, a lead in the direction it is sidling, an upward lead so the next ledge
is always in shot, a look further ahead into a long fall, and a softer vertical
time constant so a landing reads as weight.
A landing puts its weight into the frame: the shot **dips** in proportion to
the speed it landed at and eases back, and past `LW.CAMERA.kickAt` it **kicks**
as well. `landingWeight` scales both; 0 turns them off.
The frame never looks under the water. The sea line may sit at most
`LW.CAMERA.seaFloor` units above the bottom of the frame, so as the tide takes
the beach the shot is pushed up ahead of it and the penguin sinks toward the
bottom of the screen — which is the picture that moment wants.
Where it ended up is published into `LW.state.camera` — `x`, `y`,
`orthoHeight`, `halfWidth`, and `staged` (true while a moment holds the frame).
## The shot API
| Call | What it does |
|---|---|
| `:panTo(x, y, seconds, ease)` | a TIMED move along an eased curve; `:isPanning()` says when it arrives |
| `:zoomTo(height, seconds, ease)` | a TIMED change of lens. 16 is the playing frame, 9.5 a push, 26 the cliff opening out |
| `:driveTo(x, y)` | the untimed, damped drive |
| `:snapTo(x, y)` | a cut |
| `:setDrift(vx, vy)` | a slow creep added to a driven shot — a held frame that drifts is alive |
| `:kick(amount)` / `:settle(amount)` | the shake, and the weight of a landing |
| `:release()` | hand the shot back to the penguin |
| `:pose()` / `:lens()` / `:frame()` | where the shot is, how much it covers, and the world rectangle it covers |
| `:frameAt(aspect)` | the rectangle it *would* settle to on a screen of that shape |
Ease names: `linear` `inQuad` `outQuad` `inOutQuad` `outCubic` `inOutCubic`
`inOutSine` `outExpo`.
`Staging.component` is the only thing that drives these in the finished game.
`:frameAt()` is how any slice asks what a phone, a laptop and a television each
see of the same moment without changing the screen.
## In edit mode
It poses in edit as well as in play, so authoring against the scene shows the
game's frame, and a staged moment can be rehearsed without entering play and
locking the VFS for the other slices.
## Usage
```lua
rig.component.add("Camera", {
projection = "orthographic",
orthoHeight = LW.CAMERA.orthoHeight,
behavior = asset.resolve("luteway.camera.FollowCam", "component"),
})
```
Owned by the camera slice. Tuning lives in `LW.CAMERA` in `luteway.game`.
▲ 0↑ born
# game
<!-- 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
# PenguinArt
The rockhopper's body, mounted. It sits on `mount_penguin` in `scenes.main`.
## What it owns
- The meshes, the wear maps and the ten materials the bird is made of, built
once per session through `luteway.penguin.pgart`.
- `LW.provide.makePenguin` — the slot `luteway.climb.Penguin` reaches for the
first frame it needs a pose. Every body carrying a `Penguin` gets dressed
through it, the local player's and every joining player's alike.
- The pose clock: the squash of a landing, the stretch of a launch, the waddle,
the flipper flap, the lean into a wall, the wet flail of a shake, and the lute
thickening on the feet as the stickiness climbs.
## Fields
- `body: string` (default `"penguin"`) — the name of the body entity the bird is
built on when nothing is playing. In edit there is no local player, only the
prototype body the scene carries; this is how it gets dressed anyway, so the
bird is there to look at without pressing play.
## Notes
- `update` and `editorUpdate` both drive the pose, and `editorUpdate` returns
early unless the gameplay clock is held — otherwise the two would tick the
same body twice in one frame and the bird would animate at double speed.
- A module reload hands the component a fresh `pgart` whose rig table is empty
while the parts the previous one spawned are still standing under the body.
Once a second, an empty rig table and a body still standing is the signal to
dress it again; `pgart.make` clears the orphan parts as it rebuilds. That is
why the bird does not freeze mid-pose when a neighbouring slice edits something
this one depends on.
- Removing the component clears every rig and releases the provide slot.
▲ 0↑ born
# Screens
Puts every authored screen of *First Light: Luteway* 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 |
|---|---|---|
| `lw-menu` | 960 | whichever card the phase calls for |
| `lw-hud` | 120 | the height and dawn readout, the lute gauge, the cliff rail, the pause pip, the sea warning |
The HUD is two vertical rails down the **left** edge with the readout above
them and the pause pip opposite. Nothing spans the frame: the game films at
1080x1440, and the engine's own touch overlay lives in a band on the right, so
a bar across the top would fit neither.
## What decides which card is up
`LW.state.phase`, which the `climb` slice's `Game.component` owns.
| Phase | Card |
|---|---|
| `title` | the title card |
| `opening` | none — the staged crane, with the frame to itself |
| `play` | none — the HUD |
| `paused` | the pause card |
| `won` / `lost` | first light, or the sea |
*How to play* is an overlay over whichever card opened it, not a phase, so it
reads the same from the title card and from the pause card.
When the player takes a line, this component emits `uiRequest(action)` —
`"start"`, `"pause"`, `"resume"`, `"restart"`, `"title"` — and waits. If
nothing has moved the phase within a moment it moves the phase itself, so the
game is reachable from its own title card whatever else is loaded. The moment
`Game` answers `uiRequest`, that fallback stops firing on its own.
## Controls
`uimenu` is activated the instant a card goes up and released the instant the
last one comes down; it stands down `climb`, `player` and `uipause` while it is
live. `uipause` stays live through play and carries the control that opens the
pause card.
- **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 crest-yellow ring, a lit edge marker and a
diamond, and shifts a few points to the right.
- **Choose** on `confirm` (Enter, Space, south), **leave** on `back` (Escape,
Backspace, right mouse, east), and an end card also answers `restart` (R,
north).
- **A pointer or a thumb** takes a line by touching it, which also moves the
ring there, so a player who mixes a mouse and a pad never loses their place.
- Each card carries the legend for the family in the player's hands, read from
`/runtime/input/device` and published as `LW.state.device`. The how-to card
redraws its whole control table for that family.
## Public fields
- `menuMap: assetRef(inputMap)` — the menu scheme. Default `uimenu`.
- `pauseMap: assetRef(inputMap)` — the pause control. Default `uipause`.
## Methods
- `:repaint()` — force the next tick to rebuild every screen. The screens are
repainted only when their own inputs change, and a hot reload of `lwui` is
not one of those inputs, so this is how an edit to the design system reaches
the glass without restarting anything.
- `:focus()` — `{ card, id, device }`: the card that is up, the line the ring
is on, and the family being drawn for.
- `:setDevice(name?)` — pin the family the legends and the how-to card are
drawn for; `nil` hands it back to the device counters.
## Lifecycle
- `awake()` — paints the first frame.
- `update(dt)` / `editorUpdate(dt)` — one tick either way: reads the device,
resolves the card the phase asks for, activates or releases the menu scheme,
and repaints only the screens whose inputs changed.
- `onDestroy()` — releases both schemes and unregisters every screen it put up.
▲ 0↑ born
# uipause.inputMap
The one control that stays live through a climb: open the pause card.
Its `group` is `uipause`, which `uimenu` stands down while any card is up, so
the key that opened the card cannot close and re-open it in the same frame.
`Screens.component` activates this map for the whole life of the component and
acts on it only while no card is showing.
## Controls
| Control | Kind | Keyboard / mouse | Gamepad | Touch |
|---|---|---|---|---|
| `pause` | button | Escape | Start | a small button in the right-lower zone |
The HUD also draws its own pause pip at the top left, opposite the engine's own touch band, which a pointer or a
thumb can take directly.
▲ 0↑ born
# stage.inputMap
The one control a staged moment gives the player: **Skip**.
`luteway.camera.Staging` activates this map when a beat starts holding the
loop and deactivates it the moment the beat ends, so the Skip button exists for
exactly as long as there is something to skip. It suppresses nothing — the
penguin's own controls stay live and Skip simply stands beside them.
| | |
|---|---|
| Group | `stage` |
| Controls | `skip` |
▲ 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↓ import
# climb
The penguin's own controls: sidle, hop, shake the lute off. Three controls,
each carrying a keyboard, a pad and a thumb at once, so the cliff plays the same
way whatever is in the player's hands.
| Control | Keyboard | Pad | Touch |
|---|---|---|---|
| **Move** | A / D | left stick | the on-screen stick, left of the glass |
| **Hop** | Space, W, ↑ | South | the large button in the bottom-right corner |
| **Shake** | Shift, X | West | the button above Hop |
Hop is a hold as much as a press — the longer it stays down, the higher the
penguin carries — and every device reads that the same way.
The group is `climb`, and it stands down the engine's `player` group while it is
live, so the only controls on a phone's screen are the ones the penguin
actually answers to. `luteway.screens.uimenu` stands `climb` down in turn while
a card is up, which is why the Hop and Shake buttons leave the screen on the
title, the pause card and the end cards, and come back with the run.
The touch layout is a column up the right edge with Hop in the corner: on a
phone held upright, the one control a thumb finds without looking is the one it
reaches for most, and Shake is a place further away because shaking costs a beat
and should be aimed for.
▲ 0↑ born
# Staging — the three moments the camera takes off the player
Mounted on `mount_staging` by the scene's entrypoint. It owns no camera of its
own: it drives `luteway.camera.FollowCam` through that component's shot API, so
there is exactly one thing posing the lens and a moment can never fight the
follow.
## The moments
| Beat | Cue | What the frame does |
|---|---|---|
| **The opening** | phase `opening` | Holds on the dark rookery crest — the place the run is *for* — then cranes the whole length of the Luteway down to the penguin on the beach. `LW.state.stagingBusy` holds the loop until it lands. |
| **First light, in play** | `firstLight`, or `LW.state.dawn.lightY` crossing the penguin | A short push of the LENS only, and back. A breath, not a cut: the follow keeps the frame and the player never loses control. |
| **First light, the win** | phase `won` | Pushes in on the penguin at the crest, holds while the sun clears the sea, then cranes up into the light with a drift on the held frame. |
| **The sea** | phase `lost` | A kick as the wave lands, then a slow pull back until the whole drowned Luteway is in frame. |
Everything is in world units and seconds. Nothing here reads the screen, so
every beat plays the same on a phone held either way and on a television; what
changes with the shape is only how much cliff stands beside the climb, which is
the follow camera's business.
## Skip
The crane holds the loop for about seven seconds. A player seeing the Luteway
for the first time wants that; a player on their ninth run does not, so the
crane is skippable from **every** device family, through
`luteway.camera.stage.inputMap`:
| | |
|---|---|
| Mouse + keyboard | Space, Enter, Escape |
| Controller | South (A / Cross), East (B / Circle) |
| Touch | a **Skip** button, added to the far end of the touch band so the penguin's own buttons keep the positions a thumb already knows |
The map is live only while a beat is holding the loop, and it suppresses
nothing — the Skip button simply joins the climb controls for those few
seconds and leaves again. `:skip()` does the same thing from code.
## Rehearsing without play mode
The sequencer ticks in edit mode as well as in play, so a beat can be watched
without entering play and locking the VFS for the other slices:
```lua
entity.find("mount_staging").component.get("Staging"):rehearse("opening")
```
`"opening" | "firstLight" | "won" | "lost" | "release"`. `:current()` names the
beat that owns the frame, or `""` when the penguin has it.
## Fields
| Field | |
|---|---|
| `craneSeconds` | how long the opening crane takes to fall the length of the Luteway |
| `stageMoments` | off leaves the follow camera alone for the whole run |
| `inputMap` | the map carrying Skip |
A beat that somehow overruns cannot wedge the loop: `stagingBusy` is released
after 30 seconds whatever happens, with a warning, and `Game` has a budget of
its own on top of that.
Owned by the camera slice. Lenses and timings live in `LW.CAMERA` in
`luteway.game`.
▲ 0↑ born
# Sound
Everything *First Light: Luteway* is heard as. It sits on `mount_sound` and is
attached by the scene entrypoint; it spawns its own emitters as temporary
children, so nothing it makes is written into the scene file.
## Five voices
| voice | clip | what it does |
|---|---|---|
| `bed` | `lw_bed` | pre-dawn wind and the sea below, looping under everything — and leaning in as the tide climbs toward the penguin's feet |
| `low` | `lw_score_low` | the pad, there from the title card on |
| `mid` | `lw_score_mid` | a plucked figure that arrives as the sky starts to turn |
| `high` | `lw_score_high` | bells and glass, which only the first light brings |
| sfx | — | one non-spatial source every one-shot is fired through, so any number of them overlap |
The score is one piece in three layers, not three pieces. All three run from
the first frame at silence and are faded by `LW.state.dawn.t`, so the music
**brightens with the light** rather than switching tracks: `mid` comes up
across `t = 0.10 … 0.45`, `high` across `t = 0.45 … 0.85`. Their loops are 12 s,
8 s and 6 s, so they phase against each other and the repeat is hard to hear
over a two-minute climb.
## What each moment sounds like
The one-shots answer **both** the explicit `LW.sfx(name, opts)` request and the
gameplay events themselves — `hop`, `land`, `cling`, `shake`, `slip`, `won`,
`lost`, `firstLight` — de-duplicated inside a 40 ms window. So the game is heard
whether or not the slice that caused the moment remembers to ask for a sound,
and asking twice is not heard twice.
- **hop** is pitched by its power: a full hop is lower and longer, a tap is
quick and high.
- **land** picks its clip from the ledge kind — `rock` thud, `ice` ring, `lute`
squelch — and is louder the harder the landing.
- Near the crest the **rookery** answers: single brays and, now and then, the
whole colony, both louder the closer the penguin is to the top.
- With the sea within three units of the feet, a **surge** is heard every few
seconds.
- **won** plays the first-light chord, the colony under it and seven brays over
the top, none of them in tune with another. **lost** is the wave, twice.
Nothing is spatial. The mix is 2D on purpose: the camera is orthographic and a
side-on climb has no near and far to speak of, so it costs the listener nothing
to be somewhere else.
## Mixing
`master`, `musicLevel`, `ambientLevel` and `sfxLevel` are the four levels, set
on the mixer's `music` / `ambient` / `sfx` channels. Everything at full volume
is the same as nothing, so the bed and the score sit well under the one-shots
and the loudest thing in the game is the sea taking the beach.
`chatter` turns the rookery off (`0`) for a quiet capture.
## Checking it without hearing it
```luau
local sound = entity.find("mount_sound").component.get("luteway.sound.Sound")
sound:report() -- clips loaded, each voice's live volume and target
sound:cue("land_ice") -- fire one clip, without playing to the moment for it
audio.observe() -- what the mixer says is actually sounding
audio.levels() -- the master meter, which cannot be argued with
```
▲ 0↑ born
# skip.inputBinding
Cuts a staged moment short and hands the frame back to the penguin.
| Device | Binding |
|---|---|
| Mouse + keyboard | Space, Enter, Escape |
| Controller | South (A / Cross), East (B / Circle) |
| Touch | a **Skip** button, priority 95 so it is added to the far end of the touch band and the climb buttons keep the positions a thumb already knows |
▲ 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↓ import
# 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↓ import
# 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↓ import
# 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↓ import
# 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↓ import
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.