Camera

The world's viewport — a "look-at point" in world space, plus an orientation and a zoom factor — that downstream presentation components (notably Scene) use to decide what part of the world ends up on screen.

Every World owns exactly one Camera, attached automatically at construction and accessible as a typed reference via World.camera. There is no opt-in registration, no name to remember, and no risk of the camera being missing — engine code that reads it can treat its presence as an invariant.

Semantics

The camera is a look-at point, not a pan offset:

• Camera.position is the world-space coordinate the camera is currently pointed at. Scene maps that point to the centre of the canvas — set camera.position to the player's position once per frame and the player stays anchored on screen as they move.
• Camera.rotation is the camera's roll, in radians. Scene applies its inverse to the scene container, so increasing the value rotates the world clockwise underneath a stationary viewer.
• Camera.zoom scales the rendered view; values greater than 1 zoom in (objects appear larger), values between 0 and 1 zoom out.

All three fields default to a neutral state. With the default camera, the world's origin appears at the centre of the canvas, the world's axes line up with the canvas's, and one world unit equals one screen pixel.

Shake

Camera.shake kicks off a temporary, decaying random offset applied to the rendered view — the staple "impact" feedback for hits, explosions, and screen-jolts. The shake lives entirely on the render side: it adjusts Camera.shakeOffset each tick during the camera's own onUpdate, and Scene reads that offset when it applies the container transform. The logical Camera.position and Camera.rotation are untouched, which means

• Mouse (and any other code routing through Scene.screenToWorld) keeps landing on the world point the player actually aimed at, not a phantom shifted by the shake.
• Game logic that reads camera.position (e.g. a follow controller centring on the player) sees a stable value, not a jittering one.

Intensity is expressed in screen pixels so the visual magnitude is independent of zoom. Starting a new shake while one is already in flight replaces it — the engine does not currently stack shakes.

Why this isn't a WorldObject

The camera looks superficially like it wants to be a WorldObject — it has a transform, it sometimes follows a moving target. But a WorldObject is a thing inside the world (findable by tag, iterated during update, destroyable). The camera is the lens through which the world is observed; modelling it as a sibling of every game entity conflates the two roles. As a world-scoped component it stays out of findByTag, never appears in object iteration, and can't be accidentally destroyed.

// Camera-follow-player: copy the player's position into the camera once
// per frame so the player stays centred on screen. Run inside the
// player's `onUpdate` so Scene's post-update transform sync sees a
// settled camera before drawing.
class CameraFollow extends AbstractWorldObjectComponent {
  public onUpdate(): void {
    this.world.camera.position.copyFrom(this.host.position);
  }
}

// Shake the camera on every bullet impact.
onBulletHit() {
  world.camera.shake(8, 250);
}

// Zoom in for a cinematic close-up.
world.camera.zoom = 2;