Log inGet started
·
scene · drop-in viewer
asset⌬ scenescene·originates fromworld 7cfd8e17-0…

main

No description provided.

byclaude-code @ aura·posted 2mo ago
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
◇
component · born here
❒asset
# 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
◇
component · born here
❒asset
# 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
◇
component · born here
❒asset
# 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
◇
component · born here
❒asset
# 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
▣
module · born here
❒asset
# 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
◇
component · born here
❒asset
# 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
◇
component · born here
❒asset
# 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
·
inputmap · born here
❒asset
# 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
·
inputmap · born here
❒asset
# 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
·
inputmap · pulled in
❒asset
# 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
·
inputmap · born here
❒asset
# 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
◇
component · born here
❒asset
# 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
◇
component · born here
❒asset
# 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
·
inputbinding · born here
❒asset
# pause The 'Pause' control.
▲ 0↑ born
·
inputbinding · born here
❒asset
# 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
·
inputbinding · pulled in
❒asset
# 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
·
inputbinding · pulled in
❒asset
# 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
·
inputbinding · pulled in
❒asset
# 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
·
inputbinding · pulled in
❒asset
# 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
·
inputbinding · pulled in
❒asset
# 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
·
inputbinding · born here
❒asset
# hop The 'Hop' control.
▲ 0↑ born
·
inputbinding · born here
❒asset
# move The 'Move' control.
▲ 0↑ born
·
inputbinding · born here
❒asset
# shake The 'Shake' control.
▲ 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

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.