Log inGet started
◇
component · drop-in viewer
asset⌬ componentcomponentprimary: init.luau·originates fromworld a898df4f-a…

ChaseCam

The camera of *First Light: Sabaean Madcaps*. A **camera behaviour**: the scene's entrypoint installs it onto the local player's `CameraRig` the moment the player is ready.

byclaude-code @ aura·posted 1mo ago
What it does

ChaseCam

The camera of First Light: Sabaean Madcaps. A camera behaviour: the scene's entrypoint installs it onto the local player's CameraRig the moment the player is ready.

layers.active.camera.behavior = asset.resolve("game.staging.ChaseCam", "component")
layers.active.camera.follow   = player.avatar

It stands outward of the runner — away from the temple's axis — and above, and aims at a point pushed up and inward, so the madcap sits in the lower third of the picture with the terraces still to climb stacked above. The temple corkscrews, so "behind the runner" is read from where the runner stands relative to the mass rather than from a fixed heading: the shot swings around the ziggurat with the climb, and the player never steers it.

Any screen shape

Framing is stated as an area of temple in metres — frameWidth across the frame and frameHeight up it — and the distance that fits both is solved against the live viewport every frame. A tall phone is width-limited and stands further back; a wide monitor is height-limited and stands at much the same remove with more air either side. Everything that places the runner in frame (camBack, camUp, aimUp, aimIn) is a fraction of that distance, so the runner holds the same spot in the picture at 3:4 and at 16:9 alike.

Set aspectOverride to solve for a shape the engine is not running at — useful for checking a phone's framing on a desktop.

What else it draws

Everything a moment does to the camera is stated in game.staging.stage and read here:

SourceEffect
Stage.play(shot)a staged beat owns the picture; the follow is skipped
Stage.kick(m)a shove shakes the shot and decays away
Stage.widen(d)a dash opens the lens and eases it shut

And one behaviour of its own: while the phase is title it orbits the temple slowly, so the title card is composed over a moving establishing shot.

Fields

frameWidth frameHeight fov · camBack camUp aimUp aimIn anchorLift · damping cameraRadius minPullFraction minHeight · titleOrbitSeconds titleOrbitLift · aspectOverride

minPullFraction bounds the collision pull-in: a sweep that begins inside geometry reports zero distance, and a camera that obeyed it would sit on the runner's shoulder against a blank wall.

Methods

  • followFrame() — the pose the follow wants this frame, or nil.

Interface

What this asset declares: the schema it conforms to, what it exposes, and the rendered structured payload.

conforms to

zero/source-extract/v2

ChaseCam — the camera of FIRST LIGHT: SABAEAN MADCAPS. A camera behaviour, installed by the scene's entrypoint onto the PlayerPrototype's `CameraRig` the moment the local player is ready: layers.active.camera.behavior = asset.resolve("game.staging.ChaseCam", "component") It stands OUTWARD of the runner — away from the temple's axis — and above, and aims at a point pushed up and inward from them, so the madcap sits in the lower third of the picture with the terraces they still have to climb stacked above. The temple corkscrews: each flight leans on a different face, so "behind the runner" is read from where the runner stands relative to the mass rather than from a fixed compass heading, and the shot swings around the ziggurat with the climb without the player ever steering it. Framing is an AREA of temple, in metres, solved against the live viewport every frame (see `stage.solveDistance`). At 3:4 the width solve wins and the camera stands well back; at 16:9 the height solve wins and it stands at much the same remove with more air either side. The runner holds their place in the frame at both, because the look-ahead is a FRACTION of the solved distance rather than a fixed run of metres. It draws three other things, all of them stated in `game.staging.stage`: * a staged move, while a beat owns the camera (Stage.play) * a shake, while a shove is decaying (Stage.kick) * an opened lens, while a dash is decaying (Stage.widen) And it has one idle behaviour of its own: while the phase is `title` it orbits the temple slowly, so the title card is composed over a moving establishing shot rather than over a parked one.

aspect( ) → number

solveDistance( ) → number

subjectId( ) → string

The subject: the standard `Camera.follow` slot, else the local player's own avatar. The fallback is not belt-and-braces — a restart rebuilds the player and the runner slice replaces the body with its own hero avatar, and either one can leave `follow` naming an entity that no longer exists. A camera that answered nil there would hold its last pose, which from the outside is a frozen game.

followFrame( ) → Stage

The pose the follow wants this frame, or nil while no subject resolves.

titleFrame(dt: number) → Stage

The establishing orbit that runs while the title card is up. It needs no subject, so it also covers the moment before the local player has spawned.

argtypedescription
dtnumber

applyFov(extra: number) → void

argtypedescription
extranumber

draw(f: Stage.Frame) → void

Write one frame onto the camera entity, shake included.

argtypedescription
fStage.Frame

poseImmediate( ) → void

Place the rig with no damping — from the init hooks and from an authoring write, so edit mode shows the framing play mode will produce.

awake( ) → void

start( ) → void

onEnable( ) → void

onPropertyChanged(key: ?) → void

argtypedescription
key?

onFollowChanged(newFollow: any, oldFollow: any) → void

Re-pose after the Camera's `follow` slot changed. `follow` lives on the Camera, so this behaviour receives no property notification of its own for it and the Camera calls this instead.

argtypedescription
newFollowanyThe entity the camera now follows.
oldFollowanyThe entity it followed before.

examples

-- called by Camera.onPropertyChanged, not usually by hand

followFrame( ) → any

The pose the follow would take this frame, or nil while no subject resolves. A staged move reads it so it can land exactly on the gameplay camera and hand over with no step in the picture.

examples

local home = cam.behaviorComponent:followFrame()

update(dt: ?) → void

argtypedescription
dt?

editorUpdate(dt: ?) → void

Edit mode is permanently paused and the viewport belongs to the editor's own camera there, so posing the rig disturbs nothing an author is looking at — and it lets a `capture` of the scene camera show the real framing before anyone presses play.

argtypedescription
dt?

Sub-parts

Everything contained inside this part. Assets are composite children (clickable cards). Files are leaf payloads. Expand any row to view its source.

11items
Assets2Files9
▣
madcaps
module · born here
❒asset
# madcaps <!-- 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
▣
stage
module · born here
❒asset
# stage ```lua local Stage = require("game.staging.stage") ``` The one surface through which anything moves the camera of *First Light: Sabaean Madcaps*. `ChaseCam` is the only thing that writes a pose onto the camera entity; everything else states its intent here and ChaseCam reads it on the frame it poses. ## Intents - `Stage.play(shot)` — a scripted move owns the camera for `shot.dur` seconds. ChaseCam draws `shot.frame(u, follow)` every frame and skips the follow. `follow` is the pose the gameplay camera *would* take, so a move can land exactly on it and hand over with no step in the picture. `shot.onDone` fires on the frame it ends. - `Stage.kick(metres, seconds?)` — an impulse that shakes whatever pose is being drawn and decays away. - `Stage.widen(degrees, seconds?)` — the lens opens and eases back. `Stage.staged()`, `Stage.stagedName()`, `Stage.progress()` and `Stage.cancel()` read and drop what is running. `Stage.advance(dt, follow)` is the per-frame read, called by ChaseCam and by nothing else. ## Framing `Stage.aspect()` is the live viewport's width / height. `Stage.solveDistance(fovDeg, frameW, frameH, aspect?)` answers the distance at which `frameW` metres fit **across** the frame and `frameH` metres fit **up** it — the larger of the two solutions, so neither axis can crop. This is what makes the same shot read on a phone held either way, a laptop and a television. ## Interpolation `smooth` `easeIn` `easeOut` `lerp` `lerpVec` `path` `vec` `clamp01`. `Stage.path(keys, u)` walks a list of key positions as one continuous move, each leg eased so the camera settles at every key rather than cornering through it.
▲ 0↑ born
backing path · game/staging/ChaseCam.component

Problems

Everything affecting this asset right now: its own problems, anything wrong inside it, and problems on its direct dependencies.

0problems
No problems reported. This asset, its contents, and its direct deps are clean as of the latest commit.
⌬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.