@origingame/create-game 0.0.0-stage → 0.1.0

package/archetypes/third-person/src/main.ts

@@ -0,0 +1,164 @@
+// Ember Vale, the third-person archetype (3D profile): dusk is falling on
+// a lake vale and four beacons stand dark on its knolls. Walk, run, wade
+// and jump the strider there (og.CharacterController on the terrain), hold
+// F by a beacon to kindle it (the hand reaches into the bowl through an
+// og.IkChain) and light all four before night. Three stone sentinels walk
+// their rounds on the navmesh (og.nav) and think with behaviour trees
+// (og.ai): one that sees you calls the alarm and runs you down, and its
+// grab costs a heart. Three hearts gone, or night, ends the run; every
+// beacon lit wins it. Then the summary, and again.
+//
+// `start` loads the strings, the skin and the sounds, builds the vale
+// (src/world.ts) and spawns the hero (src/hero.ts), the sentinels
+// (src/sentinels.ts) and the voices (src/sound.ts). The beacons are in
+// src/beacons.ts, the screens and the run's clock in src/ui.ts and the
+// state in src/components.ts.
+
+import { og } from "@origingame/engine";
+import type { World } from "@origingame/engine";
+import { BEACONS, Game, Phase, Prefs, Tuning } from "./components.ts";
+import { Beacons, catchBeacon } from "./beacons.ts";
+import { FEET, HeroMove, spawnHero, STAND, View } from "./hero.ts";
+import { alarm, grab, Sentinels, SENTINELS, spawnSentinels } from "./sentinels.ts";
+import { spawnVoices, Voices } from "./sound.ts";
+import { LANGUAGES, startRun, toTitle, Ui } from "./ui.ts";
+import { BEACON_AT, buildVale, ground, HOURS, must, setHour } from "./world.ts";
+
+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/ember/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") } }));
+  buildVale(world);
+  spawnHero(world);
+  spawnSentinels(world);
+  spawnVoices(world);
+  // Behind the title the vale is reset and its beacons burn.
+  toTitle(world, gameOf(world));
+}
+
+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;
+}
+
+/** `run`: start a run now, as Set out on the title does. */
+function run(world: World): void {
+  startRun(world, gameOf(world));
+}
+
+/** `warp:<beacon>` or `warp:<x>:<z>`: put the hero by a beacon (facing it) or on the ground at x, z. */
+function warp(world: World, args: readonly string[]): void {
+  const g = gameOf(world);
+  let x: number;
+  let z: number;
+  if (args.length === 1) {
+    const b = BEACON_AT[num(args[0], "beacon")];
+    if (b === undefined) throw new Error(`beacons are 0 to ${BEACONS - 1}`);
+    // Where the hero stands to kindle it: STAND short of its centre, on the side of the lake.
+    const len = Math.hypot(b.x, b.z + 6);
+    x = b.x - (b.x / len) * STAND;
+    z = b.z - ((b.z + 6) / len) * STAND;
+    g.facing = Math.atan2(b.x - x, b.z - z);
+  } else {
+    x = num(args[0], "x");
+    z = num(args[1], "z");
+  }
+  const h = ground(world, g, x, z).height;
+  must(world.set(g.hero as unknown as never, og.Transform, { position: { x, y: h + FEET + 0.05, z } }));
+}
+
+/** `light:<beacon>`: the beacon catches now, as kindling it does. */
+function light(world: World, args: readonly string[]): void {
+  const g = gameOf(world);
+  if (g.phase !== Phase.Play) throw new Error("light needs a run (write run first)");
+  const i = num(args[0], "beacon");
+  if (i < 0 || i >= BEACONS) throw new Error(`beacons are 0 to ${BEACONS - 1}`);
+  catchBeacon(world, g, i);
+}
+
+/** `hearts:<n>`: set the hearts left (0 ends the run, caught). */
+function hearts(world: World, args: readonly string[]): void {
+  gameOf(world).hearts = num(args[0], "n");
+}
+
+/** `dusk:<seconds>`: jump the run's clock to this many seconds played (night at Tuning.duskSeconds). */
+function dusk(world: World, args: readonly string[]): void {
+  const g = gameOf(world);
+  g.time = num(args[0], "seconds");
+  if (g.phase === Phase.Title) setHour(world, HOURS.title);
+}
+
+/** `viewport:<desktop|phone>`: lay the UI out for a phone in portrait. */
+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>`. */
+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:<en|zh-CN>");
+  p.language = at;
+  og.i18n.setLocale(world, LANGUAGES[at]!.code);
+}
+
+/** `stale_record`: another device writes the record (the next write here is refused as stale and merged). */
+function staleRecord(world: World): void {
+  must(og.platform.storeSet(world, { key: "record", value: { runs: 9, wins: 3, best: 200 } }));
+}
+
+export default og.game({
+  tick: 60,
+  seed: 1,
+  resources: [Game, Tuning, Prefs],
+  systems: [...og.systems.cameras, Ui, HeroMove, View, Sentinels, Beacons, Voices],
+  start,
+  commands: { run, warp, light, hearts, dusk, viewport, language, stale_record: staleRecord, alarm, grab },
+  commandHelp: {
+    run: { usage: "", doc: "Start a run now, as Set out does." },
+    warp: { usage: "<beacon> | <x>:<z>", doc: "Put the hero where it kindles a beacon (0 to 3), or on the ground at x, z." },
+    light: { usage: "<beacon>", doc: "The beacon catches now, as kindling it does (the fourth wins)." },
+    hearts: { usage: "<n>", doc: "Set the hearts left (0: the sentinels caught you)." },
+    dusk: { usage: "<seconds>", doc: "Jump the run's clock to this many seconds played (night falls at Tuning.duskSeconds)." },
+    viewport: { usage: "<desktop|phone>", doc: "Lay the UI out for a phone in portrait (390×844 at 3×)." },
+    language: { usage: "<en|zh-CN>", doc: "Switch the language as the settings do." },
+    stale_record: { usage: "", doc: "Another device writes the record, so this one's next write is refused as stale and merged." },
+    alarm: { usage: "<sentinel>", doc: "A sentinel (0 to 2: west, north, east; og.ai sends its entity) calls the alarm (its behaviour raises it on sight)." },
+    grab: { usage: "<sentinel>", doc: "A sentinel's grab (0 to 2: west, north, east; og.ai sends its entity; its behaviour raises it within reach): a heart, unless the hero is out of reach or was just grabbed." },
+  },
+  facts: (world) => {
+    const game = world.resource(Game);
+    if (!game.ok) return null;
+    const g = game.value;
+    return {
+      phase: ["title", "play", "over"][g.phase],
+      ending: ["none", "dawn", "night", "caught"][g.ending],
+      hearts: g.hearts,
+      lit: g.lit,
+      litMask: g.litMask,
+      time: Math.round(g.time * 10) / 10,
+      hour: Math.round(g.hour * 100) / 100,
+      near: g.near,
+      kindle: Math.round(g.kindle * 100) / 100,
+      wading: g.wading,
+      grounded: g.grounded,
+      speed: Math.round(g.speed * 100) / 100,
+      jumps: g.jumps,
+      splashes: g.splashes,
+      grabs: g.grabs,
+      alarms: g.alarms,
+      runs: g.runs,
+      wins: g.wins,
+      best: Math.round(g.best * 10) / 10,
+      sentinels: SENTINELS.length,
+      language: LANGUAGES[g.language]!.code,
+    };
+  },
+});

package/archetypes/third-person/src/sentinels.ts

@@ -0,0 +1,159 @@
+// The sentinels: three stone stouts walking their rounds of the lake path
+// on the vale's navmesh (og.NavAgent), each thinking with its behaviour
+// (og.ai, assets/ai/sentinel-<name>.ogt) and watching with og.Perception
+// (sight, a cone, the terrain and the plinths hide the hero). Seen, a
+// sentinel raises `alarm` and chases; within reach it raises `grab`: the
+// hero loses a heart and is thrown back. The navmesh stops at the shore, so
+// the lake is a refuge. Their walk is the library's clips retargeted onto
+// the stout (src/anim.ts), its speed the graph's parameter.
+
+import { og, defineSystem } from "@origingame/engine";
+import type { Entity, World } from "@origingame/engine";
+import { sentinelRig } from "./anim.ts";
+import { Ending, Game, Phase, Sentinel, Sound, Tuning } from "./components.ts";
+import { entity, FEET } from "./hero.ts";
+import { ground, must } from "./world.ts";
+
+/** The sentinels, by behaviour (assets/ai/sentinel-<name>.ogt). */
+export const SENTINELS = ["west", "north", "east"] as const;
+/** The stout's scale: a head taller than the hero. */
+const BODY_SCALE = 1.25;
+/** Seconds the hero is thrown back by a grab, and how long it cannot be grabbed again. */
+const KNOCK = 0.35;
+const SPARED = 1.6;
+
+/** The first point of each sentinel's round (tools/make-assets.py ROUTES writes the rounds). */
+const ROUND_STARTS = [{ x: -27, z: 12 }, { x: -20, z: -31 }, { x: 27, z: -22 }];
+/** The behaviours' `alert` and `grab` states: indexes into BehaviourInfo.states, the same in all three. */
+const ALERT_STATES = [1, 2];
+/** Their first state, `patrol`. */
+const PATROL = 0;
+
+export function spawnSentinels(world: World): void {
+  const g = must(world.resource(Game));
+  const rig = sentinelRig(world);
+  const model = must(og.load.gltf(world, "models/stout.glb"));
+  const eyeLight = { color: { r: 1, g: 0.18, b: 0.08 }, intensity: 0, distance: 6, castShadow: false };
+  SENTINELS.forEach((name, i) => {
+    const mind = must(og.ai.load(world, `ai/sentinel-${name}.ogt`));
+    if (mind.states[PATROL] !== "patrol" || mind.states[1] !== "alert" || mind.states[2] !== "grab") throw new Error(`ai/sentinel-${name}.ogt: states ${mind.states.join(", ")}`);
+    const first = ROUND_STARTS[i]!;
+    const at = { x: first.x, y: ground(world, g, first.x, first.z).height, z: first.z };
+    const s = must(world.spawn({ name: `sentinel-${i}`, position: at }));
+    must(world.insert(s, og.NavAgent, { nav: g.nav as never, target: at, seeking: false, speed: 1.6, acceleration: 12, radius: 0.45, stopDistance: 0.3, faceMovement: true, turnSpeed: 6 }));
+    must(world.insert(s, og.AiAgent, { behaviour: mind.behaviour, active: true, thinkEvery: 2 }));
+    must(world.insert(s, og.Perception, { sight: 13, fov: 120, eyeHeight: 1.6, occlude: true, team: 2, memory: 3 }));
+    must(world.insert(s, Sentinel, { index: i }));
+    const body = must(world.instantiate(model, { name: `sentinel-${i}-body`, parent: s, scale: { x: BODY_SCALE, y: BODY_SCALE, z: BODY_SCALE } }));
+    must(world.insert(body, og.Skeleton, { asset: rig.skeleton, rootMotion: "off" }));
+    must(world.insert(body, og.AnimationGraph, { asset: rig.graph, speed: 1 }));
+    const eye = must(world.spawn({ name: `sentinel-${i}-eye`, parent: s, position: { x: 0, y: 2.05, z: 0.3 } }));
+    must(world.insert(eye, og.PointLight, eyeLight));
+  });
+}
+
+/**
+ * Puts the sentinels back at the start of their rounds, calm (a new run or
+ * the title). One that left its patrol (alert, grabbing or searching) is
+ * restarted (og.ai.restart: its machine afresh in `patrol`, its timers and
+ * blackboard reset); one still patrolling keeps its machine.
+ */
+function reset(world: World, g: { terrain: number }): void {
+  SENTINELS.forEach((_, i) => {
+    const s = entity(world, `sentinel-${i}`);
+    const first = ROUND_STARTS[i]!;
+    const at = { x: first.x, y: ground(world, g, first.x, first.z).height, z: first.z };
+    must(world.set(s, og.Transform, { position: at }));
+    must(world.set(s, og.NavAgent, { target: at, seeking: false }));
+    if (must(world.get(s, og.AiAgent)).state !== PATROL) must(og.ai.restart(world, s));
+    must(world.set(s, Sentinel, { alert: false }));
+  });
+}
+
+/**
+ * Per tick: the sentinels' sight and pace from Tuning, the graph's speed
+ * from how fast each walks, the body's feet on the terrain (the navmesh
+ * lies a little above or below it), and the eye's light while it chases.
+ */
+export const Sentinels = defineSystem(
+  "Sentinels",
+  { reads: [Tuning], writes: [Game, Sentinel, og.AiAgent, og.NavAgent, og.Transform, og.Perception, og.AnimationGraph, og.PointLight], after: ["Hero"] },
+  (_q, time, world) => {
+    const g = must(world.resource(Game));
+    const t = must(world.resource(Tuning));
+    if (g.start) reset(world, g);
+    const pulse = 0.75 + 0.25 * Math.sin(time.elapsed * 9);
+    SENTINELS.forEach((_, i) => {
+      const s = entity(world, `sentinel-${i}`);
+      const nav = must(world.get(s, og.NavAgent));
+      const ai = must(world.get(s, og.AiAgent));
+      const me = must(world.get(s, Sentinel));
+      const p = must(world.get(s, og.Transform)).position;
+      const speed = Math.hypot(nav.velocity.x, nav.velocity.z);
+      const alert = g.phase === Phase.Play && ALERT_STATES.includes(ai.state);
+      if (alert !== me.alert || Math.abs(speed - me.speed) > 1e-3) must(world.set(s, Sentinel, { speed, alert }));
+      must(world.set(s, og.Perception, { sight: t.sight }));
+      const body = entity(world, `sentinel-${i}-body`);
+      must(world.set(body, og.AnimationGraph, { p0: speed }));
+      must(world.set(body, og.Transform, { position: { x: 0, y: ground(world, g, p.x, p.z).height - p.y, z: 0 } }));
+      must(world.set(entity(world, `sentinel-${i}-eye`), og.PointLight, { intensity: alert ? 14 * pulse : 0 }));
+    });
+  },
+);
+
+/**
+ * The sentinel a command names: its index, 0 to 2 (SENTINELS' order, as a
+ * playtest types it), or its entity handle (what og.ai's `command` sends
+ * first; no sentinel's handle is that small).
+ */
+function sentinel(world: World, args: readonly string[]): { me: Entity; at: { x: number; y: number; z: number } } {
+  const n = Number(args[0]);
+  const me = (Number.isInteger(n) && n >= 0 && n < SENTINELS.length ? entity(world, `sentinel-${n}`) : n) as Entity;
+  const t = world.get(me, og.Transform);
+  if (!t.ok || !world.get(me, Sentinel).ok) throw new Error(`${args[0]} is not a sentinel (0 to ${SENTINELS.length - 1}, or a sentinel's entity)`);
+  return { me, at: t.value.position };
+}
+
+/** `alarm <sentinel>`: it has seen the hero (its behaviour raises it entering `alert`). */
+export function alarm(world: World, args: readonly string[]): void {
+  const { me, at } = sentinel(world, args);
+  const g = must(world.resource(Game));
+  if (g.phase !== Phase.Play || g.ending !== Ending.None) return;
+  const s = must(world.get(me, Sentinel));
+  must(world.set(me, Sentinel, { alarms: s.alarms + 1 }));
+  g.alarms += 1;
+  g.sfx |= Sound.Alarm;
+  must(og.render.floatingText(world, { text: "!", position: { x: at.x, y: at.y + 2.7, z: at.z }, size: 0.9, color: { r: 1, g: 0.3, b: 0.15 }, rise: 0.6, spread: 0, lifetime: 1 }));
+}
+
+/**
+ * `grab <sentinel>`: it reached the hero (its behaviour raises it within
+ * reach). The hero loses a heart and is thrown back, the world holds for a
+ * beat, the screen flashes red and shakes; then the hero is spared a moment.
+ */
+export function grab(world: World, args: readonly string[]): void {
+  const { me, at } = sentinel(world, args);
+  const g = must(world.resource(Game));
+  if (g.phase !== Phase.Play || g.ending !== Ending.None || g.invulnerable > 0) return;
+  const hero = must(world.get(g.hero as unknown as Entity, og.Transform)).position;
+  if (Math.hypot(hero.x - at.x, hero.z - at.z) > 2.2 || hero.y - FEET > at.y + 1.5) return;
+  const s = must(world.get(me, Sentinel));
+  must(world.set(me, Sentinel, { grabs: s.grabs + 1 }));
+  const dx = hero.x - at.x;
+  const dz = hero.z - at.z;
+  const d = Math.max(0.01, Math.hypot(dx, dz));
+  g.hearts -= 1;
+  g.hurts += 1;
+  g.grabs += 1;
+  g.knock = KNOCK;
+  g.knockX = dx / d;
+  g.knockZ = dz / d;
+  g.invulnerable = SPARED;
+  g.sfx |= Sound.Grab;
+  const t = must(world.resource(Tuning));
+  if (t.hitStop > 0) must(og.time.hitStop(world, t.hitStop));
+  const post = must(world.resource(og.PostEffects));
+  post.flash = 0.45;
+  post.flashColor = { r: 0.8, g: 0.05, b: 0.02 };
+  must(og.camera.shake(world, 0.55));
+}

package/archetypes/third-person/src/sound.ts

@@ -0,0 +1,66 @@
+// The sounds: one voice per sound effect, played once when a system sets
+// its bit in Game.sfx (a voice still playing is stopped this tick and
+// started again on the next), and the vale's music, ducked under the
+// effects, with a little of the valley's echo on them.
+
+import { og, defineSystem } from "@origingame/engine";
+import type { World } from "@origingame/engine";
+import { Game, Sfx, Sound } from "./components.ts";
+import { must } from "./world.ts";
+
+export function spawnVoices(world: World): void {
+  const sound = (path: string) => must(og.load.sound(world, path));
+  const voices: [string, number, number][] = [
+    ["audio/step.ogt", Sound.Step, 0.3],
+    ["audio/jump.wav", Sound.Jump, 0.45],
+    ["audio/splash.wav", Sound.Splash, 0.5],
+    ["audio/ignite.wav", Sound.Ignite, 0.75],
+    ["audio/alarm.wav", Sound.Alarm, 0.6],
+    ["audio/grab.wav", Sound.Grab, 0.7],
+    ["audio/dawn.wav", Sound.Dawn, 0.75],
+    ["audio/night.wav", Sound.Night, 0.75],
+  ];
+  for (const [path, bit, volume] of voices) {
+    const v = must(world.spawn({ name: `sfx-${bit}` }));
+    must(world.insert(v, og.AudioSource, { sound: sound(path), playing: false, bus: "sfx", 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/vale.wav"), bus: "music", loop: true, volume: 0.55, priority: 220 }));
+  const fx = must(world.spawn({ name: "music-bus" }));
+  must(world.insert(fx, og.AudioBusFx, { bus: "music", duck: true, duckBus: "sfx", duckDepth: 5, duckRelease: 0.6 }));
+  const echo = must(world.spawn({ name: "sfx-bus" }));
+  must(world.insert(echo, og.AudioBusFx, { bus: "sfx", reverb: 0.18 }));
+  // The touch HUD's Jump and Kindle: the skin's press sound on the ui bus,
+  // like every og.ui button, beside the jump's or the fire's own effect.
+  const tap = must(world.spawn({ name: `sfx-${Sound.Tap}` }));
+  must(world.insert(tap, og.AudioSource, { sound: sound("audio/ui-press.ogt"), playing: false, bus: "ui", volume: 0.5, priority: 150 }));
+  must(world.insert(tap, Sfx, { bit: Sound.Tap }));
+}
+
+/** Plays each requested sound once; steps and splashes vary their pitch a little. */
+export const Voices = defineSystem("Voices", { writes: [Game, Sfx, og.AudioSource, og.Rng], after: ["Beacons", "Sentinels", "View"] }, (q, _time, world) => {
+  const g = must(world.resource(Game));
+  // The last system: every system has seen this tick's start.
+  g.start = false;
+  if (g.sfx === 0) return;
+  const rng = must(world.resource(og.Rng));
+  let left = g.sfx;
+  for (const a of q.archetypes()) {
+    const sfx = a.column(Sfx);
+    const src = a.column(og.AudioSource);
+    for (let i = 0; i < a.count; i++) {
+      const b = sfx.bit[i]!;
+      if ((g.sfx & b) === 0) continue;
+      if (src.playing[i]) {
+        src.playing[i] = 0;
+      } else {
+        src.playing[i] = 1;
+        sfx.plays[i] = sfx.plays[i]! + 1;
+        if (b === Sound.Step || b === Sound.Splash) src.pitch[i] = rng.range(0.9, 1.1);
+        left &= ~b;
+      }
+    }
+  }
+  g.sfx = left;
+});