@origingame/create-game 0.0.0-stage → 0.1.0

package/archetypes/tower-defense/assets/strings/zh-CN.ogt

@@ -0,0 +1,47 @@
+type strings
+version 1
+---
+# 小径守卫的简体中文字符串（og.i18n）；每个键都与 en.ogt 一一对应。
+locale "zh-CN"
+fonts "fonts/NotoSansSC-subset.ttf"
+string "title.name" "小径守卫"
+string "title.tagline" "守住花园小径，直到黑夜过去"
+string "title.play" "开始"
+string "title.settings" "设置"
+string "title.footer" "草地上种花，小径上来客"
+string "hud.wave" "第 {n}/{total} 波"
+string "hud.next" "下一波"
+string "hud.pause" "暂停"
+string "hud.hint" "先选一株植物，再点草地上的格子"
+string "tower.thorn" "荆棘"
+string "tower.frost" "霜百合"
+string "tower.hedge" "树篱"
+string "float.gold" "+{n}"
+string "float.leak" "-{n}"
+string "float.blocked" "这会堵死小径"
+string "float.poor" "还差 {n}"
+string "float.taken" "已有植物"
+string "float.wave" "第 {n} 波"
+string "float.clear" "守住了 +{n}"
+string "pause.title" "已暂停"
+string "pause.resume" "继续"
+string "pause.settings" "设置"
+string "pause.quit" "返回标题"
+string "settings.title" "设置"
+string "settings.master" "总音量"
+string "settings.music" "音乐"
+string "settings.effects" "音效"
+string "settings.language" "语言"
+string "settings.motion" "减少动态效果"
+string "settings.done" "完成"
+string "over.won" "花园守住了"
+string "over.lost" "灯笼熄灭了"
+string "over.best" "最佳 {n}"
+string "over.newBest" "新纪录"
+string "over.waves" "守住的波次"
+string "over.kills" "劝退的来客"
+string "over.lives" "剩下的灯光"
+string "over.retry" "再玩一次"
+string "over.menu" "标题"
+string "lang.en" "English"
+string "lang.zh" "简体中文"

package/archetypes/tower-defense/assets/tiles/garden.ogt

@@ -0,0 +1,10 @@
+type tileset
+version 1
+---
+# Written by tools/make-assets.py: 0-1 grass, 2 hedge, 3 stone, 4 the gate,
+# 5 the doorstep, 6 a thorn's pad, 7 night flowers, 8 a frost lily's pad,
+# 9 a hedge's pad (the pads layer says which plant stands on a cell).
+texture "tiles/garden.png"
+grid 32 32 10 1
+filter linear
+solid 2 3

package/archetypes/tower-defense/assets/tiles/garden.png.ogt

@@ -0,0 +1,7 @@
+type import
+version 1
+---
+# Drawn art: lossless, sampled linear.
+texture {
+  kind color
+}

package/archetypes/tower-defense/gitattributes

@@ -0,0 +1,22 @@
+# Media to Git LFS, as the platform's other scaffolds route them; text stays
+# diffable (.ogt scenes and settings are line-based text by design).
+*.glb filter=lfs diff=lfs merge=lfs -text
+*.gltf filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+*.ktx2 filter=lfs diff=lfs merge=lfs -text
+*.hdr filter=lfs diff=lfs merge=lfs -text
+*.exr filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.ttf filter=lfs diff=lfs merge=lfs -text
+*.otf filter=lfs diff=lfs merge=lfs -text
+*.woff2 filter=lfs diff=lfs merge=lfs -text
+*.ogt text eol=lf
+*.ts text eol=lf

package/archetypes/tower-defense/host.d.ts

@@ -0,0 +1,46 @@
+// The host this project's playtest helpers (tests/*.ts) touch under bun:
+// `node:` modules, `process`, `Buffer`, `TextEncoder`, `import.meta.url`.
+// Declared here because the project type-checks with `types: []` (no
+// @types/node, no bun-types): `og check` reads them through tsconfig.json's
+// include. Game code (src/) uses none of them.
+
+declare module "node:fs" {
+  export function existsSync(path: string): boolean;
+  export function readFileSync(path: string): Uint8Array;
+  export function readFileSync(path: string, encoding: string): string;
+  export function writeFileSync(path: string, data: string | Uint8Array): void;
+  export function mkdirSync(path: string, options?: { recursive?: boolean }): void;
+  export function copyFileSync(from: string, to: string): void;
+}
+
+declare module "node:path" {
+  export function dirname(path: string): string;
+  export function join(...parts: string[]): string;
+  export function resolve(...parts: string[]): string;
+}
+
+declare module "node:url" {
+  export function fileURLToPath(url: string | URL): string;
+}
+
+declare module "node:zlib" {
+  export function inflateSync(data: Uint8Array): Uint8Array;
+  export function deflateSync(data: Uint8Array, options?: { level?: number }): Uint8Array;
+}
+
+declare const process: {
+  readonly env: Record<string, string | undefined>;
+  cwd(): string;
+  readonly stdout: { write(text: string): boolean };
+};
+declare const Buffer: { concat(chunks: readonly Uint8Array[]): Uint8Array };
+declare class TextEncoder {
+  encode(text: string): Uint8Array;
+}
+declare class URL {
+  constructor(url: string, base?: string | URL);
+  readonly href: string;
+}
+interface ImportMeta {
+  readonly url: string;
+}

package/archetypes/tower-defense/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "origin-tower-defense",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "og dev .",
+    "start": "og run .",
+    "build": "og build .",
+    "publish-build": "og build . --publish",
+    "cook": "og cook .",
+    "check": "og check .",
+    "test": "og test ."
+  },
+  "dependencies": {
+    "@origingame/engine": "0.1.0"
+  }
+}

package/archetypes/tower-defense/project.ogt

@@ -0,0 +1,14 @@
+type project
+version 1
+---
+name "Path Guard"
+id "tower-defense"
+engine "0.1.0"
+entry "src/main.ts"
+profile "2d"
+tick 60
+seed 1
+publish {
+  probe player
+  out "dist"
+}

package/archetypes/tower-defense/src/art.ts

@@ -0,0 +1,24 @@
+// The sprite sheet's clips (assets/sprites/garden.ogt, written by
+// tools/make-assets.py), by name. Systems pick clips by index every tick,
+// so the indices are fixed here and checked against the sheet in `start`.
+
+import { og } from "@origingame/engine";
+import type { FlipbookInfo } from "@origingame/engine";
+
+/** The sheet's clips in the order the .ogt declares them. */
+export const CLIPS = ["beetle", "moth", "snail", "lantern", "thorn", "thorn_shoot", "frost", "frost_shoot", "hedge", "seed", "flake", "cursor", "refused"] as const;
+export type ClipName = (typeof CLIPS)[number];
+
+/** A clip's index by name. */
+export function clipOf(name: string): number {
+  const i = (CLIPS as readonly string[]).indexOf(name);
+  if (i < 0) throw new Error(`the sheet has no clip '${name}'`);
+  return i;
+}
+
+/** Checks the loaded sheet against CLIPS once, in `start`. */
+export function checkClips(info: FlipbookInfo): void {
+  CLIPS.forEach((name, i) => {
+    if (og.anim.clip(info, name) !== i) throw new Error(`assets/sprites/garden.ogt: clip '${name}' must be clip ${i} (src/art.ts reads clips by position)`);
+  });
+}

package/archetypes/tower-defense/src/components.ts

@@ -0,0 +1,156 @@
+// Every piece of Path Guard'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 round (Game), the knobs (Tuning) and the player's settings (Prefs)
+// are resources. The actors are pooled rows spawned in `start`: one Plant
+// per buildable cell (placing a plant switches its row on), the Visitors
+// (the creeps) and the Shots, plus the Cursor and one Sfx row 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 plant is: the tray's order (keys 1, 2, 3). */
+export const Plant = { Thorn: 0, Frost: 1, Hedge: 2 } as const;
+export const PLANTS = ["thorn", "frost", "hedge"] as const;
+
+/** What a visitor is. */
+export const Kind = { Beetle: 0, Moth: 1, Snail: 2 } as const;
+
+/** Sound requests: bits of Game.sfx that the Voices system plays once each. */
+export const Sound = { Plant: 1, Thorn: 2, Frost: 4, Pop: 8, Leak: 16, Wave: 32, Clear: 64, Won: 128, Lost: 256, Move: 512 } as const;
+
+/** Why a placement was refused (Game.refused counts them; the HUD shakes and says why). */
+export const Refusal = { None: 0, Poor: 1, Blocked: 2, Taken: 3 } as const;
+
+/** The round: the lantern's light, the purse, the waves 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, { doc: "The pause menu is open (the garden holds)." }),
+  settingsOpen: bool(false, { doc: "The settings dialog is open." }),
+  won: bool(false, { doc: "The last round held every wave." }),
+  rounds: u32(0, { doc: "Rounds started." }),
+  lives: u32(0, { doc: "The lantern's light: a visitor that reaches the doorstep takes its share (Tuning.startLives at Play)." }),
+  gold: u32(0, { doc: "Coins to plant with." }),
+  wave: u32(0, { doc: "The wave under way or last spent (1-based; 0 before the first)." }),
+  inWave: bool(false, { doc: "Visitors of the wave are still coming or walking." }),
+  toSpawn: u32(0, { doc: "Visitors of this wave not yet through the gate." }),
+  spawnTicks: u32(0, { unit: "ticks", doc: "Ticks to the next visitor." }),
+  spawned: u32(0, { doc: "Visitors of this wave through the gate so far." }),
+  breakTicks: u32(0, { unit: "ticks", doc: "Ticks before the next wave starts by itself." }),
+  callNext: bool(false, { doc: "The player asked for the next wave now (an early call pays its bonus)." }),
+  walking: u32(0, { doc: "Visitors on the field now." }),
+  kills: u32(0, { doc: "Visitors turned away." }),
+  leaks: u32(0, { doc: "Visitors that reached the doorstep." }),
+  placed: u32(0, { doc: "Plants set this round (each stays to the round's end)." }),
+  refused: u32(0, { doc: "Placements refused (too poor, the path closed, the cell taken)." }),
+  refusal: u32(0, { doc: "Refusal.* of the last refused placement." }),
+  refusedTick: i32(-1, { unit: "ticks", doc: "The tick of the last refusal (the HUD shakes the gold on it)." }),
+  shots: u32(0, { doc: "Shots fired." }),
+  selected: u32(Plant.Thorn, { doc: "The plant the next placement sets (Plant.*)." }),
+  cursorX: i32(4, { doc: "The cursor's cell, a map column." }),
+  cursorY: i32(9, { doc: "The cursor's cell, a map row (0 the top)." }),
+  score: u32(0, { doc: "The last round's score: kills × 10 + light × 50 + coins left." }),
+  best: u32(0, { doc: "The best score, from the store." }),
+  newBest: bool(false),
+  bestRequest: u32(0, { doc: "The store request reading `best` (og.platform)." }),
+  bestRevision: u32(0, { doc: "The revision `best` was read or written at." }),
+  bestWrite: u32(0, { doc: "The store request writing `best`." }),
+  overTick: u32(0, { unit: "ticks", doc: "The tick the round ended." }),
+  lastStop: i32(-100, { unit: "ticks", doc: "The tick of the last kill's hit stop (at most one per 10 ticks, og-feel §3)." }),
+  occ0: u32(0, { doc: "Cells holding a visitor (bit per cell, row-major, 4 words): no plant goes there." }),
+  occ1: u32(0),
+  occ2: u32(0),
+  occ3: u32(0),
+  pendingPlants: u32(0, { doc: "Plants set on the pads layer that the Plants system has yet to switch on (the pads tile says which)." }),
+  reset: bool(false, { doc: "A new round asked the Plants and Visitors systems to clear their rows." }),
+  sfx: u32(0, { doc: "Sound.* bits waiting to play." }),
+  held: bool(false, { doc: "The time scale is held at 0 (paused or in the settings)." }),
+  viewW: f32(0, { unit: "cssPx", doc: "The surface the camera was last framed for." }),
+  viewH: f32(0, { unit: "cssPx" }),
+  viewTop: f32(0, { unit: "cssPx" }),
+  language: u32(0, { doc: "Prefs.language, mirrored for the facts." }),
+  grid: f64(0, { doc: "The og.nav grid of the field." }),
+  field: f64(0, { doc: "The og.nav flow field to the doorstep." }),
+  map: f64(0, { doc: "The field's og.Tilemap entity." }),
+  sheet: f64(0, { doc: "The sprite sheet's texture (cursor and range ring are drawn from it)." }),
+  ring: f64(0, { doc: "The range ring's texture." }),
+});
+
+/** The knobs. Tune reads the tunable fields; `set:Tuning.<field>=<value>` writes them. */
+export const Tuning = defineResource("Tuning", {
+  startGold: u32(150, { min: 0, max: 1000, step: 10, tunable: true, label: "Starting coins" }),
+  startLives: u32(10, { min: 1, max: 50, step: 1, tunable: true, label: "Lantern light" }),
+  waveBreak: f32(8, { min: 0, max: 30, step: 0.5, unit: "s", tunable: true, label: "Break between waves" }),
+  spawnGap: f32(1, { min: 0.2, max: 4, step: 0.1, unit: "s", tunable: true, label: "Gap between visitors" }),
+  hpGrowth: f32(0.2, { min: 0, max: 1, step: 0.02, tunable: true, label: "Visitor toughness per wave", doc: "Each wave's visitors have 1 + growth × (wave − 1) times their base health." }),
+  thornCost: u32(50, { min: 0, max: 500, step: 5, tunable: true, label: "Thorn cost" }),
+  thornDamage: f32(14, { min: 1, max: 100, step: 1, tunable: true, label: "Thorn damage" }),
+  thornReload: u32(30, { min: 6, max: 240, step: 2, unit: "ticks", tunable: true, label: "Thorn reload" }),
+  thornRange: f32(2.8, { min: 1, max: 6, step: 0.1, unit: "m", tunable: true, label: "Thorn range" }),
+  frostCost: u32(70, { min: 0, max: 500, step: 5, tunable: true, label: "Frost lily cost" }),
+  frostDamage: f32(5, { min: 0, max: 100, step: 1, tunable: true, label: "Frost damage" }),
+  frostReload: u32(60, { min: 6, max: 240, step: 2, unit: "ticks", tunable: true, label: "Frost reload" }),
+  frostRange: f32(2.2, { min: 1, max: 6, step: 0.1, unit: "m", tunable: true, label: "Frost range" }),
+  frostSlow: f32(0.5, { min: 0.1, max: 1, step: 0.05, tunable: true, label: "Frost slow", doc: "A frosted visitor walks at this fraction of its speed." }),
+  frostTicks: u32(120, { min: 0, max: 600, step: 10, unit: "ticks", tunable: true, label: "Frost length" }),
+  hedgeCost: u32(10, { min: 0, max: 200, step: 5, tunable: true, label: "Hedge cost" }),
+  shotSpeed: f32(11, { min: 2, max: 40, step: 0.5, unit: "m/s", tunable: true, label: "Shot speed" }),
+  killStop: u32(2, { min: 0, max: 8, step: 1, unit: "ticks", tunable: true, label: "Kill hit stop" }),
+  leakStop: u32(6, { min: 0, max: 16, step: 1, unit: "ticks", tunable: true, label: "Leak hit stop" }),
+  leakShake: f32(0.4, { min: 0, max: 1, step: 0.05, tunable: true, label: "Leak shake" }),
+});
+
+/** 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, doc: "The master volume." }),
+  music: f32(0.7, { min: 0, max: 1, doc: "The music bus." }),
+  effects: f32(1, { min: 0, max: 1, doc: "The effects and UI buses." }),
+  language: u32(0, { doc: "0 English, 1 简体中文 (LANGUAGES in src/ui.ts)." }),
+  reducedMotion: bool(false, { doc: "Screens fade instead of irising; shakes are a third." }),
+  loadRequest: u32(0, { doc: "The og.platform.loadSettings request." }),
+  loaded: bool(false, { doc: "The saved settings were applied (or there were none)." }),
+  saves: u32(0, { doc: "Times the settings were saved." }),
+});
+
+/** One cell's plant: every buildable cell has a row, off until a plant is set there. */
+export const Bed = defineComponent("Bed", {
+  cellX: i32(0, { doc: "The map column." }),
+  cellY: i32(0, { doc: "The map row (0 the top)." }),
+  planted: bool(false, { doc: "A plant stands here." }),
+  kind: u32(Plant.Thorn, { doc: "Plant.* of src/components.ts." }),
+  cool: u32(0, { unit: "ticks", doc: "Ticks to the next shot; the behaviour fires at 0 (assets/ai/*.ogt reads Bed.cool)." }),
+  anim: u32(0, { unit: "ticks", doc: "Ticks the shooting clip has left." }),
+  shots: u32(0, { doc: "Shots this plant fired." }),
+});
+
+/** A visitor (a creep): health, its walk and what turning it away pays. */
+export const Visitor = defineComponent("Visitor", {
+  slot: u32(0, { doc: "Its pool index." }),
+  active: bool(false, { doc: "Walking the field." }),
+  dying: u32(0, { unit: "ticks", doc: "Ticks left of its pop before the row is parked." }),
+  kind: u32(Kind.Beetle, { doc: "Kind.* of src/components.ts." }),
+  hp: f32(0),
+  maxHp: f32(0),
+  speed: f32(0, { unit: "m/s", doc: "Its walking speed before frost." }),
+  slow: u32(0, { unit: "ticks", doc: "Ticks of frost left." }),
+});
+
+/** A shot in flight: a tween carries it, its tag says whom it hits. */
+export const Shot = defineComponent("Shot", {
+  tween: f64(0, { doc: "Its flight's og.tween handle; the shot is free once that tween is done." }),
+});
+
+/** The cell cursor the keys and the pad move. */
+export const Cursor = defineComponent("Cursor", {
+  moves: u32(0, { doc: "Times it moved." }),
+});
+
+/** One voice: plays its sound once when Game.sfx asks for its bit. */
+export const Sfx = defineComponent("Sfx", {
+  bit: u32(0, { doc: "Sound.* of src/components.ts." }),
+  plays: u32(0, { doc: "Times it started." }),
+});

package/archetypes/tower-defense/src/main.ts

@@ -0,0 +1,253 @@
+// Path Guard, the tower-defense archetype (2D profile): a night garden,
+// visitors coming through the gate in the hedge and walking to the
+// lantern on the doorstep, and the plants a player sets on the lawn to
+// turn them away. Thorns shoot, frost lilies slow, hedges only block, and
+// every plant re-routes the visitors: they walk og.nav's flow field to the
+// doorstep, which goes round whatever stands on the lawn. Five waves; the
+// lantern's light runs out after ten visitors get through.
+//
+// `start` loads the field (assets/maps/garden.ogt: a tilemap whose hedges
+// and stones block), makes the walking grid and the flow field from it,
+// and spawns the pools: one Bed row per lawn cell (off until a plant is
+// set), the visitors, the shots, the cursor, the lantern and one voice per
+// sound. The systems are in src/systems.ts, the screens in src/ui.ts, the
+// state in src/components.ts.
+
+import { og } from "@origingame/engine";
+import type { Entity, World } from "@origingame/engine";
+import { checkClips, clipOf } from "./art.ts";
+import { Bed, Cursor, Game, Phase, Prefs, Sfx, Shot, Sound, Tuning, Visitor } from "./components.ts";
+import { buildable, cellCenter, COLS, Control, DOOR, endRound, fire, place, Plants, ROWS, SHOTS, Visitors, VISITORS, Voices, WAVES } from "./systems.ts";
+import { LANGUAGES, startRound, Ui } from "./ui.ts";
+
+/** The night behind the field, linear. */
+const NIGHT = { r: 0.0047, g: 0.0137, b: 0.0091 };
+
+function must<T>(r: { ok: true; value: T } | { ok: false; reason: string }): T;
+function must(r: { ok: true } | { ok: false; reason: string }): void;
+function must<T>(r: { ok: true; value?: T } | { ok: false; reason: string }): T | void {
+  if (!r.ok) throw new Error(r.reason);
+  return r.value;
+}
+
+function start(world: World): void {
+  for (const l of LANGUAGES) must(og.i18n.load(world, `strings/${l.code}.ogt`));
+  const skin = must(og.load.skin(world, "skins/pathguard/skin.ogt"));
+  const sound = (path: string) => must(og.load.sound(world, path));
+  must(
+    og.ui.configure(world, {
+      skin,
+      sounds: { press: sound("audio/ui-press.ogt"), open: sound("audio/ui-open.ogt"), close: sound("audio/ui-close.ogt"), error: sound("audio/ui-error.ogt"), success: sound("audio/ui-success.ogt") },
+    }),
+  );
+
+  const settings = must(world.resource(og.RenderSettings));
+  settings.environmentIntensity = 0;
+  settings.toneMapped = false;
+  const camera = must(world.resource(og.Camera));
+  camera.orthographic = true;
+  camera.height = 14;
+  camera.position = { x: COLS / 2, y: ROWS / 2, z: 50 };
+  camera.background = NIGHT;
+
+  const sheet = must(og.load.flipbook(world, "sprites/garden.ogt"));
+  checkClips(sheet);
+  const tilemap = must(og.load.tilemap(world, "maps/garden.ogt"));
+  const map = must(world.spawn({ name: "garden", position: { x: 0, y: tilemap.height * tilemap.tileHeight, z: 0 } }));
+  must(world.insert(map, og.Tilemap, { map: tilemap.map }));
+  // The walking grid from the hedges and stones, and the flow field every visitor follows to the doorstep.
+  const grid = must(og.nav.gridFromTilemap(world, { entity: map, layers: ["walls"] }));
+  const goal = cellCenter(DOOR.x, DOOR.y);
+  const field = must(og.nav.flowField(world, { grid, targets: [{ x: goal.x, y: goal.y, z: 0 }] }));
+  const mind = must(og.ai.load(world, "ai/plant.ogt"));
+  const pop = must(og.load.emitter(world, "fx/pop.ogt"));
+
+  const game = must(world.resource(Game));
+  game.grid = grid as unknown as number;
+  game.field = field as unknown as number;
+  game.map = map as unknown as number;
+  game.sheet = sheet.texture as unknown as number;
+  game.ring = must(og.load.texture(world, "sprites/ring.png")) as unknown as number;
+
+  const sprite = (e: Entity, clip: string, layer: number, visible: boolean, size = 1) => {
+    must(world.insert(e, og.Sprite, { texture: sheet.texture, width: size, height: size, layer, visible, sortY: true }));
+    must(world.insert(e, og.Flipbook, { sheet: sheet.sheet, clip: clipOf(clip) }));
+  };
+
+  // One bed per lawn cell: a plant there is this row switched on.
+  for (let y = 1; y < ROWS - 1; y++) {
+    for (let x = 1; x < COLS - 1; x++) {
+      const c = cellCenter(x, y);
+      const bed = must(world.spawn({ name: `bed-${x}-${y}`, position: { x: c.x, y: c.y, z: 0 } }));
+      sprite(bed, "thorn", 1, false);
+      must(world.insert(bed, Bed, { cellX: x, cellY: y }));
+      must(world.insert(bed, og.AiAgent, { behaviour: mind.behaviour, active: false }));
+      must(world.insert(bed, og.Perception, { sight: 0, fov: 360, occlude: false, team: 1, memory: 0 }));
+    }
+  }
+  for (let i = 0; i < VISITORS; i++) {
+    const v = must(world.spawn({ name: `visitor-${i}`, position: { x: -40, y: -40, z: 0 } }));
+    sprite(v, "beetle", 2, false, 0.9);
+    must(world.insert(v, Visitor, { slot: i }));
+    must(world.insert(v, og.NavAgent, { nav: field, target: { x: goal.x, y: goal.y, z: 0 }, seeking: false, speed: 1, acceleration: 30, radius: 0.3, stopDistance: 0.2, slowRadius: 0, faceMovement: true, turnSpeed: 14 }));
+    must(world.insert(v, og.Perceivable, { team: 2 }));
+    must(world.insert(v, og.ParticleSystem, { emitter: pop, seed: i + 1, visible: false }));
+  }
+  for (let i = 0; i < SHOTS; i++) {
+    const s = must(world.spawn({ name: `shot-${i}`, position: { x: -40, y: -40, z: 0 } }));
+    sprite(s, "seed", 5, true, 0.6);
+    must(world.set(s, og.Sprite, { opacity: 0, sortY: false }));
+    must(world.insert(s, Shot));
+  }
+  const lantern = must(world.spawn({ name: "lantern", position: { x: goal.x, y: goal.y + 0.1, z: 0 } }));
+  sprite(lantern, "lantern", 3, true, 1.1);
+  // The night: a pale glow behind the field and fireflies over it.
+  const glow = must(world.spawn({ name: "moonlight", position: { x: COLS / 2, y: ROWS / 2, z: 0 } }));
+  must(world.insert(glow, og.Sprite, { texture: must(og.load.texture(world, "sprites/glow.png")), width: 24, height: 24, color: { r: 0.45, g: 0.75, b: 0.55 }, opacity: 0.22, layer: -40 }));
+  const flies = must(world.spawn({ name: "fireflies", position: { x: COLS / 2, y: ROWS / 2, z: 0 } }));
+  must(world.insert(flies, og.ParticleSystem, { emitter: must(og.load.emitter(world, "fx/fireflies.ogt")), seed: 7 }));
+  const cursor = must(world.spawn({ name: "cursor", position: { x: -40, y: -40, z: 0 } }));
+  must(world.insert(cursor, Cursor));
+
+  // The voices: one per sound, played by Voices; the music loops on its bus.
+  const voices: [string, number, "sfx" | "ui", number][] = [
+    ["audio/plant.wav", Sound.Plant, "ui", 0.7],
+    ["audio/thorn.wav", Sound.Thorn, "sfx", 0.35],
+    ["audio/frost.wav", Sound.Frost, "sfx", 0.35],
+    ["audio/pop.wav", Sound.Pop, "sfx", 0.6],
+    ["audio/leak.wav", Sound.Leak, "sfx", 0.8],
+    ["audio/wave.wav", Sound.Wave, "sfx", 0.6],
+    ["audio/clear.wav", Sound.Clear, "sfx", 0.6],
+    ["audio/won.wav", Sound.Won, "sfx", 0.7],
+    ["audio/lost.wav", Sound.Lost, "sfx", 0.7],
+    ["audio/ui-press.ogt", Sound.Move, "ui", 0.25],
+  ];
+  for (const [path, bit, bus, volume] of voices) {
+    const v = must(world.spawn({ name: `sfx-${bit}` }));
+    must(world.insert(v, og.AudioSource, { sound: sound(path), playing: false, bus, volume, priority: 160 }));
+    must(world.insert(v, Sfx, { bit }));
+  }
+  const music = must(world.spawn({ name: "music" }));
+  must(world.insert(music, og.AudioSource, { sound: sound("audio/night.wav"), bus: "music", loop: true, volume: 0.55, priority: 220 }));
+  // The music ducks under the hits and the waves (og-audio §4).
+  const fx = must(world.spawn({ name: "music-bus" }));
+  must(world.insert(fx, og.AudioBusFx, { bus: "music", duck: true, duckBus: "sfx", duckDepth: 6, duckRelease: 0.5 }));
+}
+
+function gameOf(world: World) {
+  return must(world.resource(Game));
+}
+
+function num(s: string | undefined, what: string): number {
+  const n = Number(s);
+  if (s === undefined || !Number.isFinite(n)) throw new Error(`${what} is a number`);
+  return n;
+}
+
+/** `begin`: start a round now, as Play on the title does. */
+function begin(world: World): void {
+  startRound(world, gameOf(world), must(world.resource(Tuning)));
+}
+
+/** `plant:<thorn|frost|hedge>:<x>:<y>`: set a plant on a map cell (column, row from the top) as a placement does, refusals included. */
+function plantCmd(world: World, args: readonly string[]): void {
+  const kind = ["thorn", "frost", "hedge"].indexOf(args[0] ?? "");
+  if (kind < 0) throw new Error("write plant:<thorn|frost|hedge>:<x>:<y>");
+  const g = gameOf(world);
+  g.selected = kind;
+  place(world, g, must(world.resource(Tuning)), num(args[1], "x"), num(args[2], "y"));
+}
+
+/** `gold:<n>`: set the purse. */
+function gold(world: World, args: readonly string[]): void {
+  gameOf(world).gold = num(args[0], "n");
+}
+
+/** `wave:<n>`: skip to the break before wave n (the field and the purse stay). */
+function wave(world: World, args: readonly string[]): void {
+  const g = gameOf(world);
+  const n = Math.max(1, Math.min(WAVES.length, num(args[0], "n")));
+  g.wave = n - 1;
+  g.inWave = false;
+  g.toSpawn = 0;
+  g.breakTicks = Math.max(1, Math.round(must(world.resource(Tuning)).waveBreak * 60));
+}
+
+/** `lose`: put the lantern out (the round ends lost on the next tick). */
+function lose(world: World): void {
+  const g = gameOf(world);
+  if (g.phase === Phase.Play) g.lives = 0;
+}
+
+/** `win`: end the round as won now. */
+function win(world: World): void {
+  const g = gameOf(world);
+  if (g.phase === Phase.Play) endRound(world, g, true);
+}
+
+/** `viewport:<desktop|phone>`: lay the UI out for that surface (og.ui.previewViewport). */
+function viewport(world: World, args: readonly string[]): void {
+  const phone = { width: 390, height: 844, dpr: 3, safeArea: { left: 0, top: 47, right: 0, bottom: 34 }, coarsePointer: true, breakpoint: "phonePortrait" } as const;
+  og.ui.previewViewport(world, args[0] === "phone" ? phone : null);
+}
+
+/** `language:<en|zh-CN>`: switch the language as the settings do. */
+function language(world: World, args: readonly string[]): void {
+  const p = must(world.resource(Prefs));
+  const at = LANGUAGES.findIndex((l) => l.code === args[0]);
+  if (at < 0) throw new Error(`write language:<${LANGUAGES.map((l) => l.code).join("|")}>`);
+  p.language = at;
+  og.i18n.setLocale(world, LANGUAGES[at]!.code);
+}
+
+export default og.game({
+  tick: 60,
+  seed: 1,
+  resources: [Game, Tuning, Prefs],
+  systems: [Control, Plants, Visitors, Ui, Voices],
+  render: { antialias: "off" },
+  start,
+  commands: { fire, begin, plant: plantCmd, gold, wave, lose, win, viewport, language },
+  commandHelp: {
+    fire: { usage: "<plant>", doc: "The plants' behaviour command (og.ai queues it with the plant's handle): a shot at what it sees." },
+    begin: { usage: "", doc: "Start a round now, as Play on the title does." },
+    plant: { usage: "<thorn|frost|hedge>:<x>:<y>", doc: "Set a plant on a map cell (column, row from the top) as a placement does, refusals included." },
+    gold: { usage: "<n>", doc: "Set the purse." },
+    wave: { usage: "<n>", doc: "Skip to the break before wave n (the field and the purse stay)." },
+    lose: { usage: "", doc: "Put the lantern out: the round ends lost." },
+    win: { usage: "", doc: "End the round as won now." },
+    viewport: { usage: "<desktop|phone>", doc: "Lay the UI out for a phone in portrait (390×844 at 3×) or back for the surface." },
+    language: { usage: "<en|zh-CN>", doc: "Switch the language as the settings do." },
+  },
+  facts: (world) => {
+    const game = world.resource(Game);
+    if (!game.ok) return null;
+    const g = game.value;
+    return {
+      phase: ["title", "play", "over"][g.phase],
+      paused: g.paused,
+      settings: g.settingsOpen,
+      wave: g.wave,
+      waves: WAVES.length,
+      inWave: g.inWave,
+      lives: g.lives,
+      gold: g.gold,
+      kills: g.kills,
+      leaks: g.leaks,
+      placed: g.placed,
+      refused: g.refused,
+      refusal: ["none", "poor", "blocked", "taken"][g.refusal],
+      shots: g.shots,
+      walking: g.walking,
+      selected: ["thorn", "frost", "hedge"][g.selected],
+      cursor: { x: g.cursorX, y: g.cursorY },
+      cursorBuildable: buildable(world, g, g.cursorX, g.cursorY),
+      won: g.won,
+      score: g.score,
+      best: g.best,
+      newBest: g.newBest,
+      rounds: g.rounds,
+      language: LANGUAGES[g.language]!.code,
+    };
+  },
+});