@origingame/create-game 0.0.0-stage → 0.1.1

package/archetypes/idle/src/ui.ts

@@ -0,0 +1,412 @@
+// Spark Orb's screens on og.ui and the skin in assets/skins/sparkorb (the
+// engine's neon pack in the orb's gold on night violet): the title, the
+// HUD (the sparks and their rate top left, stardust and pause top right,
+// the four generators along the bottom, the supernova's progress), the
+// pause menu, the settings dialog, the supernova's dialog and its run
+// card, and the welcome back. Screens change through an iris (a fade with
+// reduced motion). Every string is a key of assets/strings/*.ogt and
+// every number goes through src/numbers.ts's `big`.
+//
+// The Ui system also keeps the save in og.platform: read on launch (and on
+// `relaunch`), the time away (the answer's host time less the save's
+// `at`, og.platform.now when it was written) credited, written every Tuning.saveEvery
+// ticks, after a supernova, on pause and on Quit, at the revision read; a write
+// refused as stale is read again and merged (the save with more lifetime
+// sparks wins) and written at the new revision.
+
+import { og, defineSystem } from "@origingame/engine";
+import type { Value, World } from "@origingame/engine";
+import { Game, GENERATORS, Phase, Prefs, Sound, Tuning } from "./components.ts";
+import { big, duration, novaAt, novaGain, offlineGain, owned, price, totalRate } from "./numbers.ts";
+import { counts, lazyTuning, must } from "./systems.ts";
+
+export const LANGUAGES = [
+  { code: "en", key: "lang.en" },
+  { code: "zh-CN", key: "lang.zh" },
+] as const;
+
+/** The generators' icons in the skin's atlas. */
+const ICONS = ["fire", "bolt", "gem", "star"] as const;
+
+/** The tokens' spacing scale in CSS px (og.ui.frameTheme answers it too, but builds the whole theme each call). */
+const S = { xxs: 2, xs: 4, sm: 8, md: 12, lg: 16, xl: 24 } as const;
+
+type GameV = Value<typeof Game>;
+type PrefsV = Value<typeof Prefs>;
+
+export function say(world: World, key: string, args?: Record<string, string | number>): string {
+  return og.i18n.t(world, key, args);
+}
+
+const grow = { kind: "grow" } as const;
+const px = (n: number) => ({ kind: "fixed", px: n }) as const;
+
+/** The save's value: everything a relaunch restores, and when it was written (the host's clock, UTC ms). */
+function saveValue(world: World, g: GameV) {
+  return { v: 1, sparks: g.sparks, runEarned: g.runEarned, lifetime: g.lifetime, owned: counts(g), dust: g.dust, novas: g.novas, runTicks: g.runTicks, taps: g.taps, at: og.platform.now(world) };
+}
+
+type Save = ReturnType<typeof saveValue>;
+
+function restore(g: GameV, s: Save): void {
+  g.sparks = s.sparks ?? 0;
+  g.runEarned = s.runEarned ?? 0;
+  g.lifetime = s.lifetime ?? 0;
+  g.owned0 = s.owned?.[0] ?? 0;
+  g.owned1 = s.owned?.[1] ?? 0;
+  g.owned2 = s.owned?.[2] ?? 0;
+  g.owned3 = s.owned?.[3] ?? 0;
+  g.dust = s.dust ?? 0;
+  g.novas = s.novas ?? 0;
+  g.runTicks = s.runTicks ?? 0;
+  g.taps = s.taps ?? 0;
+}
+
+function writeSave(world: World, g: GameV): void {
+  const r = og.platform.storeSet(world, { key: "orb", value: saveValue(world, g), revision: g.saveRevision });
+  if (r.ok) g.saveWrite = r.value;
+  g.sinceSave = 0;
+  g.saveNow = false;
+}
+
+/** A launch: the settings and the save asked for (tick 0, or `relaunch`). */
+export function launch(world: World, g: GameV, p: PrefsV): void {
+  p.loadRequest = og.platform.loadSettings(world);
+  const r = og.platform.storeGet(world, "orb");
+  g.saveRequest = r.ok ? r.value : 0;
+}
+
+function applyPrefs(world: World, p: PrefsV): void {
+  const audio = world.resource(og.Audio);
+  if (audio.ok) {
+    audio.value.master = p.master;
+    audio.value.music = p.music;
+    audio.value.sfx = p.effects;
+    audio.value.ui = p.effects;
+  }
+}
+
+function setLanguage(world: World, p: PrefsV, index: number): void {
+  p.language = Math.max(0, Math.min(LANGUAGES.length - 1, index));
+  og.i18n.setLocale(world, LANGUAGES[p.language]!.code);
+}
+
+function prefsValue(p: PrefsV) {
+  return { masterVolume: p.master, musicVolume: p.music, sfxVolume: p.effects, language: LANGUAGES[p.language]!.code, reducedMotion: p.reducedMotion };
+}
+
+/** og.platform's answers: the settings, the save (and the time away), the save's writes. */
+function platform(world: World, g: GameV, p: PrefsV): void {
+  if (p.loadRequest !== 0) {
+    const r = og.platform.result(world, p.loadRequest);
+    if (r !== null) {
+      p.loadRequest = 0;
+      const s = ((r.ok ? r.data : null) as { value?: Record<string, unknown> } | null)?.value ?? null;
+      if (s && typeof s === "object") {
+        if (typeof s.masterVolume === "number") p.master = s.masterVolume;
+        if (typeof s.musicVolume === "number") p.music = s.musicVolume;
+        if (typeof s.sfxVolume === "number") p.effects = s.sfxVolume;
+        if (typeof s.reducedMotion === "boolean") p.reducedMotion = s.reducedMotion;
+        const at = LANGUAGES.findIndex((l) => l.code === s.language);
+        if (at >= 0) setLanguage(world, p, at);
+        applyPrefs(world, p);
+      }
+    }
+  }
+  if (g.saveRequest !== 0) {
+    const r = og.platform.result(world, g.saveRequest);
+    if (r !== null) {
+      g.saveRequest = 0;
+      const d = (r.ok ? r.data : null) as { value?: Save | null; revision?: number } | null;
+      if (typeof d?.revision === "number") g.saveRevision = d.revision;
+      if (g.saveMerge) {
+        // Another device wrote the save: the one with more lifetime sparks wins, then it is written here.
+        g.saveMerge = false;
+        if (d?.value && (d.value.lifetime ?? 0) > g.lifetime) restore(g, d.value);
+        writeSave(world, g);
+      } else if (!g.loaded) {
+        g.loaded = true;
+        if (d?.value) {
+          restore(g, d.value);
+          // The time away: the answer's host time less the save's (relaunch:<s> has set it instead).
+          if (g.away === 0 && d.value.at > 0 && r.time > 0) g.away = Math.max(0, (r.time - d.value.at) / 1000);
+          const t = lazyTuning(world);
+          const gain = offlineGain(t, totalRate(t, counts(g), g.dust), g.away);
+          if (gain > 0 && g.away >= 60) {
+            g.offline = gain;
+            g.sparks += gain;
+            g.runEarned += gain;
+            g.lifetime += gain;
+            g.welcome = true;
+          }
+        }
+      }
+    }
+  }
+  if (g.saveWrite !== 0) {
+    const r = og.platform.result(world, g.saveWrite);
+    if (r !== null) {
+      g.saveWrite = 0;
+      if (r.ok) {
+        g.saveRevision = (r.data as { revision: number }).revision;
+        g.saves += 1;
+      } else if (r.error?.code === "conflict") {
+        g.saveConflicts += 1;
+        g.saveMerge = true;
+        const again = og.platform.storeGet(world, "orb");
+        g.saveRequest = again.ok ? again.value : 0;
+      }
+    }
+  }
+  // Saving: every Tuning.saveEvery ticks of play, and when asked (a supernova, the pause, Quit, which has gone to the title by then).
+  if (g.loaded && (g.phase !== Phase.Title || g.saveNow) && g.saveWrite === 0 && g.saveRequest === 0) {
+    g.sinceSave += 1;
+    if (g.saveNow || g.sinceSave >= lazyTuning(world).saveEvery) writeSave(world, g);
+  }
+}
+
+function capsule(id: string, build: () => void): void {
+  og.ui.row(id, { gap: S.xs, cross: "center", padding: { left: S.sm, top: S.xs, right: S.md, bottom: S.xs }, frame: "capsule", background: { token: "surface" } }, build);
+}
+
+function hud(world: World, g: GameV): void {
+  const t = lazyTuning(world);
+  const vp = og.ui.frameViewport();
+  const phone = vp.width < vp.height;
+  og.ui.setNavigation(false);
+  og.ui.anchor("Wallet", { anchor: "topLeft", direction: "column", gap: S.xs }, () => {
+    capsule("Sparks", () => {
+      og.ui.icon("Icon", "star", { size: 24, tint: { token: "accentInk" } });
+      // The sparks change every tick, so they are a label in the locale's words, not a counter
+      // (a counter re-counts from where it is on every change); counters show what jumps.
+      og.ui.label("Amount", big(world, g.sparks), { step: "xl", font: "display", nowrap: true });
+    });
+    og.ui.row("RateRow", { padding: { left: S.sm, top: 0, right: 0, bottom: 0 } }, () => {
+      og.ui.label("Rate", say(world, "hud.rate", { n: big(world, g.rate) }), { step: "body", color: { token: "fgMuted" }, nowrap: true });
+    });
+  });
+  let paused = false;
+  og.ui.anchor("Corner", { anchor: "topRight", gap: S.sm, cross: "center" }, () => {
+    if (g.dust > 0 || g.novas > 0) {
+      capsule("Dust", () => {
+        og.ui.icon("Icon", "gem", { size: 20, tint: { token: "info" } });
+        og.ui.counter("Amount", g.dust, { font: "mono" });
+      });
+    }
+    if (og.ui.actionButton("Pause", say(world, "hud.pause"), { icon: "pause", size: 48 }).clicked) paused = true;
+  });
+  if (paused) {
+    g.paused = true;
+    g.saveNow = true;
+  }
+  // The generators along the bottom: a button each (its icon), its name, how many, its price.
+  let buy = -1;
+  og.ui.anchor("Shop", { anchor: "bottom", gap: phone ? S.sm : S.xl, cross: "end" }, () => {
+    GENERATORS.forEach((name, i) => {
+      const n = owned(g, i);
+      const cost = price(t, i, n);
+      const can = g.sparks >= cost;
+      og.ui.column(og.ui.idi("Gen", i), { cross: "center", gap: S.xxs, width: px(phone ? 82 : 96) }, () => {
+        const r = og.ui.actionButton("Buy", say(world, "hud.buy", { name: say(world, `gen.${name}`) }), { icon: ICONS[i]!, size: phone ? 56 : 64, primary: false });
+        if (r.clicked) buy = i;
+        // A refused purchase shakes its card with the error sound; a milestone bursts from it (og-ui §6).
+        if (g.refusedSlot === i && g.refusedTick === world.tick - 1) og.ui.shake({ sound: true });
+        if (g.milestoneSlot === i && g.milestoneTick === world.tick - 1) og.ui.burst({ count: 10 });
+        og.ui.row("Head", { gap: S.xxs, cross: "center" }, () => {
+          og.ui.label("Name", say(world, `gen.${name}`), { step: "body", color: { token: g.selected === i ? "accentInk" : "fg" }, nowrap: true });
+          og.ui.counter("Owned", n, { font: "mono", prefix: "×", color: { token: "fgMuted" } });
+        });
+        og.ui.label("Cost", big(world, cost), { font: "mono", color: { token: can ? "accentInk" : "fgMuted" }, nowrap: true });
+      });
+    });
+  });
+  if (buy >= 0) g.pendingBuy = buy;
+  // The supernova: its progress until it gives stardust, then its button.
+  const gain = novaGain(t, g.runEarned);
+  og.ui.anchor("Nova", { anchor: phone ? "topRight" : "bottomRight", offsetY: phone ? 64 : 0, direction: "column", cross: "center", gap: S.xxs }, () => {
+    if (gain >= 1) {
+      if (og.ui.actionButton("Supernova", say(world, "hud.nova"), { icon: "bolt", size: 64, primary: true }).clicked) g.confirmNova = true;
+      og.ui.label("Gain", say(world, "hud.novaGain", { n: gain }), { color: { token: "accentInk" }, nowrap: true });
+    } else if (g.runEarned > 0) {
+      og.ui.label("At", say(world, "hud.novaAt", { n: big(world, novaAt(t)) }), { step: "caption", color: { token: "fgMuted" }, nowrap: true });
+      og.ui.meter("Progress", Math.min(g.runEarned, novaAt(t)), novaAt(t), { width: px(phone ? 110 : 140) });
+    }
+  });
+}
+
+function settings(world: World, g: GameV, p: PrefsV): void {
+  let done = false;
+  const before = JSON.stringify(prefsValue(p));
+  const m = og.ui.modal("Settings", g.settingsOpen, { title: say(world, "settings.title"), width: px(Math.min(420, og.ui.frameViewport().width - 32)) }, () => {
+    const slider = (id: string, key: string, value: number): number => {
+      let out = value;
+      og.ui.row(id, { width: grow, gap: S.md, cross: "center" }, () => {
+        og.ui.label("Label", say(world, key), { width: px(110), nowrap: true });
+        out = og.ui.slider("Slider", value, { step: 0.05 }).value;
+        og.ui.label("Value", `${Math.round(out * 100)}`, { width: px(40), align: "end", font: "mono", nowrap: true });
+      });
+      return out;
+    };
+    p.master = slider("Master", "settings.master", p.master);
+    p.music = slider("Music", "settings.music", p.music);
+    p.effects = slider("Effects", "settings.effects", p.effects);
+    og.ui.label("LanguageLabel", say(world, "settings.language"), { color: { token: "fgMuted" } });
+    const r = og.ui.radio("Language", LANGUAGES.map((l) => say(world, l.key)), p.language, { horizontal: true });
+    if (r.selected !== p.language) setLanguage(world, p, r.selected);
+    p.reducedMotion = og.ui.toggle("Motion", p.reducedMotion, say(world, "settings.motion")).on;
+    og.ui.row("Footer", { width: grow, align: "end" }, () => {
+      if (og.ui.button("Done", say(world, "settings.done"), { variant: "primary" }).clicked) done = true;
+    });
+  });
+  if (JSON.stringify(prefsValue(p)) !== before) applyPrefs(world, p);
+  if (g.settingsOpen && (done || m.dismissed)) {
+    g.settingsOpen = false;
+    must(og.platform.saveSettings(world, prefsValue(p)));
+    p.saves += 1;
+  }
+}
+
+/** The dialogs over play: the supernova's question and the welcome back. */
+function dialogs(world: World, g: GameV): void {
+  const t = lazyTuning(world);
+  const width = px(Math.min(420, og.ui.frameViewport().width - 32));
+  const gain = novaGain(t, g.runEarned);
+  let collapse = false;
+  let notYet = false;
+  const m = og.ui.modal("Confirm", g.confirmNova, { title: say(world, "confirm.title"), width }, () => {
+    og.ui.label("Body", say(world, "confirm.body", { n: gain, total: g.dust + gain, bonus: Math.round((g.dust + gain) * t.dustBonus * 100) }), { width: grow });
+    og.ui.row("Actions", { width: grow, gap: S.sm, align: "end" }, () => {
+      if (og.ui.button("Later", say(world, "confirm.later")).clicked) notYet = true;
+      if (og.ui.button("Collapse", say(world, "confirm.collapse"), { variant: "primary" }).clicked) collapse = true;
+    });
+  });
+  if (g.confirmNova && (notYet || m.dismissed)) g.confirmNova = false;
+  if (g.confirmNova && collapse) {
+    g.confirmNova = false;
+    g.pendingNova = true;
+  }
+  let collect = false;
+  const w = og.ui.modal("Welcome", g.welcome, { title: say(world, "welcome.title"), width }, () => {
+    og.ui.row("Mark", { width: grow, align: "center" }, () => og.ui.icon("Icon", "clock", { size: 40, tint: { token: "accentInk" } }));
+    og.ui.label("Body", say(world, "welcome.body", { time: duration(world, g.away), n: big(world, g.offline) }), { width: grow, align: "center" });
+    og.ui.row("Actions", { width: grow, align: "center" }, () => {
+      if (og.ui.button("Collect", say(world, "welcome.collect"), { variant: "primary" }).clicked) collect = true;
+    });
+  });
+  if (g.welcome && (collect || w.dismissed)) {
+    g.welcome = false;
+    g.sfx |= Sound.Welcome;
+  }
+}
+
+/** The run's card after a supernova. */
+function novaCard(world: World, g: GameV): boolean {
+  const t = lazyTuning(world);
+  let again = false;
+  og.ui.modal("Card", g.phase === Phase.Nova, { title: say(world, "nova.title"), locked: true, width: px(Math.min(400, og.ui.frameViewport().width - 32)) }, () => {
+    og.ui.row("Mark", { width: grow, align: "center" }, () => {
+      og.ui.transition("Icon", true, { kind: "pop" }, () => og.ui.icon("Glyph", "gem", { size: 48, tint: { token: "info" } }));
+    });
+    og.ui.column("Stats", { width: grow, gap: 0 }, () => {
+      og.ui.keyValue("Made", say(world, "nova.made"), big(world, g.lastRun), true);
+      og.ui.keyValue("Time", say(world, "nova.time"), duration(world, g.lastRunTicks / 60), true);
+      og.ui.keyValue("Gain", say(world, "nova.gain"), `+${g.lastGain}`, true);
+      og.ui.keyValue("Dust", say(world, "nova.dust"), `${g.dust}`, true);
+      og.ui.keyValue("Bonus", say(world, "nova.bonus"), say(world, "nova.percent", { n: Math.round(g.dust * t.dustBonus * 100) }), true);
+    });
+    og.ui.row("Actions", { width: grow }, () => {
+      if (og.ui.button("Again", say(world, "nova.again"), { variant: "primary", width: grow }).clicked) again = true;
+    });
+  });
+  return again;
+}
+
+/** The screens, the camera, the buses, the platform's answers and the save. */
+export const Ui = defineSystem("Ui", { reads: [Tuning, og.Input, og.Gamepad], writes: [Game, Prefs, og.Camera, og.Audio] }, (_q, time, world) => {
+  const game = world.resource(Game);
+  const prefs = world.resource(Prefs);
+  if (!game.ok || !prefs.ok) return;
+  const g = game.value;
+  const p = prefs.value;
+  if (time.tick === 0) {
+    launch(world, g, p);
+    applyPrefs(world, p);
+  }
+  platform(world, g, p);
+  // The camera: 10 m tall on a wide screen; 7 m across a portrait one, the orb above the shop.
+  const vp = og.ui.frameViewport();
+  if (vp.width > 0 && (vp.width !== g.viewW || vp.height !== g.viewH)) {
+    g.viewW = vp.width;
+    g.viewH = vp.height;
+    const portrait = vp.width < vp.height;
+    const cam = world.resource(og.Camera);
+    if (cam.ok) cam.value.height = portrait ? (7.4 * vp.height) / vp.width : 10;
+    g.orbX = 0;
+    g.orbY = portrait ? 1.4 : 0.35;
+  }
+  const hold = g.phase === Phase.Play && (g.paused || g.settingsOpen || g.confirmNova || g.welcome);
+  if (hold !== g.held) {
+    must(og.time.setScale(world, hold ? 0 : 1));
+    g.held = hold;
+  }
+  const input = world.resource(og.Input);
+  const pad = world.resource(og.Gamepad);
+  if (g.phase === Phase.Play && !g.held && input.ok && pad.ok) {
+    if (input.value.pressed("Escape") || input.value.pressed("KeyP") || pad.value.pressed("start")) {
+      g.paused = true;
+      g.saveNow = true;
+    }
+    if ((input.value.pressed("KeyN") || pad.value.pressed("y")) && novaGain(lazyTuning(world), g.runEarned) >= 1) g.confirmNova = true;
+  }
+  const screen = g.phase === Phase.Title ? "title" : g.phase === Phase.Play ? "play" : "nova";
+  const shown = og.ui.screenTransition("Screens", screen, { kind: p.reducedMotion ? "fade" : "iris", durationMs: 600 }).shown;
+  if (shown !== "title") g.leftTitle = true;
+  if (shown === "title") {
+    og.ui.setNavigation(true);
+    const progress = g.lifetime > 0 || g.dust > 0;
+    const r = og.ui.mainMenu("Title", {
+      title: say(world, "title.name"),
+      subtitle: say(world, "title.tagline"),
+      items: [
+        { id: "play", label: say(world, progress ? "title.continue" : "title.play"), primary: true },
+        { id: "settings", label: say(world, "title.settings") },
+      ],
+      footer: say(world, "title.footer"),
+      // The title the game opens on is built settled: the web draws it behind the play gate, where
+      // the skin's entrance would stand part-way until the tap (og-platform-sdk §3). Later titles enter.
+      instant: !g.leftTitle,
+    });
+    if (!g.settingsOpen && r.selected === "play") {
+      g.phase = Phase.Play;
+      g.playTick = world.tick;
+    }
+    if (r.selected === "settings") g.settingsOpen = true;
+  } else if (shown === "play") {
+    hud(world, g);
+    dialogs(world, g);
+    const m = og.ui.pauseMenu("Pause", {
+      open: g.paused && !g.settingsOpen,
+      title: say(world, "pause.title"),
+      items: [
+        { id: "resume", label: say(world, "pause.resume"), primary: true },
+        { id: "settings", label: say(world, "pause.settings") },
+        { id: "quit", label: say(world, "pause.quit") },
+      ],
+    });
+    if (m.selected === "resume") g.paused = false;
+    if (m.selected === "settings") g.settingsOpen = true;
+    if (m.selected === "quit") {
+      g.paused = false;
+      g.phase = Phase.Title;
+      g.saveNow = true;
+    }
+  } else {
+    og.ui.setNavigation(true);
+    if (novaCard(world, g)) {
+      g.phase = Phase.Play;
+      g.playTick = world.tick;
+    }
+  }
+  settings(world, g, p);
+  if (g.language !== p.language) g.language = p.language;
+});

package/archetypes/idle/tests/away.og.ts

@@ -0,0 +1,42 @@
+// The time away from the host's clock, across two processes (og test keeps
+// the store between them): the first plays, buys ten embers and two storms
+// and saves with Escape at its host time; the second launches two hours
+// later by its own clock, offers Continue, and the welcome back credits
+// the two hours (less the seconds the first run went on after the save) at
+// half the rate. No relaunch command: the host's time alone.
+import { playtest } from "@origingame/engine/playtest";
+import { game, press, tap, text, TITLE } from "./lib.ts";
+
+const T = 1767225600000;
+const TWO_HOURS = 2 * 3600 * 1000;
+
+export default playtest({
+  name: "two hours away by the host's clock, across processes, credited at half the rate",
+  store: "keep",
+  clock: T,
+  commands: ["0.3:play", "0.9:own:0:10", "0.9:own:1:2", "1.0:sparks:500", press("Escape", 1.2), "1.5:get:Game:saved.json", "1.6:quit"].join(";"),
+  then: [
+    {
+      clock: T + TWO_HOURS,
+      commands: ["0.5:get:Game:launched.json", "0.5:dump_ui:title.json", tap("play", 0.6), "1.5:get:Game:welcome.json", "1.5:dump_ui:welcome-ui.json", "1.6:quit"].join(";"),
+    },
+  ],
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the first run ran without warnings");
+    const saved = game(run, "saved.json");
+    t.equal(saved.saves, 1, "Escape saved");
+    t.equal(saved.rate, 18, "ten embers (doubled) and two storms: 18 a second");
+    const later = run.then[0]!;
+    t.equal(later.warnings.join("; "), "", "the second run ran without warnings");
+    const launched = game(later, "launched.json");
+    t.equal(launched.phase, TITLE, "the second process opens on the title");
+    t.ok(text(later, "title.json", "play")?.startsWith("Continue") ?? false, "which offers Continue: the save was kept");
+    const w = game(later, "welcome.json");
+    t.equal(w.owned0, 10, "the save came back");
+    // Saved about 1.2 s into the first run, read on the second's first ticks: two hours less about a second.
+    t.ok(w.away > 7198 && w.away < 7200, `away two hours by the hosts' clocks (${w.away.toFixed(3)} s)`);
+    t.near(w.offline, 18 * 0.5 * w.away, 1e-6, "credited at half of 18 a second");
+    t.equal(w.welcome, true, "the welcome back is up");
+    t.ok(text(later, "welcome-ui.json", "Body")?.startsWith("While you were away (1 h 59 min)") ?? false, `and says how long (${text(later, "welcome-ui.json", "Body")})`);
+  },
+});

package/archetypes/idle/tests/flow.og.ts

@@ -0,0 +1,57 @@
+// The core loop through real input: Play on the title; taps on the orb
+// (a click on it, Space, Enter) make sparks; a click beside the orb makes
+// none; 1 buys an Ember and the HUD's button a second, each at its price
+// (15, then 15 × 1.15 rounded up); the embers then make sparks on their
+// own, half a spark a second each; a purchase the sparks cannot cover is
+// refused and costs nothing.
+import { playtest } from "@origingame/engine/playtest";
+import { game, ORB, PLAY, press, tap, tapAt, TITLE } from "./lib.ts";
+
+export default playtest({
+  name: "taps make sparks, sparks buy embers, embers make sparks, a purchase too dear is refused",
+  commands: [
+    "0.3:get:Game:title.json",
+    tap("play", 0.9),
+    "1.6:get:Game:start.json",
+    ...Array.from({ length: 10 }, (_, i) => tapAt(ORB.x + (i % 3) * 20 - 20, ORB.y + 10, +(1.7 + i * 0.12).toFixed(2))),
+    tapAt(ORB.x + 300, ORB.y, 3.0),
+    press("Space", 3.2),
+    press("Enter", 3.3),
+    "3.5:get:Game:tapped.json",
+    "3.55:screenshot:tapped.png",
+    "3.6:sparks:40",
+    press("Digit1", 3.7),
+    "3.8:get:Game:one.json",
+    tap("Shop/Gen#0/Buy", 3.9),
+    "4.1:touch_move:200,300",
+    "4.2:get:Game:two.json",
+    "6.2:get:Game:later.json",
+    press("Digit4", 6.3),
+    "6.4:get:Game:refused.json",
+    "6.5:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.ok(run.quit, "the script reached quit");
+    t.equal(game(run, "title.json").phase, TITLE, "the game opens on the title");
+    const start = game(run, "start.json");
+    t.equal(start.phase, PLAY, "Play showed the orb");
+    t.equal(start.sparks, 0, "with no sparks");
+    const tapped = game(run, "tapped.json");
+    t.equal(tapped.taps, 12, "ten clicks on the orb, Space and Enter: twelve taps; the click beside it none");
+    t.equal(tapped.sparks, 12, "a spark a tap");
+    const one = game(run, "one.json");
+    t.equal(one.owned0, 1, "1 bought an Ember");
+    t.ok(Math.abs(one.sparks - (40 - 15)) < 0.1, `for 15 sparks (${one.sparks.toFixed(2)} left)`);
+    t.equal(one.rate, 0.5, "half a spark a second");
+    const two = game(run, "two.json");
+    t.equal(two.owned0, 2, "the HUD's button bought a second");
+    t.ok(Math.abs(two.sparks - (one.sparks - 18)) < 0.6, `for 18 (15 × 1.15, rounded up) (${one.sparks.toFixed(2)} → ${two.sparks.toFixed(2)}, the embers making a little meanwhile)`);
+    const later = game(run, "later.json");
+    t.ok(Math.abs(later.sparks - two.sparks - 2 * 1.0 * 2.0 / 2) < 0.05, `two embers made a spark a second for two seconds (${two.sparks.toFixed(2)} → ${later.sparks.toFixed(2)})`);
+    const refused = game(run, "refused.json");
+    t.equal(refused.refused, 1, "a Star (13,000) was refused");
+    t.equal(refused.owned3, 0, "none bought");
+    t.ok(refused.sparks >= later.sparks, "and nothing spent");
+  },
+});

package/archetypes/idle/tests/frames.og.ts

@@ -0,0 +1,33 @@
+// Three frames at 1280×720 compared with references/<tier>/: the title
+// over the orb, a run with every generator circling the orb, and the
+// supernova's card. `OG_FX_CAPTURE=1 og test .` records this tier's
+// references.
+import { playtest } from "@origingame/engine/playtest";
+import { checkFrames } from "./frames.ts";
+
+const FILES = ["title.png", "orbit.png", "card.png"];
+
+export default playtest({
+  name: "the title, the orb with its motes and the supernova's card match their reference frames",
+  size: "1280x720",
+  commands: [
+    "0.9:screenshot:title.png",
+    "1.0:play",
+    "1.1:own:0:12",
+    "1.1:own:1:8",
+    "1.1:own:2:5",
+    "1.1:own:3:3",
+    "1.2:sparks:2500000",
+    "2.2:screenshot:orbit.png",
+    "2.3:supernova",
+    "4.0:screenshot:card.png",
+    "4.1:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.frame(FILES, () => {
+      for (const f of FILES) t.equal(run.png(f).width, 1280, `${f} is 1280 wide`);
+    });
+    checkFrames(run, t, FILES, "");
+  },
+});