@origingame/create-game 0.1.1 → 0.3.0

package/README.md

@@ -1,7 +1,8 @@
 # @origingame/create-game
 
-Scaffolds an Origin Engine game from the project template (`templates/game`
-of the engine repository): `project.ogt`, `src/`, `assets/`, `tests/`,
+Scaffolds an Origin Engine game from a project template of the engine
+repository, the 3D template `templates/game` or the 2D starter
+`templates/game-2d`: `project.ogt`, `src/`, `assets/`, `tests/`,
 `package.json` and `tsconfig.json`, with the game's name and id filled in.
 
 ```sh
@@ -9,13 +10,20 @@ bun packages/create/bin/create.ts my-game --name "My Game"   # in the engine rep
 cd my-game && bun install && og cook && og run .
 ```
 
-`create [dir] [--name "Name"] [--id slug] [--archetype name] [--premise "one line"] [--look slug] [--force]`: the
+`create [dir] [--name "Name"] [--id slug] [--profile 2d|3d] [--archetype name] [--premise "one line"] [--look slug] [--force]`: the
 id defaults to the name in lowercase-hyphen form (or the directory's name);
 a directory that is not empty is refused unless `--force` is given.
+`--profile 2d` writes the 2D starter (a courier's platformer: sprites,
+flipbooks, a tilemap with one-way ledges, 2D physics, a HUD and a pause
+menu, one playtest), `--profile 3d` the 3D template; without the flag, a
+premise that says 2D, platformer, side-scroller, metroidvania, pixel art,
+sprites or tiles without saying 3D gets the 2D starter, anything else the
+3D template. The output's `Profile:` line says which and why.
 `--archetype` starts from a complete game of `templates/archetypes/`
-instead of the template: `runner`, `match3`, `topdown`, `tower-defense`,
-`roguelike`, `idle`, `rhythm` or `third-person` (the published package carries them under
-`archetypes/`).
+instead of either template: `runner`, `match3`, `topdown`, `tower-defense`,
+`roguelike`, `idle`, `rhythm`, `third-person` or `arena` (the published package carries them under
+`archetypes/`); an archetype has its own profile, so `--profile` beside it
+is refused.
 
 Every game gets its look: `assets/looks/<id>.ogt`, an `.ogt` of `type look`
 (og-taste §12 of the knowledge package) that `GameDesc.look` in the entry
@@ -30,7 +38,7 @@ catalogue (`packages/knowledge/looks/catalogue.json`, 37 styles):
   whole, then to catalogue order). On a terminal, with neither flag, create
   asks for the premise (`--no-prompt` does not);
 - otherwise the template's own look stays: the plain template extends
-  `faceted-low-poly`, the idle archetype carries its skin and render
+  `faceted-low-poly`, the idle archetype carries its UI style and render
   settings, and the other archetypes get a look that extends nothing (their
   frames stay as their `references/` recorded them).
 
@@ -42,8 +50,8 @@ is, what it extends and how to change it. For an archetype, a preset moves
 the frames its `references/` hold; create says so and how to record them
 again.
 
-The published package carries the template under `template/` and the style
-catalogue under `looks/`, copied by the `prepack` script
+The published package carries the 3D template under `template/`, the 2D
+starter under `template-2d/` and the style catalogue under `looks/`, copied by the `prepack` script
 (`scripts/pack-template.ts`); build output (`cooked/`,
 `dist/`, `node_modules/`) is never copied. The template's `gitattributes`
 (media through Git LFS) is written as the project's `.gitattributes`: under

package/archetypes/README.md

@@ -1,8 +1,10 @@
 # Archetypes
 
 Complete games a Maker starts from, each a project like `templates/game`
-(`project.ogt`, `src/`, `assets/`, `tests/`, `package.json`,
-`tsconfig.json`) that `og run`, `og test` and `og build` take as is. They
+and the 2D starter `templates/game-2d` (`project.ogt`, `src/`, `assets/`,
+`tests/`, `package.json`, `tsconfig.json`) that `og run`, `og test` and
+`og build` take as is; `npm create @origingame/game --archetype <name>`
+writes one, with its own profile. They
 rebuild the platform's six Godot Discover prototypes on Origin Engine,
 keeping each prototype's premise and lessons and none of its code or art,
 and add a top-down room built for the engine's 2D and game-feel modules
@@ -17,6 +19,7 @@ and a third-person vale, the engine's mid-size 3D slice.
 | `roguelike/` | Lamp Dive | 2d | the arrows or WASD, a tap on the next cell, a pad, or the HUD's d-pad | step a turn at a time through a fresh tomb, strike what the lamp shows, take what it finds, reach the relic on floor 2 with one life |
 | `idle/` | Spark Orb | 2d | taps or Space on the orb, 1–4 or the cards to buy, a pad | tap for sparks, buy generators that make them, double each kind every tenth, collapse into a supernova for stardust, come back to what it made while away |
 | `rhythm/` | Three-Lane Beat | 2d | A S D or the arrows, fingers on the lanes, a pad | read the notes falling to the line, hit each on its time, keep the combo and the groove, clear the song |
+| `arena/` | Coin Duel | 2d | WASD or the arrows, Space or Shift to dash, a pad; two players over a room | race the other player to the coin, first to five; played in lockstep through `og relay` or the platform's rooms |
 | `third-person/` | Ember Vale | 3d | WASD or the arrows, Shift, Space, hold F, Q and E; a pad; a touch joystick, Jump and Kindle | walk, wade and jump a lake vale at dusk, kindle four beacons before night while stone sentinels on their rounds hunt you |
 
 Each archetype's README has its rules, components, systems, tunables, the

package/archetypes/arena/.origin/setup

@@ -0,0 +1,14 @@
+#!/bin/sh
+# Prepares this Game's cloud sandbox snapshot: Origin runs it once per
+# snapshot build, in the checkout, without a terminal, for at most 20 minutes,
+# and saves the result for new sandboxes of the Game. Keep it idempotent; it
+# never receives credentials. Only ignored output is kept: node_modules/ and
+# cooked/ (og cook is incremental, so a new sandbox starts cooked).
+set -eu
+if [ -f bun.lock ]; then bun install --frozen-lockfile; else bun install; fi
+og="${ORIGIN_OG_BIN:-og}"
+if ! command -v "$og" >/dev/null 2>&1; then
+  echo "no og on this executor class; the first og run cooks instead"
+  exit 0
+fi
+"$og" cook .

package/archetypes/arena/LICENSES.md

@@ -0,0 +1,8 @@
+# Asset licences
+
+| File | Licence | Origin |
+|---|---|---|
+| `assets/audio/*.ogt` | CC0 1.0 | self-made: og sfx presets (`coin`, `whoosh`, `levelup`) the cook synthesises |
+| `assets/fx/coin.ogt` | CC0 1.0 | self-made: an untextured particle emitter |
+
+The UI draws in the engine's built-in neon style (`assets/looks/arena.ogt`), whose fonts the engine package carries with their own licences. Everything else the game draws is solid sprites the code places; there is no other art.

package/archetypes/arena/README.md

@@ -0,0 +1,67 @@
+# Coin Duel — the arena archetype (2D, two players)
+
+Two fighters, Red and Blue, on one floor race for one coin. Each touch
+scores a point and moves the coin; the first to five wins the round. Move
+with WASD or the arrows (or a pad's left stick), dash with Space or Shift.
+
+金币对决：两名玩家在同一场地抢一枚金币，碰到得一分，金币换位置，先到五分者赢。通过房间（`og relay` 或平台房间）以锁步同步对战。
+
+The game plays alone, with the local keys driving Red. It also plays over a
+**room in lockstep** (docs/design.md §2.8, §2.10): each process runs the
+whole world, and only the two players' inputs and the world's hash cross
+the room.
+
+```sh
+og relay                                              # terminal 1: ws://127.0.0.1:47900/<room>
+og run . --room ws://127.0.0.1:47900/duel --realtime  # terminals 2 and 3
+og run . --headless --setup bot:1 --ticks 600 --json  # alone, scripted
+og test .                                             # tests/duel.og.ts (two processes through a relay), tests/solo.og.ts
+og polish .                                           # og-taste and og-feel measured over both playtests
+```
+
+## How it is made deterministic
+
+- `start` sets `og.Lockstep` (`enabled`, `players: 2`, `inputDelay: 2`,
+  `hashEvery: 10`). It spawns two fighters, each with an `og.PlayerInput`
+  whose `player` is its seat, and the coin.
+- `Submit` is the **only** system that reads `og.Input` and `og.Gamepad`.
+  It hands this peer's input to `og.net.submit`.
+- `Move` and `CoinDrop` read `og.PlayerInput`, `Tuning` and `og.Rng` only:
+  the same on every peer.
+- `Feedback` and `Voices` play what `Move` and `CoinDrop` asked for in
+  `Duel` (`sfx`, `took`): the coin's chime, a ring of sparks where it lay,
+  "+1" in the taker's ink, a 3-tick hit stop and a light shake; a dash's
+  whoosh; a round's fanfare and a heavier shake. They read the world
+  alone, so every peer plays them the same.
+- `Hud` draws this peer's own line ("You are Red", "Waiting for 1 more")
+  and keeps nothing in the world.
+
+A system that read `og.Input` to move a fighter, or one that used
+`Math.random()`, `Date.now()` or a module variable, would part the worlds:
+`og.Desync` names the first divergent tick, and `dump_desync` names the
+component and field (`og run --commands "...:dump_desync:d.json"`).
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `bot:<n>` | This peer's input comes from scripted bot n (it runs toward the coin and weaves); 0 hands the input back to the keys. It is input, so each peer's bot drives only that peer's seat. |
+| `warp:<player>:<x>:<y>` | Put fighter 0 (Red) or 1 (Blue) at a point of the floor (0..16 × 0..9). |
+
+## Tunables
+
+`Tuning`: `speed`, `dashSpeed`, `dashTicks`, `dashCooldown`, `target`,
+`restTicks`. A tunable must be the same on every peer. Change it in code or
+on every peer at the same tick; otherwise `og.Desync` reports it.
+
+The look (`assets/looks/arena.ogt`) puts the UI in the catalogue's neon
+style. `og polish` on vulkan-cpu scores taste 100 and feel 66; its one
+finding is frame time, which lavapipe's software rasteriser sets (about
+27 ms to draw four sprites), not the game.
+
+## What a Maker changes first
+
+The fighters' look (they are solid sprites), the rules in `src/game.ts`,
+and `players` for more seats (up to 16; seats nobody holds read zero
+input). Keep every rule a function of `og.PlayerInput`, the world and
+`og.Rng`.

package/archetypes/arena/assets/audio/coin.ogt

@@ -0,0 +1,9 @@
+type sfx
+version 1
+---
+# A coin taken: og.load.sound(world, "audio/coin.ogt").
+preset "coin"
+seed 1
+pitch 1
+length 1
+volume 0.8

package/archetypes/arena/assets/audio/dash.ogt

@@ -0,0 +1,9 @@
+type sfx
+version 1
+---
+# A dash: a short swell of air.
+preset "whoosh"
+seed 2
+pitch 1.4
+length 0.5
+volume 0.6

package/archetypes/arena/assets/audio/win.ogt

@@ -0,0 +1,9 @@
+type sfx
+version 1
+---
+# A round won: a rising fanfare.
+preset "levelup"
+seed 3
+pitch 1
+length 1
+volume 0.8

package/archetypes/arena/assets/fx/coin.ogt

@@ -0,0 +1,20 @@
+type particles
+version 1
+---
+# A coin taken: a ring of gold sparks thrown from where it lay.
+maxParticles 40
+shape point
+spread 180
+rate 0
+burst 0 28
+duration 0.1
+looping false
+lifetime 0.35 0.7
+speed 3 6
+size 0.12 0.24
+colorOverLife {
+  key 0 1 0.8 0.3 1
+  key 1 1 0.5 0.1 0
+}
+drag 3
+blend additive

package/archetypes/arena/assets/looks/arena.ogt

@@ -0,0 +1,10 @@
+type look
+version 1
+---
+# Coin Duel's look (og-taste §12), named by GameDesc.look in src/main.ts:
+# the catalogue's neon UI style for the scores and the status line (an
+# arcade duel on a dark floor; `og polish` flagged the engine's placeholder
+# prototype style). The floor, the fighters and the coin are the sprites
+# start places in their own inks.
+name "Coin Duel"
+ui "@styles/neon/style.ogt"

package/archetypes/arena/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/arena/gitignore

@@ -0,0 +1,8 @@
+# og cook output: rebuilt from assets/, never committed.
+cooked/
+# og build output.
+dist/
+# og run and og test output, and og's bundled entry.
+og-out/
+.og/
+node_modules/

package/archetypes/arena/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/arena/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "origin-arena",
+  "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.3.0"
+  }
+}

package/archetypes/arena/project.ogt

@@ -0,0 +1,14 @@
+type project
+version 1
+---
+name "Coin Duel"
+id "arena"
+engine "0.3.0"
+entry "src/main.ts"
+profile "2d"
+tick 60
+seed 1
+publish {
+  probe player
+  out "dist"
+}

package/archetypes/arena/src/game.ts

@@ -0,0 +1,314 @@
+// Coin Duel's state and systems. Everything that moves the world reads
+// og.PlayerInput, the per-player input lockstep makes the same on every
+// peer; og.Input (this peer's keys) is read by one system only, Submit,
+// which hands it to og.net.submit. That split is the whole of what makes the
+// game play over a room (docs/design.md §2.10): a system that read og.Input
+// to move a fighter would move it on this peer alone, and the other peer's
+// og.Desync would name the field.
+
+import { og, defineComponent, defineResource, defineSystem, f32, u32 } from "@origingame/engine";
+import type { Result, World } from "@origingame/engine";
+
+/** The arena's floor, world units: (0, 0) to (WIDTH, HEIGHT). */
+export const WIDTH = 16;
+export const HEIGHT = 9;
+/** A fighter's half size and the coin's: they touch when their boxes overlap. */
+export const FIGHTER = 0.4;
+export const COIN = 0.25;
+/** og.PlayerInput.buttons: bit 0 dashes. */
+export const DASH = 1;
+/** Duel.sfx: the sounds asked for this tick. */
+export const Sound = { Coin: 1, Dash: 2, Win: 4 } as const;
+/** Gold, linear: the coin, its sparks. */
+const GOLD_TEXT = { r: 1, g: 0.78, b: 0.25 };
+/** Red and Blue for the "+1" over the taker. */
+const TEXT_INKS = [
+  { r: 1, g: 0.42, b: 0.36 },
+  { r: 0.45, g: 0.68, b: 1 },
+];
+
+/** One of the two fighters: its own state beside the og.PlayerInput the engine writes. */
+export const Fighter = defineComponent("Fighter", {
+  /** Ticks left of a dash (moving at Tuning.dashSpeed), then of its cooldown below zero. */
+  dash: f32(0, { unit: "ticks" }),
+  /** The last move direction, for a dash without keys. */
+  faceX: f32(1),
+  faceY: f32(0),
+});
+
+/** The coin both fighters run for. */
+export const Coin = defineComponent("Coin", {});
+
+/** The round: the scores, the coin, the positions the coin and the HUD read. */
+export const Duel = defineResource("Duel", {
+  score0: u32(),
+  score1: u32(),
+  /** The fighter who reached Tuning.target first, plus one; 0 while playing. */
+  winner: u32(),
+  /** Ticks until the next round once a fighter won. */
+  rest: u32(0, { unit: "ticks" }),
+  /** The coin was taken this tick: CoinDrop moves it. */
+  taken: u32(),
+  coinX: f32(WIDTH / 2, { unit: "m" }),
+  coinY: f32(HEIGHT / 2, { unit: "m" }),
+  coins: u32(),
+  /** Where each fighter stands, written by Move. */
+  x0: f32(0, { unit: "m" }),
+  y0: f32(0, { unit: "m" }),
+  x1: f32(0, { unit: "m" }),
+  y1: f32(0, { unit: "m" }),
+  /** Sound.* bits asked for this tick; Feedback plays and clears them. */
+  sfx: u32(),
+  /** The coin taken this tick, by whom (player + 1), and where it lay: Feedback's sparks, "+1" and shake. */
+  took: u32(),
+  tookX: f32(0, { unit: "m" }),
+  tookY: f32(0, { unit: "m" }),
+});
+
+/** A one-shot voice: Feedback starts it when its Sound bit is asked for. */
+export const Voice = defineComponent("Voice", { bit: u32(), plays: u32() });
+/** The coin's spark emitter: Feedback moves it where the coin was and restarts it. */
+export const Sparks = defineComponent("Sparks", { bursts: u32() });
+
+/** The tunables: `set:Tuning.<field>=<value>` and Tune write them; the same on every peer, or the worlds part. */
+export const Tuning = defineResource("Tuning", {
+  speed: f32(6, { unit: "m/s", min: 1, max: 20 }),
+  dashSpeed: f32(16, { unit: "m/s", min: 1, max: 40 }),
+  dashTicks: f32(8, { unit: "ticks", min: 1, max: 30 }),
+  dashCooldown: f32(40, { unit: "ticks", min: 0, max: 240 }),
+  target: u32(5, { min: 1, max: 99 }),
+  restTicks: u32(120, { unit: "ticks", min: 1, max: 600 }),
+});
+
+export function must<T>(r: Result<T>): T {
+  if (!r.ok) throw new Error(r.reason);
+  return r.value;
+}
+
+/**
+ * A scripted player for playtests and the two-process run (`bot:<n>`):
+ * this peer's input comes from the tick instead of the keys. It is input,
+ * so it lives outside the world: each peer's bot drives only its own seat.
+ */
+let bot = 0;
+export function setBot(n: number): void {
+  if (!Number.isInteger(n) || n < 0) throw new Error("write bot:<n> with a whole number (0 hands the keys back)");
+  bot = n;
+}
+
+/** The bot's input at a tick: towards the coin, weaving by its number, a dash every 90 ticks. */
+function botInput(n: number, tick: number, from: { x: number; y: number }, to: { x: number; y: number }): { x: number; y: number; buttons: number } {
+  const dx = to.x - from.x;
+  const dy = to.y - from.y;
+  const len = Math.max(Math.hypot(dx, dy), 1e-3);
+  const weave = 0.7 * Math.sin(tick * 0.045 * (1 + 0.3 * n) + n);
+  return { x: dx / len - (dy / len) * weave, y: dy / len + (dx / len) * weave, buttons: (tick + 23 * n) % 90 < 2 ? DASH : 0 };
+}
+
+/** This peer's keys (or pad, or bot) to og.net.submit: the only reader of og.Input. */
+export const Submit = defineSystem("Submit", { reads: [og.Input, og.Gamepad, og.Lockstep, Duel] }, (_q, time, world) => {
+  if (bot > 0) {
+    const d = must(world.resource(Duel));
+    const me = must(world.resource(og.Lockstep)).localPlayer === 1 ? { x: d.x1, y: d.y1 } : { x: d.x0, y: d.y0 };
+    const input = botInput(bot, time.tick, me, { x: d.coinX, y: d.coinY });
+    must(og.net.submit(world, { x: Math.max(-1, Math.min(1, input.x)), y: Math.max(-1, Math.min(1, input.y)), buttons: input.buttons }));
+    return;
+  }
+  const input = must(world.resource(og.Input));
+  const pad = must(world.resource(og.Gamepad));
+  const sx = pad.axis("leftX", 0);
+  const sy = pad.axis("leftY", 0);
+  const x = Math.max(-1, Math.min(1, input.axis("KeyA", "KeyD") + input.axis("ArrowLeft", "ArrowRight") + (Math.abs(sx) > 0.25 ? sx : 0)));
+  const y = Math.max(-1, Math.min(1, input.axis("KeyS", "KeyW") + input.axis("ArrowDown", "ArrowUp") - (Math.abs(sy) > 0.25 ? sy : 0)));
+  const dash = input.down("Space") || input.down("ShiftLeft") || pad.down("a", 0);
+  must(og.net.submit(world, { x, y, buttons: dash ? DASH : 0 }));
+});
+
+/** Each fighter from its player's og.PlayerInput: walk, dash, stay on the floor, take the coin. */
+export const Move = defineSystem(
+  "Move",
+  { reads: [og.PlayerInput, Tuning], writes: [Fighter, og.Transform, og.Sprite, Duel], after: ["Submit"] },
+  (q, time, world) => {
+    const t = must(world.resource(Tuning));
+    const duel = must(world.resource(Duel));
+    const playing = duel.winner === 0;
+    for (const a of q.archetypes()) {
+      const input = a.column(og.PlayerInput);
+      const f = a.column(Fighter);
+      const p = a.column(og.Transform).position;
+      const sprite = a.column(og.Sprite);
+      for (let i = 0; i < a.count; i++) {
+        let x = playing ? input.x[i]! : 0;
+        let y = playing ? input.y[i]! : 0;
+        const len = Math.hypot(x, y);
+        if (len > 1) {
+          x /= len;
+          y /= len;
+        }
+        if (len > 0.1) {
+          f.faceX[i] = x / Math.max(len, 1e-6);
+          f.faceY[i] = y / Math.max(len, 1e-6);
+        }
+        if (playing && (input.buttons[i]! & DASH) !== 0 && f.dash[i]! <= -t.dashCooldown) {
+          f.dash[i] = t.dashTicks;
+          duel.sfx |= Sound.Dash;
+        }
+        let vx = x * t.speed;
+        let vy = y * t.speed;
+        if (f.dash[i]! > 0) {
+          vx = f.faceX[i]! * t.dashSpeed;
+          vy = f.faceY[i]! * t.dashSpeed;
+        }
+        if (f.dash[i]! > -t.dashCooldown) f.dash[i]! -= 1;
+        p[i * 3] = Math.max(FIGHTER, Math.min(WIDTH - FIGHTER, p[i * 3]! + vx * time.dt));
+        p[i * 3 + 1] = Math.max(FIGHTER, Math.min(HEIGHT - FIGHTER, p[i * 3 + 1]! + vy * time.dt));
+        sprite.flash[i] = f.dash[i]! > 0 ? 0.6 : 0;
+        if (input.player[i] === 0) {
+          duel.x0 = p[i * 3]!;
+          duel.y0 = p[i * 3 + 1]!;
+        } else {
+          duel.x1 = p[i * 3]!;
+          duel.y1 = p[i * 3 + 1]!;
+        }
+        if (
+          playing &&
+          duel.taken === 0 &&
+          Math.abs(p[i * 3]! - duel.coinX) < FIGHTER + COIN &&
+          Math.abs(p[i * 3 + 1]! - duel.coinY) < FIGHTER + COIN
+        ) {
+          duel.taken = input.player[i]! + 1;
+        }
+      }
+    }
+  },
+);
+
+/** The coin taken: a point to its taker, the coin to a fresh place from og.Rng, and the round's end at Tuning.target. */
+export const CoinDrop = defineSystem(
+  "CoinDrop",
+  { reads: [Coin, Tuning], writes: [og.Transform, Duel, og.Rng], after: ["Move"] },
+  (q, _time, world) => {
+    const t = must(world.resource(Tuning));
+    const duel = must(world.resource(Duel));
+    const rng = must(world.resource(og.Rng));
+    if (duel.winner !== 0) {
+      duel.rest -= 1;
+      if (duel.rest === 0) {
+        duel.winner = 0;
+        duel.score0 = 0;
+        duel.score1 = 0;
+      }
+    }
+    if (duel.taken !== 0) {
+      if (duel.taken === 1) duel.score0 += 1;
+      else duel.score1 += 1;
+      duel.coins += 1;
+      duel.took = duel.taken;
+      duel.tookX = duel.coinX;
+      duel.tookY = duel.coinY;
+      duel.sfx |= Sound.Coin;
+      duel.taken = 0;
+      duel.coinX = rng.range(1, WIDTH - 1);
+      duel.coinY = rng.range(1, HEIGHT - 1);
+      const best = Math.max(duel.score0, duel.score1);
+      if (best >= t.target) {
+        duel.winner = duel.score0 >= t.target ? 1 : 2;
+        duel.rest = t.restTicks;
+        duel.sfx |= Sound.Win;
+      }
+    }
+    for (const a of q.archetypes()) {
+      const p = a.column(og.Transform).position;
+      for (let i = 0; i < a.count; i++) {
+        p[i * 3] = duel.coinX;
+        p[i * 3 + 1] = duel.coinY;
+      }
+    }
+  },
+);
+
+/**
+ * What a coin, a dash and a round won look and sound like (og-feel §3, §4, §7): the coin's
+ * chime and a ring of sparks where it lay, "+1" in the taker's ink, a short hit stop and a
+ * light shake; a dash's whoosh; the round's fanfare and a heavier shake. Everything is asked
+ * for in Duel by the systems before and played here from the world alone, so every peer of a
+ * room plays the same.
+ */
+export const Feedback = defineSystem(
+  "Feedback",
+  { writes: [Duel, Sparks, og.Transform, og.ParticleSystem], after: ["CoinDrop"] },
+  (q, time, world) => {
+    const duel = must(world.resource(Duel));
+    if (duel.took === 0) return;
+    const who = duel.took - 1;
+    must(og.render.floatingText(world, { text: "+1", position: { x: duel.tookX, y: duel.tookY + 0.5, z: 1 }, color: TEXT_INKS[who] ?? GOLD_TEXT, size: 0.6, rise: 1.2, spread: 0.2, lifetime: 0.7 }));
+    must(og.time.hitStop(world, 3));
+    must(og.camera.shake(world, duel.winner !== 0 ? 0.45 : 0.15));
+    for (const a of q.archetypes()) {
+      const p = a.column(og.Transform).position;
+      const ps = a.column(og.ParticleSystem);
+      const sp = a.column(Sparks);
+      for (let i = 0; i < a.count; i++) {
+        p[i * 3] = duel.tookX;
+        p[i * 3 + 1] = duel.tookY;
+        ps.startTick[i] = time.tick;
+        sp.bursts[i] = sp.bursts[i]! + 1;
+      }
+    }
+    duel.took = 0;
+  },
+);
+
+/** Plays each sound Duel.sfx asks for once; a voice still sounding stops this tick and starts on the next. */
+export const Voices = defineSystem("Voices", { writes: [Duel, Voice, og.AudioSource], after: ["Feedback"] }, (q, _time, world) => {
+  const duel = must(world.resource(Duel));
+  if (duel.sfx === 0) return;
+  let left = duel.sfx;
+  for (const a of q.archetypes()) {
+    const v = a.column(Voice);
+    const src = a.column(og.AudioSource);
+    for (let i = 0; i < a.count; i++) {
+      const b = v.bit[i]!;
+      if ((duel.sfx & b) === 0) continue;
+      if (src.playing[i]) src.playing[i] = 0;
+      else {
+        src.playing[i] = 1;
+        v.plays[i] = v.plays[i]! + 1;
+        left &= ~b;
+      }
+    }
+  }
+  duel.sfx = left;
+});
+
+/** The HUD: both scores, and who this peer plays or whom it waits for. */
+export const Hud = defineSystem("Hud", { reads: [Duel, og.Lockstep] }, (_q, _time, world) => {
+  const duel = must(world.resource(Duel));
+  const net = og.net.status(world);
+  const lock = must(world.resource(og.Lockstep));
+  og.ui.anchor("Score", { anchor: "top", direction: "row", gap: 32, padding: { left: 16, top: 12, right: 16, bottom: 12 } }, () => {
+    og.ui.label("P1", `Red ${duel.score0}`, { step: "xl", color: { token: "danger" }, nowrap: true });
+    og.ui.label("P2", `Blue ${duel.score1}`, { step: "xl", color: { token: "info" }, nowrap: true });
+  });
+  // This peer's own line: it differs between peers, so it is drawn and never kept in the world.
+  const line =
+    duel.winner !== 0
+      ? `${duel.winner === 1 ? "Red" : "Blue"} wins`
+      : net.running
+        ? lock.localPlayer < lock.players
+          ? `You are ${lock.localPlayer === 0 ? "Red" : "Blue"}`
+          : "Watching"
+        : net.peer === null
+          ? "Local: Red"
+          : `Waiting for ${Math.max(0, lock.players - net.peers.length)} more`;
+  og.ui.anchor("Status", { anchor: "bottom", padding: { left: 16, top: 12, right: 16, bottom: 16 } }, () => {
+    og.ui.label("Line", line, { color: { token: "inkMuted" }, nowrap: true });
+  });
+});
+
+/** The facts `og run --json` and the probe print. */
+export function facts(world: World): Record<string, unknown> {
+  const d = world.resource(Duel);
+  if (!d.ok) return {};
+  return { score0: d.value.score0, score1: d.value.score1, coins: d.value.coins, winner: d.value.winner };
+}