@origingame/create-game 0.0.0-stage → 0.1.1

package/archetypes/third-person/src/anim.ts

@@ -0,0 +1,87 @@
+// The two characters' blend trees (og.anim.graph) and where their clips
+// come from. The hero is the strider: its import settings retarget the
+// clip library (anims/humanoid-clips.glb) at cook time. The sentinels are
+// the stout, whose Unreal-named bones get the library's clips retargeted
+// here at run time (og.anim.retarget).
+
+import { og } from "@origingame/engine";
+import type { ClipInfo, GraphAsset, SkeletonAsset, World } from "@origingame/engine";
+import { must } from "./world.ts";
+
+/**
+ * The hero's graph: p0 is the speed across the ground, p1 is 1 in the air.
+ * On the ground a 1D blend runs idle, walk and run by speed (the clips'
+ * phases kept in step); a jump or a fall cross-fades to the run held
+ * mid-stride, slowed.
+ */
+const HERO_GRAPH = `type animgraph
+version 1
+---
+param speed
+param air
+clip idle "idle"
+clip walk "walk" {
+  speed 1.1
+}
+clip run "run"
+blend1d move speed {
+  child idle 0
+  child walk 2.2
+  child run 5.6
+}
+layer base {
+  state ground move
+  state air run {
+    speed 0.3
+  }
+  entry ground
+  transition ground air {
+    when air gt 0.5
+    fade 0.15
+  }
+  transition air ground {
+    when air lt 0.5
+    fade 0.1
+  }
+}
+`;
+
+/** A sentinel's graph: p0 is its speed (a patrol walks, a chase runs). */
+const SENTINEL_GRAPH = `type animgraph
+version 1
+---
+param speed
+clip idle "idle"
+clip walk "walk" {
+  speed 0.9
+}
+clip run "run"
+blend1d move speed {
+  child idle 0
+  child walk 1.6
+  child run 4.2
+}
+layer base {
+  state move move
+  entry move
+}
+`;
+
+export interface Rigged {
+  skeleton: SkeletonAsset;
+  graph: GraphAsset;
+}
+
+/** The strider's skeleton and the hero's graph. */
+export function heroRig(world: World): Rigged {
+  const anim = must(og.load.animation(world, "models/strider.glb"));
+  return { skeleton: anim.skeleton, graph: must(og.anim.graph(world, { text: HERO_GRAPH, clips: anim.clips })) };
+}
+
+/** The stout's skeleton and the sentinels' graph, its clips retargeted from the library. */
+export function sentinelRig(world: World): Rigged {
+  const anim = must(og.load.animation(world, "models/stout.glb"));
+  const library = must(og.load.animation(world, "anims/humanoid-clips.glb"));
+  const clips: ClipInfo[] = library.clips.map((c) => ({ ...c, clip: must(og.anim.retarget(world, { clip: c.clip, source: library.skeleton, target: anim.skeleton })).clip }));
+  return { skeleton: anim.skeleton, graph: must(og.anim.graph(world, { text: SENTINEL_GRAPH, clips })) };
+}

package/archetypes/third-person/src/beacons.ts

@@ -0,0 +1,80 @@
+// The beacons: the hero kindles the nearest one by holding F (X, Kindle)
+// within reach; Tuning.kindleSeconds later it catches (src/world.ts
+// lightBeacon: fire, smoke, a burst of embers, the scorch and the rune),
+// the camera punches and a toast counts it. Every burning beacon's light
+// swells in and flickers. All four lit, dawn will find the vale lit: the
+// run is won.
+
+import { og, defineSystem } from "@origingame/engine";
+import type { Entity, Value, World } from "@origingame/engine";
+import { Beacon, BEACONS, Ending, Game, Phase, Sound, Tuning } from "./components.ts";
+import { entity, STAND } from "./hero.ts";
+import { say } from "./ui.ts";
+import { BEACON_AT, douseBeacons, lightBeacon, must, part } from "./world.ts";
+
+/** Beacon `i` catches: its fire, the punch, the toast; the last one wins the run (no toast). */
+export function catchBeacon(world: World, g: Value<typeof Game>, i: number): void {
+  if ((g.litMask & (1 << i)) !== 0) return;
+  lightBeacon(world, i, g.time);
+  g.litMask |= 1 << i;
+  g.lit += 1;
+  g.kindle = 0;
+  g.near = -1;
+  g.sfx |= Sound.Ignite;
+  must(og.camera.punch(world, 0.35));
+  // The last one's news is the dawn stinger and the summary, not a toast under it.
+  if (g.lit < BEACONS) og.ui.toast(world, say(world, "hud.lit", { n: g.lit, total: BEACONS }));
+  if (g.lit >= BEACONS) {
+    g.ending = Ending.Dawn;
+    g.sfx |= Sound.Dawn;
+  }
+}
+
+/** A burning beacon's light at full flame (og.PointLight.intensity). */
+const FLAME = 30;
+
+export const Beacons = defineSystem(
+  "Beacons",
+  { reads: [Tuning, og.Transform], writes: [Game, Beacon, og.PointLight, og.ParticleSystem, og.Decal, og.Mesh], after: ["Hero"] },
+  (_q, time, world) => {
+    const g = must(world.resource(Game));
+    const t = must(world.resource(Tuning));
+    if (g.start) {
+      // Behind the title the four burn; a run starts with them dark.
+      douseBeacons(world);
+      if (g.phase === Phase.Title) for (let i = 0; i < BEACONS; i++) lightBeacon(world, i, -1);
+    }
+    const playing = g.phase === Phase.Play && g.ending === Ending.None;
+    const p = must(world.get(g.hero as unknown as Entity, og.Transform)).position;
+    let near = -1;
+    let nearest = Infinity;
+    if (playing) {
+      BEACON_AT.forEach((b, i) => {
+        if ((g.litMask & (1 << i)) !== 0) return;
+        const d = Math.hypot(p.x - b.x, p.z - b.z);
+        if (d < t.reach + 0.8 && d < nearest) {
+          nearest = d;
+          near = i;
+        }
+      });
+    }
+    if (near !== g.near) {
+      g.near = near;
+      g.kindle = 0;
+    }
+    // Kindling counts once the hero stands at the plinth with its hand in the bowl.
+    if (playing && g.kindling && near >= 0 && nearest <= STAND + 0.3) g.kindle += time.scaledDt;
+    else if (g.kindle > 0) g.kindle = Math.max(0, g.kindle - time.scaledDt * 2);
+    if (playing && near >= 0 && g.kindle >= t.kindleSeconds) catchBeacon(world, g, near);
+    // The lights: each swells in over half a second and flickers.
+    for (let i = 0; i < BEACONS; i++) {
+      const b = must(world.get(entity(world, `beacon-${i}`), Beacon));
+      if (!b.lit) continue;
+      const since = g.phase === Phase.Title ? 10 : g.time - b.litAt;
+      const swell = Math.min(1, since / 0.5);
+      const e = time.elapsed;
+      const flicker = 0.86 + 0.08 * Math.sin(e * 13 + i * 2.1) + 0.06 * Math.sin(e * 29 + i * 5.3);
+      must(world.set(part(world, i, "light"), og.PointLight, { intensity: FLAME * swell * flicker }));
+    }
+  },
+);

package/archetypes/third-person/src/components.ts

@@ -0,0 +1,148 @@
+// Every piece of Ember Vale's state lives in these reflected types: dumps,
+// the probe, Tune and the command channel's `get` and `set` read and write
+// them by name.
+//
+// The run (Game), the knobs (Tuning) and the player's settings (Prefs) are
+// resources. The actors are rows spawned in `start`: the hero (Hero), the
+// four beacons (Beacon), the three sentinels (Sentinel) and one voice per
+// sound (Sfx).
+
+import { bool, defineComponent, defineResource, f32, f64, i32, u32 } from "@origingame/engine";
+
+/** The screen the game is on. */
+export const Phase = { Title: 0, Play: 1, Over: 2 } as const;
+
+/** How a run ended (Game.ending). */
+export const Ending = { None: 0, Dawn: 1, Night: 2, Caught: 3 } as const;
+
+/**
+ * Sound requests: bits of Game.sfx that the Voices system plays once each.
+ * `Tap` is the touch HUD's stick, Jump and Kindle answering on the ui bus, as
+ * og.ui's own buttons do (og-ui's touch controls play no press sound of their
+ * own).
+ */
+export const Sound = { Step: 1, Jump: 2, Splash: 4, Ignite: 8, Alarm: 16, Grab: 32, Dawn: 64, Night: 128, Tap: 256 } as const;
+
+/** The beacons a run lights. */
+export const BEACONS = 4;
+/** The hearts a run starts with. */
+export const HEARTS = 3;
+
+/** The run: the hero's progress, the clock and the effects' bookkeeping. */
+export const Game = defineResource("Game", {
+  phase: u32(Phase.Title, { doc: "Phase.* of src/components.ts." }),
+  leftTitle: bool(false, { doc: "The player has left the title the game opened on: from then on the title enters with the skin's entrance (the opening one is built settled, og.ui.mainMenu's instant: the web draws it behind the play gate)." }),
+  ending: u32(Ending.None, { doc: "Ending.* once a run is over." }),
+  paused: bool(false),
+  settingsOpen: bool(false),
+  held: bool(false, { doc: "The time scale is held at 0 (paused or in the settings)." }),
+  runs: u32(0, { doc: "Runs started on this device (the store's `record`)." }),
+  wins: u32(0, { doc: "Runs that lit every beacon (the store's `record`)." }),
+  best: f32(0, { unit: "s", doc: "The fastest win (the store's `record`; 0 none)." }),
+  recordRequest: u32(0, { doc: "The store request reading `record`." }),
+  recordRevision: u32(0, { doc: "The revision `record` was read or written at." }),
+  recordWrite: u32(0, { doc: "The store request writing `record`." }),
+  recordMerge: bool(false, { doc: "A write was refused as stale: the record is read again and the merge written." }),
+  recordRuns: u32(0, { doc: "Runs in the record as last read or written: Game.runs less this is what this device adds." }),
+  recordWins: u32(0, { doc: "Wins in the record as last read or written." }),
+  recordConflicts: u32(0, { doc: "Record writes refused as stale (another device or tab wrote first)." }),
+  recordDirty: bool(false, { doc: "The record changed while a read or write of it was in flight: written when that answers." }),
+  recordSentRuns: u32(0, { doc: "Runs in the record write in flight (what the store holds once it answers ok)." }),
+  recordSentWins: u32(0, { doc: "Wins in the record write in flight." }),
+  newBest: bool(false),
+  hearts: i32(HEARTS),
+  hurts: u32(0, { doc: "Hearts lost this run." }),
+  lit: u32(0, { doc: "Beacons lit this run." }),
+  litMask: u32(0, { doc: "Bit i: beacon i burns." }),
+  time: f32(0, { unit: "s", doc: "Seconds played this run (paused time excluded)." }),
+  hour: f32(0, { doc: "The time of day (og.atmosphere.timeOfDay): night falls at Tuning.nightHour." }),
+  near: i32(-1, { doc: "The beacon within reach (-1 none)." }),
+  kindle: f32(0, { unit: "s", doc: "How long the near beacon has been kindled." }),
+  kindling: bool(false, { doc: "The hero is kindling (holding F, X or Kindle by a beacon)." }),
+  wading: bool(false, { doc: "The hero's feet are in the lake." }),
+  grounded: bool(false),
+  speed: f32(0, { unit: "m/s", doc: "The hero's speed across the ground." }),
+  jumps: u32(0),
+  splashes: u32(0),
+  grabs: u32(0, { doc: "Sentinel grabs that cost a heart." }),
+  alarms: u32(0, { doc: "Times a sentinel called the alarm." }),
+  invulnerable: f32(0, { unit: "s", doc: "Seconds before the hero can be grabbed again." }),
+  knock: f32(0, { unit: "s", doc: "Seconds the hero is thrown back (no control)." }),
+  knockX: f32(0),
+  knockZ: f32(0),
+  yaw: f32(0, { unit: "rad", doc: "The view's heading: 0 looks north (-z)." }),
+  facing: f32(0, { unit: "rad", doc: "The hero's heading." }),
+  padJump: bool(false, { doc: "The HUD's Jump was pressed this tick." }),
+  padKindle: bool(false, { doc: "The HUD's Kindle is held." }),
+  stickX: f32(0, { doc: "The HUD joystick (written by Ui)." }),
+  stickY: f32(0),
+  lookId: i32(-1, { doc: "The finger turning the view on a touch screen (an og.Pointers id; -1 none)." }),
+  lookX: f32(0, { unit: "cssPx", doc: "Where that finger was last tick." }),
+  lookTurn: f32(0, { unit: "rad", doc: "How far the finger turned the view this tick (written by Ui, applied by View)." }),
+  overTicks: u32(0, { unit: "ticks", doc: "Ticks since the run ended; the summary comes after a beat." }),
+  start: bool(false, { doc: "Every system resets its part of the vale this tick (a new run or the title)." }),
+  sfx: u32(0),
+  hero: f64(0, { doc: "The hero's entity." }),
+  terrain: f64(0, { doc: "The vale's og.terrain data." }),
+  nav: f64(0, { doc: "The sentinels' navmesh." }),
+  viewW: f32(0, { unit: "cssPx" }),
+  viewH: f32(0, { unit: "cssPx" }),
+  language: u32(0, { doc: "Prefs.language, mirrored for the facts." }),
+});
+
+/** The knobs. Tune reads the tunable fields; `set:Tuning.<field>=<value>` writes them. */
+export const Tuning = defineResource("Tuning", {
+  walkSpeed: f32(3, { min: 1, max: 8, step: 0.1, unit: "m/s", tunable: true, label: "Walk speed" }),
+  runSpeed: f32(6, { min: 2, max: 12, step: 0.1, unit: "m/s", tunable: true, label: "Run speed" }),
+  wade: f32(0.45, { min: 0.1, max: 1, step: 0.05, tunable: true, label: "Wading slows to", doc: "The hero's speed in the lake, as a fraction." }),
+  jumpSpeed: f32(5.2, { min: 2, max: 12, step: 0.1, unit: "m/s", tunable: true, label: "Jump speed" }),
+  kindleSeconds: f32(1.6, { min: 0.2, max: 6, step: 0.1, unit: "s", tunable: true, label: "Kindling takes" }),
+  reach: f32(2.4, { min: 1, max: 5, step: 0.1, unit: "m", tunable: true, label: "Kindling reach", doc: "How near a beacon's centre the hero kindles it." }),
+  duskSeconds: f32(150, { min: 20, max: 900, step: 5, unit: "s", tunable: true, label: "Dusk lasts", doc: "Seconds of play from the first light to night." }),
+  patrolSpeed: f32(1.6, { min: 0.5, max: 6, step: 0.1, unit: "m/s", tunable: true, label: "Sentinel patrol speed" }),
+  chaseSpeed: f32(4.2, { min: 1, max: 9, step: 0.1, unit: "m/s", tunable: true, label: "Sentinel chase speed" }),
+  sight: f32(13, { min: 2, max: 40, step: 0.5, unit: "m", tunable: true, label: "Sentinel sight" }),
+  hitStop: u32(5, { min: 0, max: 20, unit: "ticks", tunable: true, label: "Hit stop" }),
+  cameraDistance: f32(6.2, { min: 2, max: 14, step: 0.1, unit: "m", tunable: true, label: "Camera distance" }),
+});
+
+/** The player's settings: kept in og.platform's settings, restored on the first ticks. */
+export const Prefs = defineResource("Prefs", {
+  master: f32(1, { min: 0, max: 1 }),
+  music: f32(0.7, { min: 0, max: 1 }),
+  effects: f32(1, { min: 0, max: 1 }),
+  language: u32(0, { doc: "0 English, 1 简体中文 (LANGUAGES in src/ui.ts)." }),
+  reducedMotion: bool(false),
+  loadRequest: u32(0),
+  saves: u32(0),
+});
+
+/** The hero, on the capsule (its body, the strider, is a child). */
+export const Hero = defineComponent("Hero", {
+  steps: u32(0, { doc: "Footsteps: one per stride of ground covered." }),
+  airTime: f32(0, { unit: "s", doc: "Seconds since the capsule last stood on the ground." }),
+  stepClock: f32(0, { unit: "m", doc: "Ground covered since the last footstep." }),
+});
+
+/** A beacon: its plinth, bowl, fire, smoke, light and decals hang off it. */
+export const Beacon = defineComponent("Beacon", {
+  index: u32(0),
+  lit: bool(false),
+  litAt: f32(0, { unit: "s", doc: "Game.time when it caught." }),
+  top: f32(0, { unit: "m", doc: "The bowl's rim, world y." }),
+});
+
+/** A sentinel: a stone stout on the navmesh, thinking with assets/ai/sentinel-<name>.ogt. */
+export const Sentinel = defineComponent("Sentinel", {
+  index: u32(0),
+  grabs: u32(0),
+  alarms: u32(0),
+  speed: f32(0, { unit: "m/s", doc: "Its speed across the ground (the graph's p0)." }),
+  alert: bool(false, { doc: "It is chasing or grabbing (its eye burns red)." }),
+});
+
+/** One voice: plays its sound once when Game.sfx asks for its bit. */
+export const Sfx = defineComponent("Sfx", {
+  bit: u32(0),
+  plays: u32(0),
+});

package/archetypes/third-person/src/hero.ts

@@ -0,0 +1,293 @@
+// The hero: a capsule on og.CharacterController carrying the strider
+// (skinned, run by the graph of src/anim.ts), and the camera that follows
+// it. WASD or the arrows (the left stick, the touch joystick) walk
+// relative to the view, Shift (a full stick) runs, Space (A, Jump) jumps,
+// holding F (X, Kindle) by a beacon walks up to it and reaches into the
+// bowl with the right hand (an og.IkChain on the arm) until it catches.
+// Wading in the lake slows the hero and splashes; the sentinels cannot
+// follow there. Q and E (the right stick, a finger dragged across the
+// touch HUD's look zone) turn the view; walking swings it slowly behind
+// the hero.
+
+import { og, defineSystem, SHAPE_CAPSULE } from "@origingame/engine";
+import type { Entity, Value, Vector3, World } from "@origingame/engine";
+import { heroRig } from "./anim.ts";
+import { Beacon, Ending, Game, Hero, Phase, Sound, Tuning } from "./components.ts";
+import { BEACON_AT, ground, LAKE, must, START, WATER_Y } from "./world.ts";
+
+type GameV = Value<typeof Game>;
+type TuneV = Value<typeof Tuning>;
+
+/** The capsule's centre above the feet (radius 0.3, a 0.9 m segment). */
+export const FEET = 0.75;
+/** The strider's scale (about 1.6 m tall). */
+const BODY_SCALE = 0.92;
+/** The strider's right hand: its index among the skin's joints (Hips is 0). */
+export const RIGHT_HAND = 12;
+/** How near a beacon's centre the hero stands to reach into its bowl. */
+export const STAND = 1.12;
+const UP = { x: 0, y: 1, z: 0 };
+
+/** Tuning, read on its first use in this call (a resource read encodes every field). */
+export function lazyTuning(world: World): TuneV {
+  let v: TuneV | null = null;
+  return new Proxy({} as TuneV, { get: (_, k) => ((v ??= must(world.resource(Tuning))) as unknown as Record<string | symbol, unknown>)[k] });
+}
+
+export function entity(world: World, name: string): Entity {
+  const e = world.find(name);
+  if (e === null) throw new Error(`${name} is missing`);
+  return e;
+}
+
+/** Spawns the hero at the start, its body, its reach and its splash. */
+export function spawnHero(world: World): void {
+  const g = must(world.resource(Game));
+  const rig = heroRig(world);
+  const h = ground(world, g, START.x, START.z).height;
+  const hero = must(world.spawn({ name: "hero", position: { x: START.x, y: h + FEET + 0.05, z: START.z } }));
+  must(world.insert(hero, og.Collider, { shape: SHAPE_CAPSULE, radius: 0.3, height: 0.9 }));
+  must(world.insert(hero, og.CharacterController, { maxSlope: 42, stepHeight: 0.35, snapDistance: 0.3, coyoteTime: 0.12 }));
+  must(world.insert(hero, Hero));
+  must(world.insert(hero, og.Perceivable, { team: 1, eyeHeight: 0.6 }));
+  g.hero = hero as unknown as number;
+  const body = must(world.instantiate(must(og.load.gltf(world, "models/strider.glb")), { name: "hero-body", parent: hero, position: { x: 0, y: -FEET, z: 0 }, scale: { x: BODY_SCALE, y: BODY_SCALE, z: BODY_SCALE } }));
+  must(world.insert(body, og.Skeleton, { asset: rig.skeleton, rootMotion: "off" }));
+  must(world.insert(body, og.AnimationGraph, { asset: rig.graph }));
+  const reach = must(world.spawn({ name: "hero-reach" }));
+  must(world.insert(reach, og.IkChain, { skeleton: body, tip: RIGHT_HAND, bones: 3, solver: "fabrik", tolerance: 0.02, space: "world", weight: 0 }));
+  const splash = must(world.spawn({ name: "hero-splash", position: { x: 0, y: WATER_Y, z: 0 } }));
+  must(world.insert(splash, og.ParticleSystem, { emitter: must(og.load.emitter(world, "fx/splash.ogt")), seed: 5, visible: false }));
+}
+
+function wrap(a: number): number {
+  while (a > Math.PI) a -= 2 * Math.PI;
+  while (a < -Math.PI) a += 2 * Math.PI;
+  return a;
+}
+
+/** Turns `from` towards `to` by at most `step` radians. */
+export function turn(from: number, to: number, step: number): number {
+  const d = wrap(to - from);
+  return wrap(from + Math.max(-step, Math.min(step, d)));
+}
+
+function splash(world: World, g: GameV, at: Vector3): void {
+  must(world.set(entity(world, "hero-splash"), og.Transform, { position: { x: at.x, y: WATER_Y + 0.02, z: at.z } }));
+  must(world.set(entity(world, "hero-splash"), og.ParticleSystem, { visible: true, startTick: world.tick }));
+  g.sfx |= Sound.Splash;
+  g.splashes += 1;
+}
+
+/** Puts the hero back at the start, facing north, the view behind it. */
+function reset(world: World, g: GameV, hero: Entity): void {
+  const h = ground(world, g, START.x, START.z).height;
+  must(world.set(hero, og.Transform, { position: { x: START.x, y: h + FEET + 0.05, z: START.z } }));
+  must(world.set(hero, og.CharacterController, { move: { x: 0, y: 0, z: 0 }, jump: false }));
+  must(world.set(hero, Hero, { airTime: 0, stepClock: 0 }));
+  g.facing = Math.PI;
+  g.yaw = 0;
+  g.knock = 0;
+  g.invulnerable = 0;
+  g.kindling = false;
+}
+
+/**
+ * Per tick: reads the controls, moves the capsule, turns the body, drives
+ * the graph and the reach, and makes the steps, the splashes and the jumps
+ * heard.
+ */
+export const HeroMove = defineSystem(
+  "Hero",
+  { reads: [og.Input, og.Gamepad, Tuning, Beacon], writes: [Game, Hero, og.CharacterController, og.Transform, og.AnimationGraph, og.IkChain, og.ParticleSystem, og.PostEffects], after: ["Ui"] },
+  (_q, time, world) => {
+    const g = must(world.resource(Game));
+    const t = lazyTuning(world);
+    const hero = g.hero as unknown as Entity;
+    if (g.start) reset(world, g, hero);
+    const inp = must(world.resource(og.Input));
+    const gp = must(world.resource(og.Gamepad));
+    const playing = g.phase === Phase.Play && g.ending === Ending.None;
+    // Pause before the time gate: a press during a hit-stop (scaledDt 0)
+    // still pauses. Not while held: the press that resumed from the menu
+    // this tick (Ui runs first) would open it again.
+    if (playing && !g.held && (inp.pressed("Escape") || inp.pressed("KeyP") || gp.pressed("start"))) g.paused = true;
+    const dt = time.scaledDt;
+    if (dt === 0) return;
+    const body = entity(world, "hero-body");
+    const reach = entity(world, "hero-reach");
+    const cc = must(world.get(hero, og.CharacterController));
+    const me = must(world.get(hero, Hero));
+    const p = must(world.get(hero, og.Transform)).position;
+
+    // The controls, relative to the view: forward is where the camera looks.
+    let ix = inp.axis("KeyA", "KeyD") + inp.axis("ArrowLeft", "ArrowRight");
+    let iy = inp.axis("KeyS", "KeyW") + inp.axis("ArrowDown", "ArrowUp");
+    let analog = false;
+    const sx = gp.axis("leftX");
+    const sy = -gp.axis("leftY");
+    if (Math.hypot(sx, sy) > 0.2) {
+      ix += sx;
+      iy += sy;
+      analog = true;
+    }
+    if (g.stickX !== 0 || g.stickY !== 0) {
+      ix += g.stickX;
+      iy -= g.stickY;
+      analog = true;
+    }
+    const mag = Math.min(1, Math.hypot(ix, iy));
+    const run = analog ? mag > 0.85 : inp.down("ShiftLeft") || inp.down("ShiftRight");
+    const fwd = { x: -Math.sin(g.yaw), z: -Math.cos(g.yaw) };
+    const right = { x: Math.cos(g.yaw), z: -Math.sin(g.yaw) };
+    let dx = 0;
+    let dz = 0;
+    if (mag > 0.01) {
+      const n = Math.hypot(ix, iy);
+      dx = (right.x * ix + fwd.x * iy) / n;
+      dz = (right.z * ix + fwd.z * iy) / n;
+    }
+
+    const feet = p.y - FEET;
+    g.wading = feet < WATER_Y - 0.08 && Math.hypot(p.x - LAKE.x, p.z - LAKE.z) < 18;
+    const kindleHeld = playing && (inp.down("KeyF") || gp.down("x") || g.padKindle);
+    g.kindling = kindleHeld && g.near >= 0;
+
+    let speed = 0;
+    let face: number | null = null;
+    if (g.knock > 0) {
+      const k = g.knock / 0.35;
+      speed = 7 * k;
+      dx = g.knockX;
+      dz = g.knockZ;
+      g.knock = Math.max(0, g.knock - dt);
+    } else if (g.kindling) {
+      // Walk up to the plinth, then stand and reach.
+      const b = BEACON_AT[g.near]!;
+      const vx = b.x - p.x;
+      const vz = b.z - p.z;
+      const d = Math.hypot(vx, vz);
+      face = Math.atan2(vx, vz);
+      if (d > STAND) {
+        dx = vx / d;
+        dz = vz / d;
+        speed = t.walkSpeed;
+      }
+    } else if (playing && mag > 0.01) {
+      speed = (run ? t.runSpeed : t.walkSpeed) * (analog && !run ? mag / 0.85 : 1);
+      face = Math.atan2(dx, dz);
+    }
+    if (g.wading) speed *= t.wade;
+    const jump = playing && !g.kindling && g.knock === 0 && (inp.down("Space") || gp.down("a") || g.padJump);
+    must(world.set(hero, og.CharacterController, { move: { x: dx * speed, y: 0, z: dz * speed }, jump, jumpSpeed: t.jumpSpeed }));
+    g.padJump = false;
+    if (g.invulnerable > 0) g.invulnerable = Math.max(0, g.invulnerable - dt);
+    const post = must(world.resource(og.PostEffects));
+    if (post.flash > 0) post.flash = Math.max(0, post.flash - dt * 2.5);
+
+    // The body turns towards where it goes (not while thrown back).
+    if (face !== null) g.facing = turn(g.facing, face, 11 * dt);
+    must(world.set(body, og.Transform, { quaternion: og.transform.fromAxisAngle(UP, g.facing) }));
+
+    // The graph: speed across the ground, and whether it is in the air.
+    const v = cc.velocity;
+    const hs = Math.hypot(v.x, v.z);
+    g.speed = hs;
+    const airTime = cc.grounded ? 0 : me.airTime + dt;
+    must(world.set(body, og.AnimationGraph, { p0: cc.grounded || airTime < 0.12 ? hs : 0, p1: airTime > 0.12 ? 1 : 0 }));
+
+    // The reach: the right hand into the near bowl while kindling.
+    const ik = must(world.get(reach, og.IkChain));
+    let weight = ik.weight;
+    const want = g.kindling ? 1 : 0;
+    weight += Math.max(-dt * 5, Math.min(dt * 5, want - weight));
+    if (g.near >= 0) {
+      const b = BEACON_AT[g.near]!;
+      const bowl = world.find(`beacon-${g.near}`);
+      const top = bowl === null ? p.y : must(world.get(bowl, Beacon)).top;
+      const vx = p.x - b.x;
+      const vz = p.z - b.z;
+      const d = Math.max(0.01, Math.hypot(vx, vz));
+      // IkChain's "world" space is the frame the body's Transform is in: the hero's (unrotated) capsule.
+      must(world.set(reach, og.IkChain, { weight, target: { x: b.x + (vx / d) * 0.5 - p.x, y: top + 0.05 - p.y, z: b.z + (vz / d) * 0.5 - p.z } }));
+    } else if (weight !== ik.weight) must(world.set(reach, og.IkChain, { weight }));
+
+    // Steps, splashes, jumps and landings.
+    let steps = me.steps;
+    let stepClock = me.stepClock;
+    if (cc.grounded && hs > 0.5) {
+      stepClock += hs * dt;
+      const stride = hs > 4 ? 1.6 : 1.15;
+      if (stepClock >= stride) {
+        stepClock -= stride;
+        steps += 1;
+        if (g.wading) splash(world, g, p);
+        else g.sfx |= Sound.Step;
+      }
+    }
+    if (!cc.grounded && me.airTime === 0 && v.y > 1) {
+      g.jumps += 1;
+      g.sfx |= Sound.Jump;
+    }
+    if (cc.grounded && me.airTime > 0.3) {
+      if (feet < WATER_Y) splash(world, g, p);
+      else g.sfx |= Sound.Step;
+    }
+    g.grounded = cc.grounded;
+    must(world.set(hero, Hero, { airTime, steps, stepClock }));
+  },
+);
+
+/** How far the camera's eye stays above the ground and the water. */
+const CLEARANCE = 0.6;
+/** The view's pitch, down from level. */
+const PITCH = 0.36;
+
+/**
+ * The camera: behind the title an orbit of the vale; in a run it follows
+ * the hero, turned by Q and E (the right stick) and swung slowly behind it
+ * as it walks, kept above the ground and the lake.
+ */
+export const View = defineSystem("View", { reads: [og.Input, og.Gamepad, og.Transform, Tuning], writes: [Game, og.Camera], after: ["Hero"] }, (_q, time, world) => {
+  const g = must(world.resource(Game));
+  const cam = must(world.resource(og.Camera));
+  const t = lazyTuning(world);
+  const inp = must(world.resource(og.Input));
+  const gp = must(world.resource(og.Gamepad));
+  const dt = time.dt;
+  let eye: Vector3;
+  let focus: Vector3;
+  if (g.phase === Phase.Title) {
+    const a = time.elapsed * 0.035 + 0.6;
+    eye = { x: LAKE.x + Math.sin(a) * 42, y: 17, z: LAKE.z + Math.cos(a) * 42 };
+    focus = { x: LAKE.x, y: 3, z: LAKE.z };
+  } else {
+    const p = must(world.get(g.hero as unknown as Entity, og.Transform)).position;
+    if (time.scaledDt > 0) {
+      let turnBy = inp.axis("KeyQ", "KeyE") * 2.2 + (Math.abs(gp.axis("rightX")) > 0.2 ? gp.axis("rightX") * 2.6 : 0);
+      // Swing behind a walking hero (not one walking at the camera), unless a finger holds the view.
+      const behind = g.facing + Math.PI;
+      if (turnBy === 0 && g.lookId < 0 && g.speed > 0.5 && Math.abs(wrap(behind - g.yaw)) < 2.2) turnBy = (wrap(behind - g.yaw) * Math.min(1, g.speed / 6)) * 0.9;
+      // A finger dragging across the look zone (Ui's touch turn): dragging right turns the view right.
+      g.yaw = wrap(g.yaw + turnBy * dt - g.lookTurn);
+      if (g.lookTurn !== 0) g.lookTurn = 0;
+    }
+    const d = t.cameraDistance;
+    focus = { x: p.x, y: p.y + 0.9, z: p.z };
+    eye = {
+      x: focus.x + Math.sin(g.yaw) * d * Math.cos(PITCH),
+      y: focus.y + d * Math.sin(PITCH),
+      z: focus.z + Math.cos(g.yaw) * d * Math.cos(PITCH),
+    };
+    const floor = Math.max(ground(world, g, eye.x, eye.z).height, WATER_Y) + CLEARANCE;
+    if (eye.y < floor) eye.y = floor;
+  }
+  const at = cam.position;
+  const far = Math.hypot(eye.x - at.x, eye.y - at.y, eye.z - at.z) > 12 || g.start;
+  const k = far ? 1 : 1 - Math.exp(-dt * 9);
+  const pos = { x: at.x + (eye.x - at.x) * k, y: at.y + (eye.y - at.y) * k, z: at.z + (eye.z - at.z) * k };
+  cam.position = pos;
+  cam.quaternion = og.transform.lookAt(pos, focus);
+  cam.fov = 55;
+  cam.far = 400;
+});