@origingame/create-game 0.0.0-stage → 0.1.0

package/archetypes/roguelike/src/components.ts

@@ -0,0 +1,169 @@
+// Every piece of Lamp Dive'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 dive (Game), the knobs (Tuning), the player's settings (Prefs) and
+// where each foe stands (Foes, so the hero's system can find what it walks
+// into) are resources. The actors are pooled rows spawned in `start`: the
+// hero, the foes, the loot and one voice per sound.
+
+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;
+
+/** What a foe is (Foe.kind). */
+export const FoeKind = { Rat: 0, Skeleton: 1, Guardian: 2 } as const;
+export const FOES = ["rat", "skeleton", "guardian"] as const;
+
+/** What a find is (Loot.kind). */
+export const LootKind = { Potion: 0, Blade: 1, Ward: 2, Oil: 3, Coin: 4, Relic: 5 } as const;
+export const LOOT = ["potion", "blade", "ward", "oil", "coin", "relic"] as const;
+
+/** Sound requests: bits of Game.sfx that the Voices system plays once each. */
+export const Sound = { Step: 1, Hit: 2, Hurt: 4, Kill: 8, Pickup: 16, Item: 32, Drink: 64, Stairs: 128, Roar: 256, Telegraph: 512, Fall: 1024, Won: 2048, Bump: 4096, Move: 8192 } as const;
+
+/** The most foes and finds a floor holds. */
+export const FOE_SLOTS = 10;
+export const LOOT_SLOTS = 12;
+
+/** The dive: the lamp-bearer, the floor, the turn, the counts 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)." }),
+  paused: bool(false),
+  settingsOpen: bool(false),
+  held: bool(false, { doc: "The time scale is held at 0 (paused or in the settings)." }),
+  dives: u32(0, { doc: "Dives started on this device (the store's `record`)." }),
+  relics: u32(0, { doc: "Dives that took the relic (the store's `record`)." }),
+  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." }),
+  recordDives: u32(0, { doc: "Dives in the record as last read or written: Game.dives less this is what this device adds." }),
+  recordRelics: u32(0, { doc: "Relics in the record as last read or written." }),
+  recordConflicts: u32(0, { doc: "Record writes refused as stale (another device or tab wrote first)." }),
+  seed: u32(0, { doc: "This dive's seed: every floor's rooms, foes and finds come from og.Rng streams forked with it." }),
+  floor: u32(0, { doc: "The floor the lamp-bearer is on (1 or 2; 0 before the first dive)." }),
+  deepest: u32(0),
+  build: bool(false, { doc: "The Hero system carves the floor this tick." }),
+  place: bool(false, { doc: "The Foes and Loot systems place this floor's rows this tick." }),
+  hp: i32(0),
+  hpMax: i32(0),
+  attack: i32(0, { doc: "Damage a strike deals (before the die's +0 or +1)." }),
+  armour: i32(0, { doc: "Damage a foe's strike loses." }),
+  lamp: f32(0, { unit: "cells", doc: "How far the lamp lights." }),
+  potions: u32(0),
+  gold: u32(0),
+  kills: u32(0),
+  hits: u32(0, { doc: "Strikes that landed on a foe." }),
+  hurts: u32(0, { doc: "Strikes that landed on the lamp-bearer." }),
+  finds: u32(0, { doc: "Things picked up." }),
+  turns: u32(0),
+  heroX: i32(0, { doc: "The lamp-bearer's cell, a map column." }),
+  heroY: i32(0, { doc: "The lamp-bearer's cell, a map row (0 the top)." }),
+  stairsX: i32(-1, { doc: "The stairs' cell on floor 1 (-1 none)." }),
+  stairsY: i32(-1),
+  foesTurn: bool(false, { doc: "The foes act this turn: their behaviour (assets/ai/*.ogt) checks it." }),
+  lock: u32(0, { unit: "ticks", doc: "Ticks before the next action is taken (the step's or the strike's animation)." }),
+  strikeSlot: i32(-1, { doc: "The foe the lamp-bearer struck this tick, for the Foes system."}),
+  strikeDamage: i32(0),
+  queued: u32(0, { doc: "An action asked for while the last played out (0 none, 1-4 a direction, 5 wait, 6 drink)." }),
+  repeat: u32(0, { unit: "ticks", doc: "Ticks a direction has been held (it repeats after 14, then every 7)." }),
+  lastDir: u32(0, { doc: "The direction held last tick (0 none, 1 up, 2 right, 3 down, 4 left)." }),
+  padDir: u32(0, { doc: "The HUD d-pad's direction this tick (written by Ui)." }),
+  padWait: bool(false, { doc: "The HUD's Wait was pressed this tick." }),
+  padDrink: bool(false, { doc: "The HUD's Drink was pressed this tick." }),
+  refusedTick: i32(-1, { unit: "ticks", doc: "The tick a draught was refused (the HUD shakes Drink)." }),
+  foesAt: i32(-1, { unit: "ticks", doc: "The tick foesTurn went up; the Foes system takes it down on a later tick, after og.ai has thought with it." }),
+  foeMind: f64(0, { doc: "assets/ai/foe.ogt's behaviour handle." }),
+  guardianMind: f64(0, { doc: "assets/ai/guardian.ogt's behaviour handle." }),
+  won: bool(false),
+  killedBy: i32(-1, { doc: "FoeKind.* of the foe that put the lamp out (-1 none)." }),
+  overTicks: u32(0, { unit: "ticks", doc: "Ticks since the lamp went out or the relic was taken; the card comes after a beat." }),
+  newRecord: bool(false),
+  sfx: u32(0),
+  fogDirty: bool(false, { doc: "The lamp-bearer moved: the Fog system lights the cells it sees." }),
+  lit: u32(0, { doc: "Cells the lamp lights now." }),
+  seen: u32(0, { doc: "Cells of this floor the lamp has ever lit (lit now or remembered)." }),
+  grid: f64(0, { doc: "The floor's og.nav grid." }),
+  map: f64(0, { doc: "The floor's og.Tilemap entity." }),
+  glow: f64(0, { doc: "The lamp's light texture." }),
+  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", {
+  heroHp: i32(20, { min: 1, max: 99, step: 1, tunable: true, label: "Lamp-bearer's health" }),
+  heroAttack: i32(3, { min: 1, max: 20, step: 1, tunable: true, label: "Strike" }),
+  lamp: f32(4.5, { min: 2, max: 12, step: 0.5, unit: "cells", tunable: true, label: "Lamp reach" }),
+  potionHeal: i32(8, { min: 1, max: 40, step: 1, tunable: true, label: "A draught heals" }),
+  ratHp: i32(5, { min: 1, max: 40, tunable: true, label: "Rat health" }),
+  ratAttack: i32(1, { min: 0, max: 20, tunable: true, label: "Rat strike" }),
+  skeletonHp: i32(9, { min: 1, max: 60, tunable: true, label: "Skeleton health" }),
+  skeletonAttack: i32(2, { min: 0, max: 20, tunable: true, label: "Skeleton strike" }),
+  guardianHp: i32(18, { min: 1, max: 99, tunable: true, label: "Guardian health" }),
+  guardianAttack: i32(3, { min: 0, max: 20, tunable: true, label: "Guardian strike", doc: "Its charged strike, every third turn and telegraphed the turn before, deals twice this." }),
+  sight: f32(6, { min: 1, max: 15, step: 0.5, unit: "m", tunable: true, label: "Foes' sight", doc: "How far a foe sees (og.Perception.sight); walls hide the lamp-bearer." }),
+  stepTime: f32(0.09, { min: 0.02, max: 0.4, step: 0.01, unit: "s", tunable: true, label: "Step time", doc: "How long a step's tween takes; actions wait for it." }),
+  hitStop: u32(4, { min: 0, max: 12, unit: "ticks", tunable: true, label: "Hit stop" }),
+});
+
+/** 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),
+});
+
+/** Where each foe stands and whether it is up: the Hero system reads it to strike what it walks into. */
+export const Foes = defineResource("Foes", Object.fromEntries(
+  Array.from({ length: FOE_SLOTS }, (_, i) => [
+    [`x${i}`, i32(-1)],
+    [`y${i}`, i32(-1)],
+  ]).flat(),
+) as Record<string, ReturnType<typeof i32>>);
+
+/** The lamp-bearer. */
+export const Hero = defineComponent("Hero", {
+  steps: u32(0, { doc: "Cells walked." }),
+  bumps: u32(0, { doc: "Steps into stone (refused with a bump)." }),
+});
+
+/** A foe: a pooled row a floor switches on. What it decides is assets/ai/<kind>.ogt (og.ai). */
+export const Foe = defineComponent("Foe", {
+  slot: u32(0),
+  active: bool(false),
+  kind: u32(FoeKind.Rat),
+  hp: i32(0),
+  hpMax: i32(0),
+  attack: i32(0),
+  cx: i32(0, { doc: "Its cell." }),
+  cy: i32(0),
+  turns: u32(0, { doc: "Its turns on this floor (the guardian charges every third)." }),
+  charging: bool(false, { doc: "Its next strike is charged (telegraphed in red)." }),
+  dying: u32(0, { unit: "ticks" }),
+});
+
+/** A find on the floor. */
+export const Loot = defineComponent("Loot", {
+  slot: u32(0),
+  active: bool(false),
+  kind: u32(LootKind.Potion),
+  amount: u32(0, { doc: "Gold in a coin pile." }),
+  cx: i32(0),
+  cy: i32(0),
+  taken: u32(0, { unit: "ticks", doc: "Ticks since it was picked up (it rises and fades, then the row parks)." }),
+});
+
+/** 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/roguelike/src/dive.ts

@@ -0,0 +1,144 @@
+// A floor's plan: rooms, the corridors between them, where the lamp-bearer
+// starts, the stairs (floor 1) or the relic and its guardian (floor 2), the
+// foes and the finds. A pure function of the dive's seed and the floor
+// number: the plan comes from an og.Rng stream forked with both, so every
+// system that needs it (the Hero carves it, the Foes and the Loot place
+// their rows) computes the same plan, and a dive replays from its seed.
+
+import type { RngStream } from "@origingame/engine";
+import { FoeKind, LootKind } from "./components.ts";
+
+/** The floor's size in cells (assets/maps/dive.ogt). */
+export const W = 28;
+export const H = 20;
+
+export interface Room {
+  readonly x: number;
+  readonly y: number;
+  readonly w: number;
+  readonly h: number;
+}
+
+export interface Plan {
+  /** 1 where the floor is stone, row-major from the top row. */
+  readonly walls: Uint8Array;
+  readonly rooms: readonly Room[];
+  readonly start: { x: number; y: number };
+  /** Floor 1's way down. */
+  readonly stairs: { x: number; y: number } | null;
+  /** Floor 2's relic, in the farthest room. */
+  readonly relic: { x: number; y: number } | null;
+  readonly foes: ReadonlyArray<{ kind: number; x: number; y: number }>;
+  readonly loot: ReadonlyArray<{ kind: number; x: number; y: number; amount: number }>;
+}
+
+const centre = (r: Room) => ({ x: r.x + Math.floor(r.w / 2), y: r.y + Math.floor(r.h / 2) });
+
+/**
+ * Rooms placed at random without touching, joined in order of their
+ * centres by L-shaped corridors (which way the L turns is a coin), then the
+ * start in the first room, the goal in the room farthest from it by walking
+ * distance, and the foes and finds in the others.
+ */
+export function planFloor(rng: RngStream, floor: number): Plan {
+  const walls = new Uint8Array(W * H).fill(1);
+  const rooms: Room[] = [];
+  for (let attempt = 0; attempt < 80 && rooms.length < 8; attempt++) {
+    const w = rng.integer(4, 7);
+    const h = rng.integer(3, 5);
+    const x = rng.integer(1, W - w - 1);
+    const y = rng.integer(1, H - h - 1);
+    const touches = rooms.some((r) => x <= r.x + r.w && r.x <= x + w && y <= r.y + r.h && r.y <= y + h);
+    if (!touches) rooms.push({ x, y, w, h });
+  }
+  rooms.sort((a, b) => centre(a).x - centre(b).x || centre(a).y - centre(b).y);
+  const open = (x: number, y: number) => {
+    if (x > 0 && y > 0 && x < W - 1 && y < H - 1) walls[y * W + x] = 0;
+  };
+  for (const r of rooms) for (let y = r.y; y < r.y + r.h; y++) for (let x = r.x; x < r.x + r.w; x++) open(x, y);
+  for (let i = 1; i < rooms.length; i++) {
+    const a = centre(rooms[i - 1]!);
+    const b = centre(rooms[i]!);
+    const flat = rng.chance(0.5);
+    const corner = flat ? { x: b.x, y: a.y } : { x: a.x, y: b.y };
+    for (const [p, q] of [[a, corner], [corner, b]] as const) {
+      for (let x = Math.min(p.x, q.x); x <= Math.max(p.x, q.x); x++) open(x, p.y);
+      for (let y = Math.min(p.y, q.y); y <= Math.max(p.y, q.y); y++) open(q.x, y);
+    }
+  }
+  const start = centre(rooms[0]!);
+  // Walking distance from the start to every open cell (four ways).
+  const dist = new Int32Array(W * H).fill(-1);
+  const queue = [start.y * W + start.x];
+  dist[queue[0]!] = 0;
+  for (let k = 0; k < queue.length; k++) {
+    const c = queue[k]!;
+    for (const d of [1, -1, W, -W]) {
+      const n = c + d;
+      if (n >= 0 && n < W * H && walls[n] === 0 && dist[n]! < 0) {
+        dist[n] = dist[c]! + 1;
+        queue.push(n);
+      }
+    }
+  }
+  let far = 0;
+  rooms.forEach((r, i) => {
+    const c = centre(r);
+    if (dist[c.y * W + c.x]! > dist[centre(rooms[far]!).y * W + centre(rooms[far]!).x]!) far = i;
+  });
+  const goal = centre(rooms[far]!);
+  const taken = new Set<number>([start.y * W + start.x, goal.y * W + goal.x]);
+  /** A free cell of a room, not its doorway rows: tries a few times, then the room's centre. */
+  const spot = (r: Room) => {
+    for (let k = 0; k < 12; k++) {
+      const x = rng.integer(r.x, r.x + r.w - 1);
+      const y = rng.integer(r.y, r.y + r.h - 1);
+      if (!taken.has(y * W + x)) {
+        taken.add(y * W + x);
+        return { x, y };
+      }
+    }
+    return null;
+  };
+  const foes: Array<{ kind: number; x: number; y: number }> = [];
+  const loot: Array<{ kind: number; x: number; y: number; amount: number }> = [];
+  const others = rooms.map((_, i) => i).filter((i) => i !== 0);
+  others.forEach((i, k) => {
+    const r = rooms[i]!;
+    const count = floor === 2 ? 1 + (k % 2) : 1;
+    for (let n = 0; n < count; n++) {
+      const at = spot(r);
+      if (at === null) continue;
+      if (i === far && floor === 2) continue;
+      const kind = floor === 1 ? (k % 3 === 2 ? FoeKind.Skeleton : FoeKind.Rat) : n === 0 ? FoeKind.Skeleton : FoeKind.Rat;
+      foes.push({ kind, ...at });
+    }
+  });
+  if (floor === 2) {
+    // The guardian stands between the relic and the way in.
+    const g = { x: goal.x - 1, y: goal.y };
+    taken.add(g.y * W + g.x);
+    foes.push({ kind: FoeKind.Guardian, ...g });
+  }
+  const finds = floor === 1 ? [LootKind.Potion, LootKind.Blade, LootKind.Oil, LootKind.Coin, LootKind.Coin, LootKind.Potion] : [LootKind.Potion, LootKind.Ward, LootKind.Coin, LootKind.Coin, LootKind.Potion];
+  finds.forEach((kind, k) => {
+    const r = rooms[others[k % others.length]!]!;
+    const at = spot(r);
+    if (at !== null) loot.push({ kind, ...at, amount: kind === LootKind.Coin ? rng.integer(5, 15) : 0 });
+  });
+  if (floor === 2) loot.push({ kind: LootKind.Relic, ...goal, amount: 0 });
+  return {
+    walls,
+    rooms,
+    start,
+    stairs: floor === 1 ? goal : null,
+    relic: floor === 2 ? goal : null,
+    foes: foes.slice(0, 10),
+    loot: loot.slice(0, 12),
+  };
+}
+
+/** The stream a floor is planned from: the world's seed, the dive's and the floor's. */
+export function floorStream(rng: { fork(label: string): RngStream }, seed: number, floor: number): RngStream {
+  return rng.fork(`dive-${seed}-floor-${floor}`);
+}

package/archetypes/roguelike/src/foes.ts

@@ -0,0 +1,174 @@
+// The foes' actions: the game's commands their behaviours raise (og.ai
+// queues each with the foe's handle; they run before the next tick). One
+// command is one foe's whole turn.
+//
+// - strike: the lamp-bearer is next to it: it loses the foe's strike less
+//   its armour (at least 1), twice that for a charged strike; a hit holds
+//   the world, flashes the lamp-bearer red, shakes and kicks the camera.
+// - hunt: a step along og.nav's path to the lamp-bearer (or to where the
+//   foe last saw it), never onto another foe; into the lamp-bearer it is a
+//   strike.
+// - roam: a step in a direction of the dice (rats roam every turn,
+//   skeletons every other).
+// - brace: the guardian holds its ground.
+// The guardian charges every third turn: the turn before, it glows red and
+// a "!" rises over it, so the lamp-bearer can step back and let the charge
+// pass.
+
+import { og } from "@origingame/engine";
+import type { Entity, Value, World } from "@origingame/engine";
+import { Foe, FoeKind, FOE_SLOTS, Game, Sound } from "./components.ts";
+import { H, W } from "./dive.ts";
+import { cellCenter, feel, float, isWall, lazyTuning, must, must2, RED } from "./systems.ts";
+import { say } from "./ui.ts";
+
+type FoeV = Value<typeof Foe>;
+type GameV = Value<typeof Game>;
+
+interface Ctx {
+  me: Entity;
+  f: FoeV;
+  g: GameV;
+}
+
+function context(world: World, args: readonly string[]): Ctx | null {
+  const me = Number(args[0]) as Entity;
+  const foe = world.get(me, Foe);
+  const game = world.resource(Game);
+  if (!foe.ok || !game.ok) throw new Error(`${args[0]} is not a foe`);
+  const g = game.value;
+  if (!foe.value.active || foe.value.dying > 0 || g.hp <= 0 || g.won) return null;
+  return { me, f: foe.value as FoeV, g };
+}
+
+/**
+ * Counts the foe's turn. The guardian's every third turn is charged,
+ * telegraphed a turn ahead; a charge not struck with on that turn (the
+ * lamp-bearer stepped away) is spent.
+ */
+function turnTaken(world: World, c: Ctx): void {
+  const turns = c.f.turns + 1;
+  const charging = c.f.kind === FoeKind.Guardian && turns % 3 === 2;
+  if (charging) {
+    const at = cellCenter(c.f.cx, c.f.cy);
+    float(world, say(world, "float.charge"), at.x, at.y + 0.9, RED, true, 0.6);
+    c.g.sfx |= Sound.Telegraph;
+  }
+  must(world.set(c.me, Foe, { turns, charging }));
+}
+
+function occupied(world: World, x: number, y: number, me: Entity): boolean {
+  for (let i = 0; i < FOE_SLOTS; i++) {
+    const e = world.find(`foe-${i}`);
+    if (e === null || e === me) continue;
+    const f = world.get(e, Foe);
+    if (f.ok && f.value.active && f.value.cx === x && f.value.cy === y) return true;
+  }
+  return false;
+}
+
+function stepTo(world: World, c: Ctx, x: number, y: number): boolean {
+  if (x < 0 || y < 0 || x >= W || y >= H || isWall(world, c.g, x, y) || occupied(world, x, y, c.me)) return false;
+  if (x === c.g.heroX && y === c.g.heroY) return false;
+  must(world.set(c.me, Foe, { cx: x, cy: y }));
+  const to = cellCenter(x, y);
+  must(og.tween.to(world, { entity: c.me, field: "position", to: [to.x, to.y, 0], duration: lazyTuning(world).stepTime, ease: "quadOut" }));
+  return true;
+}
+
+/** `strike:<foe>`: the foe strikes the lamp-bearer beside it. */
+export function strike(world: World, args: readonly string[]): void {
+  const c = context(world, args);
+  if (c === null) return;
+  const { f, g } = c;
+  if (Math.abs(f.cx - g.heroX) + Math.abs(f.cy - g.heroY) !== 1) {
+    hunt(world, args);
+    return;
+  }
+  const charged = f.charging;
+  const dmg = Math.max(1, f.attack * (charged ? 2 : 1) - g.armour);
+  g.hp = Math.max(0, g.hp - dmg);
+  g.hurts += 1;
+  g.sfx |= Sound.Hurt;
+  const hero = world.find("hero");
+  const at = cellCenter(g.heroX, g.heroY);
+  float(world, say(world, "float.hurt", { n: dmg }), at.x, at.y + 0.7, RED, charged);
+  if (hero !== null) {
+    must(og.tween.flash(world, { entity: hero, color: RED, duration: 0.2 }));
+    must(og.tween.squash(world, { entity: hero, impact: { x: 1.25, y: 0.75 }, duration: 0.2 }));
+  }
+  const from = cellCenter(f.cx, f.cy);
+  // The foe lunges at the lamp-bearer and back.
+  must(og.tween.sequence(world, [
+    { entity: c.me, field: "position", to: [from.x + (at.x - from.x) * 0.35, from.y + (at.y - from.y) * 0.35, 0], duration: 0.05, ease: "quadOut" },
+    { entity: c.me, field: "position", to: [from.x, from.y, 0], duration: 0.09, ease: "quadIn" },
+  ]));
+  const dead = g.hp === 0;
+  must(og.time.hitStop(world, dead ? 16 : charged ? 8 : 3));
+  const k = feel(world);
+  must(og.camera.shake(world, (dead ? 0.7 : charged ? 0.5 : 0.25) * k));
+  must(og.camera.kick(world, { x: at.x - from.x, y: at.y - from.y, z: 0 }, (charged ? 0.25 : 0.12) * k));
+  if (dead) {
+    g.killedBy = f.kind;
+    g.overTicks = 0;
+    g.sfx |= Sound.Fall;
+  }
+  turnTaken(world, c);
+}
+
+/** `hunt:<foe>`: a step along og.nav's path to the lamp-bearer, or to where the foe last saw it. */
+export function hunt(world: World, args: readonly string[]): void {
+  const c = context(world, args);
+  if (c === null) return;
+  const { f, g } = c;
+  const eyes = world.get(c.me, og.Perception);
+  const sees = eyes.ok && eyes.value.sees;
+  let tx = g.heroX;
+  let ty = g.heroY;
+  if (!sees && eyes.ok) {
+    tx = Math.floor(eyes.value.lastSeen.x);
+    ty = H - 1 - Math.floor(eyes.value.lastSeen.y);
+  }
+  if (Math.abs(f.cx - g.heroX) + Math.abs(f.cy - g.heroY) === 1 && sees) {
+    strike(world, args);
+    return;
+  }
+  const from = cellCenter(f.cx, f.cy);
+  const to = cellCenter(tx, ty);
+  const path = og.nav.findPath(world, { nav: g.grid as unknown as never, from: { x: from.x, y: from.y, z: 0 }, to: { x: to.x, y: to.y, z: 0 }, smooth: false });
+  let moved = false;
+  if (path.ok && path.value.points.length > 1) {
+    const next = path.value.points[1]!;
+    const dx = Math.sign(Math.round(next.x - 0.5) - f.cx);
+    const dy = Math.sign(H - 1 - Math.round(next.y - 0.5) - f.cy);
+    // Along the longer leg first, then the other.
+    const tries = Math.abs(next.x - from.x) >= Math.abs(next.y - from.y) ? [[dx, 0], [0, dy]] : [[0, dy], [dx, 0]];
+    for (const [sx, sy] of tries) {
+      if ((sx !== 0 || sy !== 0) && !moved) moved = stepTo(world, c, f.cx + sx!, f.cy + sy!);
+    }
+  }
+  turnTaken(world, c);
+}
+
+/** `roam:<foe>`: a step in a direction of the dice (a skeleton keeps still every other turn). */
+export function roam(world: World, args: readonly string[]): void {
+  const c = context(world, args);
+  if (c === null) return;
+  const rng = must2(world.resource(og.Rng));
+  if (c.f.kind === FoeKind.Rat || c.f.turns % 2 === 0) {
+    const start = rng.integer(0, 3);
+    const dirs = [[0, -1], [1, 0], [0, 1], [-1, 0]];
+    for (let k = 0; k < 4; k++) {
+      const [dx, dy] = dirs[(start + k) % 4]!;
+      if (stepTo(world, c, c.f.cx + dx!, c.f.cy + dy!)) break;
+    }
+  }
+  turnTaken(world, c);
+}
+
+/** `brace:<foe>`: the guardian holds its ground (its charge still counts). */
+export function brace(world: World, args: readonly string[]): void {
+  const c = context(world, args);
+  if (c === null) return;
+  turnTaken(world, c);
+}