@origingame/create-game 0.0.0-stage → 0.1.0

package/template/src/main.ts

@@ -0,0 +1,246 @@
+// The game entry: its default export is og.game(...). `og run .` runs it
+// headless with the probe; `og dev .` reloads it on every save; `og build .`
+// bundles it for the play page.
+//
+// This is the hello of docs/design.md §3.2 (Health, Velocity, Move) grown
+// into a scene: scenes/main.ogt (cooked from assets/scenes/main.ogt) spawns
+// the ground, the dropship and the trickster before the first tick; `start`
+// gives the ground its mesh and collider, drops a crate above it, puts the
+// camera, the UI font and the string table (assets/strings/en.ogt) in
+// place. The Start button of the menu panel (or S or Enter) starts the
+// trickster spinning and lets the crate fall.
+//
+// A guard walks the yard: a state machine in assets/ai/guard.ogt (og.ai)
+// patrols its post on the navmesh baked from assets/nav/yard.ogt (og.nav),
+// sees the trickster only inside its view cone and not through the wall,
+// raises the alarm and chases it, then searches and goes back.
+//
+// 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, Vector3, SHAPE_BOX } from "@origingame/engine";
+import type { World } from "@origingame/engine";
+
+export const Health = defineComponent("Health", {
+  hp: f32(100, { min: 0, max: 1000, tunable: true, label: "Health" }),
+  max: f32(100),
+});
+
+export const Velocity = defineComponent("Velocity", { v: Vector3() });
+
+/** Turns an entity about +Y; 0 until the player starts. */
+export const Spin = defineComponent("Spin", {
+  speed: f32(0, { min: -10, max: 10, step: 0.1, unit: "rad", tunable: true, label: "Spin speed" }),
+  target: f32(1.5, { min: -10, max: 10, tunable: true, label: "Spin when started" }),
+});
+
+/** Whether the player has pressed Start. */
+export const Run = defineResource("Run", { started: bool(), chimed: bool() });
+
+/** The guard's alarms, raised by its machine's `alarm` command. */
+export const Alarm = defineComponent("Alarm", { raised: f32(0) });
+
+export const Move = defineSystem("Move", { reads: [Velocity], writes: [og.Transform] }, (q, time) => {
+  for (const a of q.archetypes()) {
+    const p = a.column(og.Transform).position;
+    const v = a.column(Velocity).v;
+    for (let i = 0; i < a.count; i++) {
+      p[i * 3] += v[i * 3] * time.dt;
+      p[i * 3 + 1] += v[i * 3 + 1] * time.dt;
+      p[i * 3 + 2] += v[i * 3 + 2] * time.dt;
+    }
+  }
+});
+
+/**
+ * The menu panel: the title, the trickster's state and the Start button.
+ * A click on Start (or S or Enter) starts the run; the button then reads
+ * "Started" and stays inert.
+ */
+export const Menu = defineSystem("Menu", { reads: [Spin, og.Input], writes: [Run] }, (q, _time, world) => {
+  const run = world.resource(Run);
+  const input = world.resource(og.Input);
+  if (!run.ok || !input.ok) return;
+  let speed = 0;
+  for (const a of q.archetypes()) if (a.count > 0) speed = a.column(Spin).speed[0]!;
+  const started = run.value.started;
+  og.ui.column("Hud", { padding: { left: 24, top: 24, right: 24, bottom: 24 } }, () => og.ui.panel("Menu", { padding: { left: 20, top: 16, right: 20, bottom: 16 } }, () => {
+    og.ui.label("Title", og.i18n.t(world, "menu.title"), { step: "displaySm" });
+    og.ui.label("Status", started ? og.i18n.t(world, "menu.spinning", { speed: speed.toFixed(1) }) : og.i18n.t(world, "menu.prompt"), { color: { token: started ? "accentInk" : "fgMuted" } });
+    const start = og.ui.button("Start", og.i18n.t(world, started ? "menu.started" : "menu.start"), { variant: "primary", size: "large", disabled: started });
+    if (!started && (start.clicked || input.value.pressed("KeyS") || input.value.pressed("Enter"))) run.value.started = true;
+  }));
+});
+
+/** Once started, every Spin turns at its target speed. */
+export const StartSpin = defineSystem("StartSpin", { reads: [Run], writes: [Spin], after: ["Menu"] }, (q, _time, world) => {
+  const run = world.resource(Run);
+  if (!run.ok || !run.value.started) return;
+  for (const a of q.archetypes()) {
+    const s = a.column(Spin);
+    for (let k = 0; k < a.count; k++) if (s.speed[k] === 0) s.speed[k] = s.target[k]!;
+  }
+});
+
+/** Once started, held bodies (gravityScale 0) fall. */
+export const Drop = defineSystem("Drop", { reads: [Run], writes: [og.RigidBody], after: ["Menu"] }, (q, _time, world) => {
+  const run = world.resource(Run);
+  if (!run.ok || !run.value.started) return;
+  for (const a of q.archetypes()) {
+    const g = a.column(og.RigidBody).gravityScale;
+    for (let k = 0; k < a.count; k++) if (g[k] === 0) g[k] = 1;
+  }
+});
+
+/** Once started, the crate's blip plays once (an AudioSource inserted held, released here). */
+export const Chime = defineSystem("Chime", { writes: [Run, og.AudioSource], after: ["Menu"] }, (q, _time, world) => {
+  const run = world.resource(Run);
+  if (!run.ok || !run.value.started || run.value.chimed) return;
+  run.value.chimed = true;
+  for (const a of q.archetypes()) a.column(og.AudioSource).playing.fill(1);
+});
+
+/** Rotates by Spin.speed about +Y: q' = q * (axis-angle about Y). */
+export const Rotate = defineSystem("Rotate", { reads: [Spin], writes: [og.Transform], after: ["StartSpin"] }, (q, time) => {
+  for (const a of q.archetypes()) {
+    const r = a.column(og.Transform).quaternion;
+    const s = a.column(Spin).speed;
+    for (let i = 0; i < a.count; i++) {
+      const half = (s[i] * time.dt) / 2;
+      // Small-angle rotation, renormalised: deterministic arithmetic only.
+      const sy = half - (half * half * half) / 6;
+      const cw = 1 - (half * half) / 2;
+      const x = r[i * 4], y = r[i * 4 + 1], z = r[i * 4 + 2], w = r[i * 4 + 3];
+      const nx = x * cw - z * sy, ny = y * cw + w * sy, nz = z * cw + x * sy, nw = w * cw - y * sy;
+      const n = Math.sqrt(nx * nx + ny * ny + nz * nz + nw * nw);
+      r[i * 4] = nx / n;
+      r[i * 4 + 1] = ny / n;
+      r[i * 4 + 2] = nz / n;
+      r[i * 4 + 3] = nw / n;
+    }
+  }
+});
+
+function spawnWave(world: World, count: number): void {
+  const ship = og.load.gltf(world, "models/dropship.glb");
+  if (!ship.ok) throw new Error(ship.reason);
+  for (let i = 0; i < count; i++) {
+    const e = world.instantiate(ship.value, { name: `wave-${world.tick}-${i}`, position: { x: -4 + i * 1.5, y: 4, z: -3 } });
+    if (!e.ok) throw new Error(e.reason);
+    world.insert(e.value, Velocity, { v: { x: 0, y: -0.5, z: 0 } });
+  }
+}
+
+function must<T>(r: { ok: true; value: T } | { ok: false; reason: string }): T {
+  if (!r.ok) throw new Error(r.reason);
+  return r.value;
+}
+
+export default og.game({
+  tick: 60,
+  seed: 1,
+  scenes: { main: "scenes/main.ogt" },
+  // The art direction as data (og-taste §12): applied after the scene
+  // spawns and before start, which may still change any of it.
+  look: "looks/origin-game.ogt",
+  resources: [Run],
+  systems: [Move, Menu, StartSpin, Drop, Chime, Rotate],
+  // MSAA keeps world-space sprites and text sharp; TAA would blur them across
+  // frames. The UI draws over the finished frame either way.
+  render: { antialias: "msaa4" },
+  start(world) {
+    // The camera looks down -Z at the scene from in front.
+    const camera = must(world.resource(og.Camera));
+    camera.position = { x: 0.4, y: 1.8, z: 8 };
+    camera.quaternion = { x: 0, y: 0, z: 0, w: 1 };
+    must(world.resource(og.RenderSettings)).sky = true;
+
+    // The ground: a 30 m slab whose top is y = 0, drawn and collided with.
+    const ground = world.find("ground");
+    if (ground !== null) {
+      const slab = must(og.render.boxGeometry(world, { width: 30, height: 0.2, depth: 30 }));
+      const stone = must(og.render.standardMaterial(world, { color: { r: 0.18, g: 0.2, b: 0.24 }, roughness: 0.95 }));
+      world.set(ground, og.Transform, { position: { x: 0, y: -0.1, z: 0 } });
+      world.insert(ground, og.Mesh, { geometry: slab, material: stone, receiveShadow: true });
+      world.insert(ground, og.Collider, { shape: SHAPE_BOX, size: { x: 30, y: 0.2, z: 30 } });
+    }
+
+    // The crate: a dynamic body held in the air (gravityScale 0) until Start.
+    const cube = must(og.render.boxGeometry(world, {}));
+    const amber = must(og.render.standardMaterial(world, { color: { r: 0.9, g: 0.55, b: 0.08 }, roughness: 0.6 }));
+    const crate = must(world.spawn({ name: "crate", position: { x: -2.4, y: 4, z: 0.5 } }));
+    world.insert(crate, og.Mesh, { geometry: cube, material: amber, castShadow: true, receiveShadow: true });
+    world.insert(crate, og.RigidBody, { gravityScale: 0 });
+    world.insert(crate, og.Collider, { shape: SHAPE_BOX });
+    const blip = og.load.sound(world, "audio/blip.wav");
+    if (blip.ok) world.insert(crate, og.AudioSource, { sound: blip.value, playing: false, spatial: true });
+
+    const trickster = world.find("trickster");
+    if (trickster !== null) {
+      world.insert(trickster, Spin);
+      world.insert(trickster, Health);
+      // What the guard looks for: team 1, looked at 1 m above its feet.
+      world.insert(trickster, og.Perceivable, { team: 1, eyeHeight: 1 });
+    }
+
+    // The wall the navmesh was baked around (assets/nav/yard.ogt): drawn, and solid to the guard's sight.
+    const wall = must(world.spawn({ name: "wall", position: { x: -3, y: 1, z: -2 } }));
+    const slabGeo = must(og.render.boxGeometry(world, { width: 0.6, height: 2, depth: 6 }));
+    const plaster = must(og.render.standardMaterial(world, { color: { r: 0.55, g: 0.52, b: 0.48 }, roughness: 0.9 }));
+    world.insert(wall, og.Mesh, { geometry: slabGeo, material: plaster, castShadow: true, receiveShadow: true });
+    world.insert(wall, og.Collider, { shape: SHAPE_BOX, size: { x: 0.6, y: 2, z: 6 } });
+
+    // The guard: the walker model, moved by og.nav on the baked navmesh and run by og.ai's machine.
+    const yard = must(og.nav.load(world, "nav/yard.ogt"));
+    const mind = must(og.ai.load(world, "ai/guard.ogt"));
+    const walker = must(og.load.gltf(world, "models/walker.glb"));
+    const guard = must(world.instantiate(walker, { name: "guard", position: { x: -6, y: 0, z: -3 } }));
+    // Facing east (+X), towards the wall: its view cone is 120° around the way it faces until it moves.
+    world.set(guard, og.Transform, { quaternion: { x: 0, y: Math.SQRT1_2, z: 0, w: Math.SQRT1_2 } });
+    world.insert(guard, og.NavAgent, { nav: yard.mesh, speed: 1.5, acceleration: 12, radius: 0.4, faceMovement: true, turnSpeed: 8 });
+    world.insert(guard, og.AiAgent, { behaviour: mind.behaviour });
+    world.insert(guard, og.Perception, { sight: 9, fov: 120, eyeHeight: 1.6, team: 2 });
+    world.insert(guard, Alarm);
+    // Every string the menu shows (og-i18n §1): load each locale's table here.
+    must(og.i18n.load(world, "strings/en.ogt"));
+    const font = og.load.font(world, "fonts/NotoSansSC-Regular-subset.ttf");
+    // A press answers with a sound as well as its look (og-taste §6): the `click` preset, synthesised by og cook.
+    const click = og.load.sound(world, "audio/click.ogt");
+    og.ui.configure(world, { ...(font.ok ? { font: font.value } : {}), ...(click.ok ? { sounds: { press: click.value } } : {}) });
+  },
+  commands: {
+    spawn_wave: (world, args) => spawnWave(world, Number(args[0] ?? 3)),
+    // The guard's machine raises it on entering `alert`; og.ai passes the guard's handle first.
+    alarm: (world, args) => {
+      const guard = Number(args[0]) as never;
+      const a = must(world.get(guard, Alarm));
+      must(world.set(guard, Alarm, { raised: a.raised + 1 }) as never);
+    },
+    /** `lure:<x>:<z>`: moves the trickster on the ground. */
+    lure: (world, args) => {
+      const t = world.find("trickster");
+      if (t === null) throw new Error("no trickster");
+      must(world.set(t, og.Transform, { position: { x: Number(args[0]), y: 0, z: Number(args[1]) } }) as never);
+    },
+  },
+  commandHelp: {
+    spawn_wave: { usage: "[count]", doc: "Drop that many dropships (3 by default)." },
+    alarm: { usage: "<guard>", doc: "The guard's state machine raises it on entering alert; og.ai passes the guard's handle." },
+    lure: { usage: "<x>:<z>", doc: "Move the trickster on the ground." },
+  },
+  facts: (world) => {
+    const run = world.resource(Run);
+    const trickster = world.find("trickster");
+    const spin = trickster === null ? null : world.get(trickster, Spin);
+    const crate = world.find("crate");
+    const at = crate === null ? null : world.get(crate, og.Transform);
+    const guard = world.find("guard");
+    const mind = guard === null ? null : (og.ai.describe(world, guard) as { state: string } | null);
+    return {
+      started: run.ok && run.value.started,
+      guard: mind?.state ?? null,
+      spin: spin?.ok ? spin.value.speed : null,
+      crateY: at?.ok ? at.value.position.y : null,
+    };
+  },
+});

package/template/tests/guard.og.ts

@@ -0,0 +1,67 @@
+// The guard (assets/ai/guard.ogt, a state machine on og.ai; the navmesh
+// cooked from assets/nav/yard.ogt, walked by og.nav). Facing east at its
+// first post, it does not see the trickster behind the wall (in range, in
+// its cone) nor behind it (in range, in the open); in front of it, it does,
+// raises the alarm once and chases; when the trickster slips behind the wall
+// it searches where it last saw it and returns to its patrol 3 s later.
+import { playtest } from "@origingame/engine/playtest";
+
+interface AiDump {
+  behaviour: string;
+  kind: string;
+  state: string;
+  sees: boolean;
+}
+interface EntityDump {
+  components: Record<string, Record<string, unknown>>;
+}
+
+const at = (run: { json<T>(f: string): T }, f: string) => run.json<EntityDump>(f).components["og.Transform"]!["position"] as number[];
+
+export default playtest({
+  name: "the guard patrols, sees inside its cone and not through the wall, chases, searches and returns",
+  commands: [
+    "0.3:lure:0:-3",
+    "0.4:dump_ai:guard:walled.json",
+    "0.4:dump_entity:guard:g0.json",
+    "0.5:lure:-6:-7",
+    "0.7:dump_ai:guard:behind.json",
+    "1.0:lure:-4:-1",
+    "1.1:dump_ai:guard:front.json",
+    "2.2:dump_entity:guard:chasing.json",
+    "2.2:dump_ai:guard:chase.json",
+    "2.3:lure:-1:-4",
+    "2.6:dump_ai:guard:lost.json",
+    "6.0:dump_ai:guard:back.json",
+    "6.0:dump_entity:guard:end.json",
+    "6.1:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const walled = run.json<AiDump>("walled.json");
+    t.equal(walled.behaviour, "guard", "the guard runs assets/ai/guard.ogt");
+    t.equal(walled.kind, "machine", "a state machine");
+    t.equal(walled.state, "patrol", "it patrols");
+    t.equal(walled.sees, false, "the wall hides the trickster 6 m ahead, inside its cone and its 9 m sight");
+    const g0 = at(run, "g0.json");
+    t.ok(Math.abs(g0[1]!) < 0.2, `it stands on the navmesh's surface (y ${g0[1]!.toFixed(3)})`);
+    const behind = run.json<AiDump>("behind.json");
+    t.equal(behind.sees, false, "4 m behind it, in the open, the trickster is outside its 120° cone");
+    t.equal(behind.state, "patrol", "so it keeps patrolling");
+
+    const front = run.json<AiDump>("front.json");
+    t.equal(front.sees, true, "in front of it the trickster is seen");
+    t.equal(front.state, "alert", "and the guard is alert");
+    const chase = run.json<AiDump>("chase.json");
+    t.equal(chase.state, "alert", "still chasing a second later");
+    const c = at(run, "chasing.json");
+    const d = Math.hypot(c[0]! + 4, c[2]! + 1);
+    t.ok(d < 2.0, `it closed in on the trickster (${d.toFixed(2)} m)`);
+
+    const lost = run.json<AiDump>("lost.json");
+    t.equal(lost.sees, false, "behind the wall the trickster is hidden");
+    t.equal(lost.state, "search", "so the guard searches");
+    t.equal(run.json<AiDump>("back.json").state, "patrol", "three seconds later it is back on patrol");
+    t.equal(run.json<EntityDump>("end.json").components["Alarm"]!["raised"], 1, "the alarm was raised once, on entering alert");
+  },
+});

package/template/tests/smoke.og.ts

@@ -0,0 +1,43 @@
+// The template's playtest, run by `og test` through `og run --headless
+// --commands`: a tap on the menu's Start button (found by its UI id, no key
+// fallback) starts the trickster spinning and drops the crate onto the
+// ground; the frame, the dumps and the UI tree are written.
+import { playtest } from "@origingame/engine/playtest";
+
+interface EntityDump {
+  components: Record<string, Record<string, number | boolean | string | number[]>>;
+}
+
+interface UiDump {
+  elements: Array<{ id: string; parent: string; text: string; x: number; y: number; width: number; height: number }>;
+}
+
+export default playtest({
+  name: "A tap on Start spins the trickster and drops the crate; the run writes its frame, dumps and UI tree",
+  commands:
+    "0.5:touch_move_to:Start;0.6:touch_start;0.7:touch_end;" +
+    "2.0:screenshot:smoke.png;2.1:dump_entity:trickster:trickster.json;2.15:dump_entity:crate:crate.json;" +
+    "2.2:dump_world:world.json;2.3:dump_ui:ui.json;2.5:quit",
+  check(run, t) {
+    t.ok(run.quit, "the script reached quit");
+    // Frames are read inside t.frame: without a renderer (og test in a sandbox
+    // with no GPU) the frame is reported unchecked and every other check runs.
+    t.frame("smoke.png", () => {
+      const frame = run.png("smoke.png");
+      t.ok(frame.width > 0 && frame.height > 0, `a ${frame.width}x${frame.height} frame was captured`);
+    });
+    const world = run.json<{ entities: number; systems: Array<{ name: string; matched: number | null }> }>("world.json");
+    t.ok(world.entities >= 5, `the scene spawned with the crate (${world.entities} entities)`);
+    t.ok(world.systems.some((s) => s.name === "Rotate" && s.matched === 1), "Rotate matches the trickster");
+    const ui = run.json<UiDump>("ui.json");
+    const start = ui.elements.find((e) => e.id === "Start");
+    t.ok(start !== undefined && start.width > 0 && start.height > 0, "the UI tree has the Start button with bounds");
+    t.ok(start?.text === "Started", `the button reads "${start?.text}" after the tap`);
+    const trickster = run.json<EntityDump>("trickster.json");
+    const spin = trickster.components["Spin"]!;
+    t.ok(Number(spin["speed"]) > 0, `the trickster spins (${spin["speed"]} rad/s)`);
+    const crate = run.json<EntityDump>("crate.json");
+    const y = (crate.components["og.Transform"]!["position"] as number[])[1]!;
+    t.ok(y > 0.4 && y < 0.6, `the crate fell from 4 m and rests on the ground (y ${y.toFixed(3)})`);
+  },
+});

package/template/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022"],
+    "types": [],
+    "strict": true,
+    "exactOptionalPropertyTypes": true,
+    "noFallthroughCasesInSwitch": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
+}