@origingame/create-game 0.2.0 → 0.4.0

package/template-2d/assets/rigs/keeper.ogt

@@ -0,0 +1,292 @@
+type rig2d
+version 1
+---
+# The lamp keeper (templates/game-2d): a 2D rig drawn as textured triangles.
+# Bones are pixels with +y up, unit 20 pixels to a world unit; the legs are
+# two-bone IK chains planted on the ramp by og.IkTarget2D (src/main.ts, Plant),
+# the cape a weighted mesh over the hip and two cape bones, fluttered by the
+# idle clip's deform keys. The walk clip bobs the hip on Bézier keys, swings
+# the arm and trails the cape; its "step" events mark each foot's contact,
+# and src/main.ts's Plant moves the feet's IK targets in step with it (a
+# 0.8 s cycle of a 0.4 m stride: the keeper walks 0.5 m/s). Written by hand
+# (og-game §8, the rig2d grammar).
+texture "keeper.png"
+filter nearest
+unit 20
+bone root {
+}
+bone hip {
+  parent root
+  at 0 22
+  rotation 90
+  length 16
+}
+bone head {
+  parent hip
+  at 16 0
+  rotation -90
+}
+bone arm {
+  parent hip
+  at 14 -5
+  rotation 180
+  length 13
+}
+bone thigh-b {
+  parent hip
+  at 0 2
+  rotation 180
+  length 11
+}
+bone shin-b {
+  parent thigh-b
+  at 11 0
+  length 11
+}
+bone thigh-f {
+  parent hip
+  at 0 -2
+  rotation 180
+  length 11
+}
+bone shin-f {
+  parent thigh-f
+  at 11 0
+  length 11
+}
+bone cape-1 {
+  parent hip
+  at 15 4
+  rotation 180
+  length 12
+}
+bone cape-2 {
+  parent cape-1
+  at 12 0
+  length 12
+}
+bone foot-b {
+  parent root
+  at -3 0
+}
+bone foot-f {
+  parent root
+  at 3 0
+}
+slot cape {
+  bone hip
+  attachment cape
+}
+slot thigh-b {
+  bone thigh-b
+  attachment thigh-b
+  color 0.72 0.72 0.8 1
+}
+slot shin-b {
+  bone shin-b
+  attachment shin-b
+  color 0.72 0.72 0.8 1
+}
+slot boot-b {
+  bone shin-b
+  attachment boot-b
+  color 0.72 0.72 0.8 1
+}
+slot torso {
+  bone hip
+  attachment torso
+}
+slot thigh-f {
+  bone thigh-f
+  attachment thigh-f
+}
+slot shin-f {
+  bone shin-f
+  attachment shin-f
+}
+slot boot-f {
+  bone shin-f
+  attachment boot-f
+}
+slot head {
+  bone head
+  attachment head
+}
+slot arm {
+  bone arm
+  attachment arm
+}
+slot lantern {
+  bone arm
+  attachment lantern
+}
+region torso {
+  slot torso
+  rect 0 0 12 20
+  at 8 0
+  rotation -90
+  size 12 20
+}
+region head {
+  slot head
+  rect 15 0 14 12
+  at 0 5
+  rotation 0
+  size 14 12
+}
+region arm {
+  slot arm
+  rect 32 16 4 14
+  at 6.5 0
+  rotation 90
+  size 4 14
+}
+region lantern {
+  slot lantern
+  rect 52 16 8 10
+  at 15 0
+  rotation 90
+  size 8 10
+}
+region thigh-b {
+  slot thigh-b
+  rect 32 0 5 12
+  at 5.5 0
+  rotation 90
+  size 5 12
+}
+region shin-b {
+  slot shin-b
+  rect 40 0 5 12
+  at 5.5 0
+  rotation 90
+  size 5 12
+}
+region boot-b {
+  slot boot-b
+  rect 48 0 10 5
+  at 10.5 2
+  rotation 90
+  size 10 5
+}
+region thigh-f {
+  slot thigh-f
+  rect 32 0 5 12
+  at 5.5 0
+  rotation 90
+  size 5 12
+}
+region shin-f {
+  slot shin-f
+  rect 40 0 5 12
+  at 5.5 0
+  rotation 90
+  size 5 12
+}
+region boot-f {
+  slot boot-f
+  rect 48 0 10 5
+  at 10.5 2
+  rotation 90
+  size 10 5
+}
+mesh cape {
+  slot cape
+  vertex 0 32 hip 16.000 16.000 1
+  vertex 6 32 hip 16.000 9.000 1
+  vertex 12 32 hip 16.000 2.000 1
+  vertex 0 40 hip 7.000 16.000 0.4 cape-1 8.000 -12.000 0.6
+  vertex 6 40 hip 7.000 9.000 0.4 cape-1 8.000 -5.000 0.6
+  vertex 12 40 hip 7.000 2.000 0.4 cape-1 8.000 2.000 0.6
+  vertex 0 48 cape-1 17.000 -12.000 0.5 cape-2 5.000 -12.000 0.5
+  vertex 6 48 cape-1 17.000 -5.000 0.5 cape-2 5.000 -5.000 0.5
+  vertex 12 48 cape-1 17.000 2.000 0.5 cape-2 5.000 2.000 0.5
+  vertex 0 56 cape-2 14.000 -12.000 1
+  vertex 6 56 cape-2 14.000 -5.000 1
+  vertex 12 56 cape-2 14.000 2.000 1
+  triangles 0 3 1 1 3 4 1 4 2 2 4 5 3 6 4 4 6 7 4 7 5 5 7 8 6 9 7 7 9 10 7 10 8 8 10 11
+}
+ik leg-b {
+  bones thigh-b shin-b
+  target foot-b
+  bend clockwise
+}
+ik leg-f {
+  bones thigh-f shin-f
+  target foot-f
+  bend clockwise
+}
+clip idle {
+  duration 2
+  loop true
+  bone hip {
+    translate 0 0 0
+    translate 1 0 -1.5
+    translate 2 0 0
+  }
+  bone head {
+    rotate 0 0
+    rotate 1 4
+    rotate 2 0
+  }
+  bone arm {
+    rotate 0 4
+    rotate 1 -8
+    rotate 2 4
+  }
+  bone cape-1 {
+    rotate 0 -4
+    rotate 1 8
+    rotate 2 -4
+  }
+  bone cape-2 {
+    rotate 0 -6
+    rotate 1 12
+    rotate 2 -6
+  }
+  deform cape {
+    key 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+    key 0.5 0 0 0 0 0 0 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -3 0 -3 0 -3 0 -3 0 -3 0 -3 0 -5 0 -5 0 -5
+    key 1 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 2 0 2 0 2 0 2 0 2 0 2 0 3 0 3 0 3
+    key 1.5 0 0 0 0 0 0 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -3.5 0 -3.5 0 -3.5 0 -3.5 0 -3.5 0 -3.5 0 -6 0 -6 0 -6
+    key 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+  }
+  event 0 "inhale"
+}
+clip walk {
+  duration 0.8
+  loop true
+  bone hip {
+    translate 0 0 -1 curve 0.3 0 0.6 1
+    translate 0.2 0 0.6 curve 0.4 0 0.7 1
+    translate 0.4 0 -1 curve 0.3 0 0.6 1
+    translate 0.6 0 0.6 curve 0.4 0 0.7 1
+    translate 0.8 0 -1
+  }
+  bone head {
+    rotate 0 -2
+    rotate 0.4 2
+    rotate 0.8 -2
+  }
+  bone arm {
+    rotate 0 16 curve 0.42 0 0.58 1
+    rotate 0.4 -12 curve 0.42 0 0.58 1
+    rotate 0.8 16
+  }
+  bone cape-1 {
+    rotate 0 -10
+    rotate 0.2 -14
+    rotate 0.4 -10
+    rotate 0.6 -14
+    rotate 0.8 -10
+  }
+  bone cape-2 {
+    rotate 0 -12
+    rotate 0.3 -20
+    rotate 0.5 -12
+    rotate 0.7 -20
+    rotate 0.8 -12
+  }
+  event 0 "step"
+  event 0.4 "step"
+}

package/template-2d/assets/rigs/keeper.png.ogt

@@ -0,0 +1,7 @@
+type import
+version 1
+---
+# Pixel art: lossless, sampled nearest.
+texture {
+  kind pixel
+}

package/template-2d/package.json

@@ -13,6 +13,6 @@
     "test": "og test ."
   },
   "dependencies": {
-    "@origingame/engine": "0.2.0"
+    "@origingame/engine": "0.4.0"
   }
 }

package/template-2d/project.ogt

@@ -7,7 +7,7 @@ version 1
 name "Origin Game 2D"
 id "origin-game-2d"
 # The engine this game is written against (design §9: upgrades are explicit).
-engine "0.2.0"
+engine "0.4.0"
 entry "src/main.ts"
 # 2d: an orthographic camera, sprites, flipbooks, tilemaps and 2D physics.
 profile "2d"

package/template-2d/src/main.ts

@@ -11,11 +11,22 @@
 // Everything the starter shows is in og-game §8 (sprites, flipbooks,
 // tilemaps), §13 (the controller) and og-feel §12 (its tunables).
 //
+// Beside the spawn a lamp keeper stands on a ramp: a 2D skeletal rig
+// (assets/rigs/keeper.ogt, og.Skeleton2D) whose cape is a weighted mesh the
+// idle clip deforms, whose feet two-bone IK planted on the slope
+// (og.IkTarget2D, the Plant system), and whose lantern lights the sprite
+// layers through og.Lighting2D (og-game §8; og-anim's 2D skeletons). Sent
+// along the ramp (`keeper:<x>`), it turns to face the way (a paper turn
+// over a few ticks), plays its walk clip there, each foot planted while it
+// carries the keeper and lifted while it swings, lets both feet land when
+// it arrives, turns back and breathes again (the Walk and Plant systems).
+// No foot ever moves faster than the gait's own swing.
+//
 // The frame's look is data: GameDesc.look names a file under assets/looks/
 // that extends a preset of the style catalogue, applied before start runs.
 
 import { og, defineComponent, defineResource, defineSystem, bool, f32, u32, SHAPE_BOX } from "@origingame/engine";
-import type { FlipbookInfo, Result, TileObject } from "@origingame/engine";
+import type { FlipbookInfo, Result, Rig2DInfo, TileObject, World } from "@origingame/engine";
 
 /** The courier's clips, in the sheet's file order (og-game §8): `start` checks them. */
 const CLIP = { idle: 0, run: 1, jump: 2, fall: 3 } as const;
@@ -28,6 +39,26 @@ const BOX = { w: 0.9, h: 1.9 } as const;
 /** Below this the courier fell into the pit. */
 const FALL_Y = -3;
 const LIVES = 3;
+/** The keeper's ramp: a plank from (x0, y0) on the roof rising at `slope` (tan 12°) to x1. */
+const RAMP = { x0: 4.5, y0: 2, x1: 7.6, slope: 0.21256, sinHalf: 0.104528, cosHalf: 0.994522 } as const;
+/** The ramp's top at x. */
+const rampY = (x: number): number => RAMP.y0 + RAMP.slope * (x - RAMP.x0);
+/** The keeper's ankles and its root above the ramp (its legs reach 1.1 from a hip 1.1 up: a slight bend), the lantern from its feet, in world units. */
+const ANKLE = 0.12;
+const LIFT = 0.08;
+const LANTERN = { x: 0.25, y: 1.0 } as const;
+/** The keeper's gait: the walk clip's 0.8 s cycle carries it a stride of 0.4 m (a step per foot), each foot lifted at most `lift` mid-swing. */
+const WALK = { speed: 0.5, stride: 0.4, lift: 0.08 } as const;
+/**
+ * The fastest a foot moves (m/s): the gait's swing at its start, a stride
+ * forward in half a cycle (twice the walking speed) while it rises up the
+ * slope and off it (the lift's parabola, 4 lift over the swing's length,
+ * at its steepest). A foot sent elsewhere (setting off, stopping, a turn)
+ * steps there no faster.
+ */
+const FOOT_SPEED = Math.hypot(2 * WALK.speed, 2 * WALK.speed * RAMP.slope + (8 * WALK.lift * WALK.speed) / WALK.stride);
+/** A turn's ticks: the rig narrows to its edge and opens the other way (og.Transform's scale x, never 0). */
+const TURN_TICKS = 12;
 
 /** The courier. */
 export const Hero = defineComponent("Hero", { spawnX: f32(0, { unit: "m" }), spawnY: f32(0, { unit: "m" }) });
@@ -35,6 +66,18 @@ export const Hero = defineComponent("Hero", { spawnX: f32(0, { unit: "m" }), spa
 /** A coin of the map's `coin` objects; taken once. */
 export const Coin = defineComponent("Coin", { taken: bool() });
 
+/**
+ * One of the keeper's feet: its IK target stands on the ramp `dx` ahead of
+ * the keeper (behind when negative), `lag` of a gait cycle after the front
+ * foot; `x`, `y` is where the foot is.
+ */
+export const Plant = defineComponent("Plant", {
+  dx: f32(0, { unit: "m" }),
+  lag: f32(0, { min: 0, max: 1 }),
+  x: f32(0, { unit: "m" }),
+  y: f32(0, { unit: "m" }),
+});
+
 /** A voice: the sound bit (Sound) it plays when Game.sfx asks for it. */
 export const Voice = defineComponent("Voice", { bit: u32() });
 
@@ -58,6 +101,28 @@ export const Game = defineResource("Game", {
   /** The HUD's touch controls this tick (a phone): the run and the held jump. */
   touchX: f32(0, { min: -1, max: 1 }),
   touchJump: bool(),
+  /** The keeper's breaths: og.Skeleton2DEvent "inhale" (the idle clip's event at 0). */
+  inhales: u32(),
+  /** The keeper's footfalls: og.Skeleton2DEvent "step" (the walk clip's, one per foot). */
+  steps: u32(),
+});
+
+/** Where the keeper walks (`keeper:<x>`), how far it has walked since it set off (its gait's phase), its turn and stop, and its clips. */
+export const KeeperWalk = defineResource("KeeperWalk", {
+  goal: f32(6, { unit: "m" }),
+  walked: f32(0, { unit: "m" }),
+  walking: bool(),
+  /** -1 facing left (towards the spawn), 1 right. */
+  facing: f32(-1),
+  /** Ticks of a turn done (0: not turning). */
+  turning: u32(),
+  /** og.Transform's scale x: 1, or through a turn from 1 towards -1. */
+  squash: f32(1),
+  /** Arrived, the feet stepping to stand (Plant sets `landed` when both are down). */
+  settling: bool(),
+  landed: bool(true),
+  idle: u32(),
+  walk: u32(),
 });
 
 function must<T>(r: Result<T>): T {
@@ -161,6 +226,133 @@ export const Animate = defineSystem("Animate", { reads: [Hero, og.PlatformerCont
   }
 });
 
+/**
+ * Walks the keeper towards KeeperWalk.goal along the ramp at the gait's
+ * speed (by scaled time, as the clip plays: paused, both hold), facing the
+ * way it goes, with the walk clip. Facing the other way first, it turns
+ * over TURN_TICKS (og.Transform's scale x eased from 1 to -1, never 0, then
+ * flipX), its feet stepping across with it. On arrival it holds the walk
+ * pose until Plant has both feet down, turns to face the spawn, and once
+ * they are down again breathes with the idle clip (which starts over,
+ * breathing in).
+ */
+export const Walk = defineSystem("Walk", { writes: [KeeperWalk, og.Skeleton2D, og.Transform], after: ["Control"] }, (_q, time, world) => {
+  const keeper = world.find("keeper");
+  if (keeper === null) return;
+  const w = must(world.resource(KeeperWalk));
+  const x = must(world.get(keeper, og.Transform)).position.x;
+  const s = must(world.get(keeper, og.Skeleton2D));
+  const place = (nx: number) => must(world.set(keeper, og.Transform, { position: { x: nx, y: rampY(nx) + LIFT, z: 0 }, scale: { x: w.squash, y: 1, z: 1 } }));
+  if (w.turning > 0 || (time.scaledDt > 0 && w.turning === 0 && wantsTurn(w, x))) {
+    // A turn: the rig narrows to its edge and opens facing the other way.
+    if (time.scaledDt === 0) return;
+    w.turning += 1;
+    if (w.turning < TURN_TICKS) {
+      w.squash = Math.cos((Math.PI * (w.turning - 0.5)) / (TURN_TICKS - 0.5));
+    } else {
+      w.turning = 0;
+      w.squash = 1;
+      w.facing = -w.facing;
+      must(world.set(keeper, og.Skeleton2D, { flipX: w.facing < 0 }));
+    }
+    place(x);
+    return;
+  }
+  const left = w.goal - x;
+  if (left !== 0) {
+    const step = WALK.speed * time.scaledDt;
+    const arrived = Math.abs(left) <= step;
+    const nx = arrived ? w.goal : x + Math.sign(left) * step;
+    w.walked = (w.walking ? w.walked : 0) + Math.abs(nx - x);
+    w.walking = !arrived;
+    w.settling = arrived;
+    w.landed = false;
+    place(nx);
+    // Walking plays the walk clip from its first step; arrived, it holds its pose while the feet land.
+    if (s.clip !== w.walk) must(world.set(keeper, og.Skeleton2D, { clip: w.walk, speed: 1 }));
+    else if (arrived) must(world.set(keeper, og.Skeleton2D, { speed: 0 }));
+    return;
+  }
+  if (w.settling && w.landed) w.settling = false;
+  // Standing, both feet down and facing the spawn: breathe.
+  if (!w.settling && w.landed && w.facing < 0 && s.clip !== w.idle) must(world.set(keeper, og.Skeleton2D, { clip: w.idle, speed: 1 }));
+});
+
+/** Whether the keeper must turn before it goes on: towards its goal, or back to the spawn once it stands with both feet down. */
+function wantsTurn(w: { goal: number; facing: number; settling: boolean; walking: boolean }, x: number): boolean {
+  const left = w.goal - x;
+  if (left !== 0) return Math.sign(left) !== w.facing && !w.walking;
+  return !w.settling && w.facing > 0;
+}
+
+/**
+ * Puts the keeper's feet on the ramp (og.IkTarget2D: the legs' two-bone IK
+ * reaches each target, the knees bend as the hip bobs). Standing, each foot
+ * is `dx` from the keeper; walking, the front foot's gait phase is the
+ * distance walked over the stride and the back foot's half a cycle later:
+ * for half a cycle a foot stays where it is on the plank while the keeper
+ * passes over it, for the other half it swings a stride forward, lifted on
+ * a parabola. A foot steps to where it should be at most FOOT_SPEED fast,
+ * lifted while it is still on its way, so turning, setting off and
+ * stopping are steps, not jumps (each leg hangs from its own hip: the
+ * front foot crosses to the other side in a turn). Keeps the lantern's light at its hand, and
+ * counts the clips' breaths and footfalls.
+ */
+export const Plant2D = defineSystem("Plant", { reads: [og.Skeleton2DEvent], writes: [Game, KeeperWalk, Plant, og.IkTarget2D, og.Transform], after: ["Walk"] }, (q, time, world) => {
+  const keeper = world.find("keeper");
+  if (keeper === null) return;
+  const at = must(world.get(keeper, og.Transform)).position;
+  const w = must(world.resource(KeeperWalk));
+  const reach = FOOT_SPEED * time.scaledDt;
+  let down = true;
+  for (const a of q.archetypes()) {
+    const plant = a.column(Plant);
+    const target = a.column(og.IkTarget2D).target;
+    for (let i = 0; i < a.count; i++) {
+      let ahead = plant.dx[i]!;
+      let lift = 0;
+      if (w.walking) {
+        const phase = w.walked / WALK.stride + plant.lag[i]!;
+        const p = phase - Math.floor(phase);
+        if (p < 0.5) {
+          // Planted: it slides back under the keeper as fast as the keeper walks.
+          ahead += WALK.stride * (0.25 - p);
+        } else {
+          const s = (p - 0.5) * 2;
+          ahead += WALK.stride * (s - 0.5) * 0.5;
+          lift = WALK.lift * 4 * s * (1 - s);
+        }
+      }
+      // Turning, each foot follows its hip as the rig narrows and opens the other way.
+      const wx = at.x + w.facing * w.squash * ahead;
+      const [x, y] = toward(plant.x[i]!, plant.y[i]!, wx, rampY(wx) + ANKLE + lift, reach);
+      // Still on its way: lifted with how far it has left (a step's height at half a stride), as fast as it may rise.
+      const rest = Math.abs(wx - x);
+      const [fx, fy] = rest > 1e-6 ? toward(plant.x[i]!, plant.y[i]!, x, Math.max(y, rampY(x) + ANKLE + WALK.lift * Math.min(1, rest / (WALK.stride / 2))), reach) : [x, y];
+      plant.x[i] = fx;
+      plant.y[i] = fy;
+      target[i * 2] = fx;
+      target[i * 2 + 1] = fy;
+      if (Math.hypot(wx - fx, rampY(wx) + ANKLE + lift - fy) > 1e-5 || lift > 0) down = false;
+    }
+  }
+  w.landed = down;
+  const lantern = world.find("lantern");
+  if (lantern !== null) must(world.set(lantern, og.Transform, { position: { x: at.x - w.facing * w.squash * LANTERN.x, y: at.y + LANTERN.y, z: 0 } }));
+  const g = must(world.resource(Game));
+  for (const e of world.events(og.Skeleton2DEvent)) {
+    if (e.name === "inhale") g.inhales += 1;
+    else if (e.name === "step") g.steps += 1;
+  }
+});
+
+/** (x, y) moved towards (tx, ty) by at most `reach`. */
+function toward(x: number, y: number, tx: number, ty: number, reach: number): [number, number] {
+  const d = Math.hypot(tx - x, ty - y);
+  if (d <= reach) return [tx, ty];
+  return [x + ((tx - x) * reach) / d, y + ((ty - y) * reach) / d];
+}
+
 /** Plays each sound asked for once: a voice still playing is stopped this tick and played again the next. */
 export const Voices = defineSystem("Voices", { reads: [Voice], writes: [Game, og.AudioSource], after: ["Pickups"] }, (q, _time, world) => {
   const g = must(world.resource(Game));
@@ -212,6 +404,42 @@ export const Hud = defineSystem("Hud", { writes: [Game] }, (_q, _time, world) =>
   }
 });
 
+/**
+ * The lamp keeper: a plank ramp, the rig on it facing the spawn, a foot
+ * target per leg, and its lantern's light; og.Lighting2D lights layers 1
+ * and 2 (the keeper, the courier, the coins), the city stays as drawn.
+ */
+function spawnKeeper(world: World, rig: Rig2DInfo): void {
+  const idle = og.anim.clip(rig, "idle");
+  const walk = og.anim.clip(rig, "walk");
+  if (idle < 0 || walk < 0) throw new Error("rigs/keeper.ogt needs clips idle and walk");
+  const mid = (RAMP.x0 + RAMP.x1) / 2;
+  const plank = must(world.spawn({ name: "ramp", position: { x: mid, y: rampY(mid) - 0.2, z: 0 }, quaternion: { x: 0, y: 0, z: RAMP.sinHalf, w: RAMP.cosHalf } }));
+  // The plank is a region of the keeper's texture (pixels 24..64 x 32..40 of 64 x 64).
+  must(world.insert(plank, og.Sprite, { texture: rig.texture, width: RAMP.x1 - RAMP.x0, height: 0.4, uvMin: { x: 0.375, y: 0.5 }, uvMax: { x: 1, y: 0.625 }, layer: 1 }));
+  const x = 6;
+  const keeper = must(world.spawn({ name: "keeper", position: { x, y: rampY(x) + LIFT, z: 0 } }));
+  must(world.insert(keeper, og.Skeleton2D, { rig: rig.rig, clip: idle, flipX: true, layer: 1 }));
+  const w = must(world.resource(KeeperWalk));
+  Object.assign(w, { goal: x, walked: 0, walking: false, facing: -1, turning: 0, squash: 1, settling: false, landed: true, idle, walk });
+  // Facing left, the front foot is the left one; the back foot steps half a cycle later.
+  for (const [name, ahead, lag] of [["leg-f", 0.15, 0], ["leg-b", -0.15, 0.5]] as const) {
+    const constraint = rig.constraints.indexOf(name);
+    if (constraint < 0) throw new Error(`rigs/keeper.ogt has no ik ${name}`);
+    const fx = x - ahead;
+    const foot = must(world.spawn({ name: `keeper-${name}` }));
+    must(world.insert(foot, og.IkTarget2D, { skeleton: keeper, constraint, target: { x: fx, y: rampY(fx) + ANKLE }, tolerance: 0.02 }));
+    must(world.insert(foot, Plant, { dx: ahead, lag, x: fx, y: rampY(fx) + ANKLE }));
+  }
+  const light = must(world.spawn({ name: "lantern", position: { x: x + LANTERN.x, y: rampY(x) + LIFT + LANTERN.y, z: 0 } }));
+  must(world.insert(light, og.Light2D, { color: { r: 1, g: 0.72, b: 0.35 }, intensity: 1.6, radius: 4, castShadows: false }));
+  const lighting = must(world.resource(og.Lighting2D));
+  lighting.enabled = true;
+  lighting.ambient = { r: 0.62, g: 0.64, b: 0.78 };
+  lighting.minLayer = 1;
+  lighting.maxLayer = 2;
+}
+
 function checkClips(info: FlipbookInfo): void {
   for (const [name, index] of Object.entries(CLIP)) {
     const at = og.anim.clip(info, name);
@@ -229,13 +457,14 @@ export default og.game({
   look: "looks/origin-game-2d.ogt",
   tick: 60,
   seed: 1,
-  resources: [Game],
-  systems: [Hud, Control, Pickups, Animate, Voices],
+  resources: [Game, KeeperWalk],
+  systems: [Hud, Control, Pickups, Animate, Walk, Plant2D, Voices],
   start(world) {
     const map = must(og.load.tilemap(world, "maps/level.ogt"));
     const courier = must(og.load.flipbook(world, "sprites/courier.ogt"));
     checkClips(courier);
     const coin = must(og.load.flipbook(world, "sprites/coin.ogt"));
+    spawnKeeper(world, must(og.load.rig2d(world, "rigs/keeper.ogt")));
     const height = map.height * map.tileHeight;
 
     const camera = must(world.resource(og.Camera));
@@ -293,13 +522,20 @@ export default og.game({
       if (hero === null || !Number.isFinite(x) || !Number.isFinite(y)) throw new Error("write warp:<x>:<y>");
       must(world.set(hero, og.Transform, { position: { x, y, z: 0 } }));
     },
+    /** `keeper:<x>`: send the keeper walking along the ramp to x (the Walk system moves it; its feet step on the plank). */
+    keeper: (world, args) => {
+      const x = Math.max(RAMP.x0 + 0.4, Math.min(RAMP.x1 - 0.4, Number(args[0])));
+      if (world.find("keeper") === null || !Number.isFinite(x)) throw new Error("write keeper:<x>");
+      must(world.resource(KeeperWalk)).goal = x;
+    },
   },
   commandHelp: {
     warp: { usage: "<x>:<y>", doc: "Put the courier's feet at a world point." },
+    keeper: { usage: "<x>", doc: "Send the lamp keeper walking along its ramp to x." },
   },
   facts: (world) => {
     const g = world.resource(Game);
     if (!g.ok) return {};
-    return { coins: g.value.coins, total: g.value.total, lives: g.value.lives, won: g.value.won, x: g.value.heroX, y: g.value.heroY };
+    return { coins: g.value.coins, total: g.value.total, lives: g.value.lives, won: g.value.won, inhales: g.value.inhales, steps: g.value.steps, x: g.value.heroX, y: g.value.heroY };
   },
 });