@origingame/create-game 0.0.0-stage → 0.1.0

package/archetypes/idle/package.json

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

package/archetypes/idle/project.ogt

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

package/archetypes/idle/src/components.ts

@@ -0,0 +1,139 @@
+// Every piece of Spark Orb's state lives in these reflected types: dumps,
+// the probe, Tune and the command channel's `get` and `set` read and write
+// them by name.
+//
+// The run and the save (Game), the knobs (Tuning) and the player's
+// settings (Prefs) are resources. The drawn things are rows spawned in
+// `start`: the orb, its glow, the motes that circle it (one pool per
+// generator) and one voice per sound.
+
+import { bool, defineComponent, defineResource, f32, f64, i32, u32 } from "@origingame/engine";
+
+/** The screen the game is on. */
+export const Phase = { Title: 0, Play: 1, Nova: 2 } as const;
+
+/** The generators, in order: what each is called in the string tables and drawn with. */
+export const GENERATORS = ["ember", "storm", "crystal", "star"] as const;
+
+/** Motes drawn per generator at most (one per generator owned). */
+export const MOTES = 12;
+
+/** Sound requests: bits of Game.sfx that the Voices system plays once each. */
+export const Sound = { Tap: 1, Buy: 2, Milestone: 4, Nova: 8, Welcome: 16, Move: 32 } as const;
+
+/** The run, the save and the effects' bookkeeping. */
+export const Game = defineResource("Game", {
+  phase: u32(Phase.Title, { doc: "Phase.* of src/components.ts." }),
+  leftTitle: bool(false, { doc: "The player has left the title the game opened on: from then on the title enters with the skin's entrance (the opening one is built settled, og.ui.mainMenu's instant: the web draws it behind the play gate)." }),
+  paused: bool(false),
+  settingsOpen: bool(false),
+  held: bool(false, { doc: "The time scale is held at 0 (paused, in the settings or a dialog)." }),
+  confirmNova: bool(false, { doc: "The Supernova dialog is open." }),
+  welcome: bool(false, { doc: "The welcome-back dialog is open." }),
+  sparks: f64(0, { doc: "The currency." }),
+  runEarned: f64(0, { doc: "Sparks made this run (since the last supernova): the supernova's stardust grows with it." }),
+  lifetime: f64(0, { doc: "Sparks made on this save, every run." }),
+  owned0: u32(0, { doc: "Embers owned." }),
+  owned1: u32(0, { doc: "Storms owned." }),
+  owned2: u32(0, { doc: "Crystals owned." }),
+  owned3: u32(0, { doc: "Stars owned." }),
+  dust: u32(0, { doc: "Stardust: +10 % to everything each (Tuning.dustBonus)." }),
+  novas: u32(0, { doc: "Supernovas on this save." }),
+  lastGain: u32(0, { doc: "Stardust the last supernova gave." }),
+  lastRun: f64(0, { doc: "Sparks the last supernova's run made." }),
+  lastRunTicks: u32(0, { unit: "ticks" }),
+  runTicks: u32(0, { unit: "ticks", doc: "Ticks played this run." }),
+  rate: f64(0, { unit: "sparks/s", doc: "Sparks a second now (the generators, the milestones, the stardust)." }),
+  tapValue: f64(1, { doc: "Sparks a tap makes now." }),
+  taps: u32(0),
+  streak: u32(0, { doc: "Taps in a quick run (each within 20 ticks of the last): the chime climbs." }),
+  lastTapTick: i32(-100, { unit: "ticks" }),
+  buys: u32(0),
+  boughtSlot: i32(-1, { doc: "The generator bought last (its card pops)." }),
+  boughtTick: i32(-1, { unit: "ticks" }),
+  refused: u32(0, { doc: "Purchases refused for want of sparks." }),
+  refusedSlot: i32(-1, { doc: "The generator whose purchase was refused last (its card shakes)." }),
+  refusedTick: i32(-1, { unit: "ticks" }),
+  milestoneSlot: i32(-1, { doc: "The generator that reached a milestone last (its card bursts)." }),
+  milestoneTick: i32(-1, { unit: "ticks" }),
+  selected: u32(0, { doc: "The generator the keys and the pad buy (0-3)." }),
+  playTick: i32(-1, { unit: "ticks", doc: "The tick play began (from the title or a new run): the key or button that began it is not also a tap or a purchase." }),
+  pendingTap: bool(false, { doc: "A tap asked for by the HUD this tick (the Orb system makes it)." }),
+  pendingBuy: i32(-1, { doc: "A purchase asked for by the HUD this tick (the Economy system makes it)." }),
+  pendingNova: bool(false, { doc: "The supernova confirmed this tick (the Economy system makes it)." }),
+  away: f64(0, { unit: "s", doc: "Seconds the game was closed: the save's answer's time (og.platform's host clock) less the time the save was written; relaunch:<s> sets it for a test." }),
+  offline: f64(0, { doc: "Sparks the orb made while the game was closed (shown on the welcome-back dialog)." }),
+  saveRequest: u32(0, { doc: "The store request reading `orb`." }),
+  saveRevision: u32(0, { doc: "The revision `orb` was read or written at." }),
+  saveWrite: u32(0, { doc: "The store request writing `orb`." }),
+  saveMerge: bool(false, { doc: "A write was refused as stale: the save is read again, merged and written." }),
+  saveConflicts: u32(0),
+  saves: u32(0, { doc: "Saves written." }),
+  loaded: bool(false, { doc: "The save was read (or found empty) on launch." }),
+  sinceSave: u32(0, { unit: "ticks" }),
+  saveNow: bool(false, { doc: "Write the save this tick (after a supernova, on pause, on Quit)." }),
+  burstKind: u32(0, { doc: "The burst asked for this tick (BURST.* of src/systems.ts)." }),
+  burstX: f32(0, { unit: "m" }),
+  burstY: f32(0, { unit: "m" }),
+  burstTick: i32(-1, { unit: "ticks", doc: "The tick a burst was asked for (the Bursts system fires it the same tick)." }),
+  sfx: u32(0),
+  viewW: f32(0, { unit: "cssPx" }),
+  viewH: f32(0, { unit: "cssPx" }),
+  orbX: f32(0, { unit: "m", doc: "The orb's centre (it moves up on a phone)." }),
+  orbY: f32(0, { unit: "m" }),
+  language: u32(0, { doc: "Prefs.language, mirrored for the facts." }),
+});
+
+/** The knobs. Tune reads the tunable fields; `set:Tuning.<field>=<value>` writes them. */
+export const Tuning = defineResource("Tuning", {
+  emberRate: f32(0.5, { min: 0, max: 1000, tunable: true, unit: "sparks/s", label: "Ember makes" }),
+  emberCost: f32(15, { min: 1, max: 1e6, tunable: true, label: "Ember costs" }),
+  stormRate: f32(4, { min: 0, max: 1e4, tunable: true, unit: "sparks/s", label: "Storm makes" }),
+  stormCost: f32(110, { min: 1, max: 1e7, tunable: true, label: "Storm costs" }),
+  crystalRate: f32(26, { min: 0, max: 1e5, tunable: true, unit: "sparks/s", label: "Crystal makes" }),
+  crystalCost: f32(1200, { min: 1, max: 1e8, tunable: true, label: "Crystal costs" }),
+  starRate: f32(160, { min: 0, max: 1e6, tunable: true, unit: "sparks/s", label: "Star makes" }),
+  starCost: f32(13000, { min: 1, max: 1e9, tunable: true, label: "Star costs" }),
+  costGrowth: f32(1.15, { min: 1, max: 2, step: 0.01, tunable: true, label: "Price growth", doc: "Each one bought multiplies the next one's price." }),
+  milestone: u32(10, { min: 1, max: 100, tunable: true, label: "Milestone every", doc: "Every this many of a generator doubles what that generator makes." }),
+  tapBase: f32(1, { min: 0, max: 1000, tunable: true, label: "A tap makes" }),
+  tapShare: f32(0.05, { min: 0, max: 1, step: 0.01, tunable: true, label: "Tap's share of the rate", doc: "A tap also makes this many seconds' worth of the rate." }),
+  dustBonus: f32(0.1, { min: 0, max: 1, step: 0.01, tunable: true, label: "Stardust bonus", doc: "Each stardust adds this to every multiplier." }),
+  novaScale: f32(100000, { min: 1, max: 1e12, tunable: true, label: "Supernova scale", doc: "Stardust from a supernova is floor(sqrt(run sparks / this))." }),
+  offlineShare: f32(0.5, { min: 0, max: 1, step: 0.05, tunable: true, label: "Offline share", doc: "The share of the rate the orb makes while the game is closed." }),
+  offlineCap: f32(28800, { min: 0, max: 604800, tunable: true, unit: "s", label: "Offline cap" }),
+  saveEvery: u32(600, { min: 60, max: 36000, tunable: true, unit: "ticks", label: "Save every" }),
+});
+
+/** The player's settings: kept in og.platform's settings, restored on the first ticks. */
+export const Prefs = defineResource("Prefs", {
+  master: f32(1, { min: 0, max: 1 }),
+  music: f32(0.7, { min: 0, max: 1 }),
+  effects: f32(1, { min: 0, max: 1 }),
+  language: u32(0, { doc: "0 English, 1 简体中文 (LANGUAGES in src/ui.ts)." }),
+  reducedMotion: bool(false),
+  loadRequest: u32(0),
+  saves: u32(0),
+});
+
+/** The orb: a tap squashes and flashes it. */
+export const Orb = defineComponent("Orb", {
+  taps: u32(0),
+});
+
+/** A mote circling the orb: one per generator owned, up to MOTES per generator. */
+export const Mote = defineComponent("Mote", {
+  tier: u32(0, { doc: "The generator (0-3)." }),
+  index: u32(0, { doc: "Its place in the tier's ring." }),
+});
+
+/** A pooled particle burst of one kind (BURST.* of src/systems.ts). */
+export const Burst = defineComponent("Burst", {
+  kind: u32(0),
+});
+
+/** One voice: plays its sound once when Game.sfx asks for its bit. */
+export const Sfx = defineComponent("Sfx", {
+  bit: u32(0),
+  plays: u32(0),
+});

package/archetypes/idle/src/main.ts

@@ -0,0 +1,247 @@
+// Spark Orb, the idle archetype (2D profile): a glowing orb in the night.
+// Tap it for sparks; spend them on generators (embers, storms, crystals,
+// stars) that make sparks on their own and circle the orb as motes; every
+// tenth of a kind doubles that kind. When the run has made enough, the orb
+// can collapse into a supernova: sparks and generators go, stardust stays,
+// and each stardust makes everything 10 % stronger. The save lives in
+// og.platform's store with the host's time it was written at; on a launch
+// the time away (the save's answer's time less that) is credited at half
+// the rate.
+//
+// The look (GameDesc.look, a file under assets/looks/) sets the frame's
+// treatment and the UI skin before start runs. `start` loads the strings,
+// the sounds and the orb's art and spawns the rows: the orb and its glow,
+// 48 motes (12 per generator), the burst pools, a voice per sound and the
+// music. The systems are in
+// src/systems.ts, the formulas and big numbers in src/numbers.ts, the
+// screens and the save in src/ui.ts and the state in src/components.ts.
+
+import { og } from "@origingame/engine";
+import type { World } from "@origingame/engine";
+import { Burst, Game, GENERATORS, Mote, MOTES, Orb, Phase, Prefs, Sfx, Sound, Tuning } from "./components.ts";
+import { counts, Bursts, BURST, Economy, lazyTuning, Motes, nova, ORB_RADIUS, OrbTap, TIER_COLOURS, Voices } from "./systems.ts";
+import { setOwned } from "./numbers.ts";
+import { LANGUAGES, launch, Ui } from "./ui.ts";
+
+/** The night, linear. */
+const NIGHT = { r: 0.004, g: 0.002, b: 0.012 };
+
+function must<T>(r: { ok: true; value: T } | { ok: false; reason: string }): T;
+function must(r: { ok: true } | { ok: false; reason: string }): void;
+function must<T>(r: { ok: true; value?: T } | { ok: false; reason: string }): T | void {
+  if (!r.ok) throw new Error(r.reason);
+  return r.value;
+}
+
+function start(world: World): void {
+  for (const l of LANGUAGES) must(og.i18n.load(world, `strings/${l.code}.ogt`));
+  // GameDesc.look set the frame and loaded the skin before start; the UI
+  // keeps that skin and adds the sounds.
+  const skin = og.render.look(world)?.skin ?? null;
+  const sound = (path: string) => must(og.load.sound(world, path));
+  must(og.ui.configure(world, { skin, sounds: { press: sound("audio/ui-press.ogt"), open: sound("audio/ui-open.ogt"), close: sound("audio/ui-close.ogt"), error: sound("audio/ui-error.ogt"), success: sound("audio/ui-success.ogt") } }));
+
+  const camera = must(world.resource(og.Camera));
+  camera.orthographic = true;
+  camera.height = 10;
+  camera.position = { x: 0, y: 0, z: 50 };
+  camera.background = NIGHT;
+
+  const texture = (path: string) => must(og.load.texture(world, path));
+  // The night: a violet haze and fixed stars of the dice (og.Rng's "stars" stream, the same every launch).
+  const haze = must(world.spawn({ name: "haze", position: { x: 0, y: 0.35, z: 0 } }));
+  must(world.insert(haze, og.Sprite, { texture: texture("sprites/glow.png"), width: 24, height: 18, color: { r: 0.4, g: 0.2, b: 0.85 }, opacity: 0.16, blend: "additive", layer: -11 }));
+  const spark = texture("sprites/spark.png");
+  const dice = must(world.resource(og.Rng)).fork("stars");
+  for (let i = 0; i < 140; i++) {
+    const star = must(world.spawn({ name: `star-${i}`, position: { x: dice.range(-15, 15), y: dice.range(-10, 10), z: 0 } }));
+    const size = dice.range(0.05, 0.16);
+    const warm = dice.next();
+    must(world.insert(star, og.Sprite, { texture: spark, width: size, height: size, color: { r: 0.75 + 0.25 * warm, g: 0.82 + 0.1 * warm, b: 1 - 0.25 * warm }, opacity: dice.range(0.35, 0.9), blend: "additive", layer: -10 }));
+  }
+  const stars = must(world.spawn({ name: "stars", position: { x: 0, y: 0, z: 0 } }));
+  must(world.insert(stars, og.ParticleSystem, { emitter: must(og.load.emitter(world, "fx/stars.ogt")), seed: 3 }));
+  const glow = must(world.spawn({ name: "glow", position: { x: 0, y: 0.35, z: 0 } }));
+  must(world.insert(glow, og.Sprite, { texture: texture("sprites/glow.png"), width: ORB_RADIUS * 5.5, height: ORB_RADIUS * 5.5, color: { r: 1, g: 0.6, b: 0.2 }, opacity: 0.85, blend: "additive", layer: 1 }));
+  const drift = must(world.spawn({ name: "drift", position: { x: 0, y: 0.35, z: 0 } }));
+  must(world.insert(drift, og.ParticleSystem, { emitter: must(og.load.emitter(world, "fx/drift.ogt")), seed: 5 }));
+  const orb = must(world.spawn({ name: "orb", position: { x: 0, y: 0.35, z: 0 } }));
+  must(world.insert(orb, og.Sprite, { texture: texture("sprites/orb.png"), width: ORB_RADIUS * 2.2, height: ORB_RADIUS * 2.2, layer: 3 }));
+  must(world.insert(orb, Orb));
+
+  const moteTextures = GENERATORS.map((name) => texture(`sprites/mote-${name}.png`));
+  GENERATORS.forEach((_, tier) => {
+    for (let k = 0; k < MOTES; k++) {
+      const m = must(world.spawn({ name: `mote-${tier}-${k}`, position: { x: 0, y: -40, z: 0 } }));
+      const c = TIER_COLOURS[tier]!;
+      must(world.insert(m, og.Sprite, { texture: moteTextures[tier]!, width: 0.42, height: 0.42, color: c, blend: "additive", layer: 4, visible: false }));
+      must(world.insert(m, Mote, { tier, index: k }));
+    }
+  });
+  const pools: [number, string, number][] = [[BURST.Tap, "fx/tap.ogt", 6], [BURST.Milestone, "fx/milestone.ogt", 2], [BURST.Nova, "fx/nova.ogt", 1]];
+  for (const [kind, path, n] of pools) {
+    const emitter = must(og.load.emitter(world, path));
+    for (let i = 0; i < n; i++) {
+      const b = must(world.spawn({ name: `burst-${kind}-${i}`, position: { x: 0, y: -40, z: 0 } }));
+      must(world.insert(b, og.ParticleSystem, { emitter, seed: kind * 10 + i + 1, visible: false }));
+      must(world.insert(b, Burst, { kind }));
+    }
+  }
+
+  const voices: [string, number, "sfx" | "ui", number][] = [
+    // The orb is the game's one big button: its chime is on the ui bus, as a press's sound (og-audio §3).
+    ["audio/tap.wav", Sound.Tap, "ui", 0.5],
+    ["audio/buy.wav", Sound.Buy, "sfx", 0.55],
+    ["audio/milestone.wav", Sound.Milestone, "sfx", 0.6],
+    ["audio/nova.wav", Sound.Nova, "sfx", 0.75],
+    ["audio/ui-success.ogt", Sound.Welcome, "ui", 0.6],
+    ["audio/ui-press.ogt", Sound.Move, "ui", 0.3],
+  ];
+  for (const [path, bit, bus, volume] of voices) {
+    const v = must(world.spawn({ name: `sfx-${bit}` }));
+    must(world.insert(v, og.AudioSource, { sound: sound(path), playing: false, bus, volume, priority: 160 }));
+    must(world.insert(v, Sfx, { bit }));
+  }
+  const music = must(world.spawn({ name: "music" }));
+  must(world.insert(music, og.AudioSource, { sound: sound("audio/orbit.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: 4, duckRelease: 0.6 }));
+  const game = must(world.resource(Game));
+  game.orbY = 0.35;
+}
+
+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;
+}
+
+/** `play`: from the title to the orb, as Play does. */
+function play(world: World): void {
+  gameOf(world).phase = Phase.Play;
+}
+
+/** `sparks:<n>`: set the sparks (and count them as made this run). */
+function sparks(world: World, args: readonly string[]): void {
+  const g = gameOf(world);
+  const n = num(args[0], "n");
+  const more = Math.max(0, n - g.sparks);
+  g.sparks = n;
+  g.runEarned += more;
+  g.lifetime += more;
+}
+
+/** `own:<generator 0-3>:<n>`: set how many of a generator are owned. */
+function own(world: World, args: readonly string[]): void {
+  const g = gameOf(world);
+  const i = num(args[0], "generator");
+  if (i < 0 || i > 3) throw new Error("the generator is 0 to 3");
+  setOwned(g, i, num(args[1], "n"));
+}
+
+/** `supernova`: collapse now, as the dialog's Collapse does (refused under one stardust). */
+function supernova(world: World): void {
+  nova(world, gameOf(world), lazyTuning(world));
+}
+
+/**
+ * `relaunch:<seconds away>`: the game closed and opened again that much later, in this process:
+ * the run forgotten, the save read again, the time away credited. For tests: a real launch reads
+ * the time away from the host's clock (the save's `at` against its answer's time; tests/away.og.ts
+ * runs it across two processes).
+ */
+function relaunch(world: World, args: readonly string[]): void {
+  const g = gameOf(world);
+  const away = num(args[0], "seconds");
+  g.phase = Phase.Title;
+  g.paused = false;
+  g.settingsOpen = false;
+  g.confirmNova = false;
+  g.welcome = false;
+  g.sparks = 0;
+  g.runEarned = 0;
+  g.lifetime = 0;
+  g.owned0 = 0;
+  g.owned1 = 0;
+  g.owned2 = 0;
+  g.owned3 = 0;
+  g.dust = 0;
+  g.novas = 0;
+  g.runTicks = 0;
+  g.taps = 0;
+  g.rate = 0;
+  g.offline = 0;
+  g.loaded = false;
+  g.saveRevision = 0;
+  g.away = away;
+  launch(world, g, must(world.resource(Prefs)));
+}
+
+/** `stale_save`: another device writes a save with more lifetime sparks, so this one's next write is refused as stale and the other's progress kept. */
+function staleSave(world: World): void {
+  must(og.platform.storeSet(world, { key: "orb", value: { v: 1, sparks: 5000, runEarned: 9000, lifetime: 1e9, owned: [20, 5, 0, 0], dust: 3, novas: 1, runTicks: 600, taps: 10 } }));
+}
+
+/** `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);
+}
+
+export default og.game({
+  tick: 60,
+  seed: 1,
+  resources: [Game, Tuning, Prefs],
+  systems: [Ui, OrbTap, Economy, Motes, Bursts, Voices],
+  render: { antialias: "off" },
+  look: "looks/idle.ogt",
+  start,
+  commands: { play, sparks, own, supernova, relaunch, stale_save: staleSave, viewport, language },
+  commandHelp: {
+    play: { usage: "", doc: "From the title to the orb, as Play does." },
+    sparks: { usage: "<n>", doc: "Set the sparks (the rise counts as made this run)." },
+    own: { usage: "<generator 0-3>:<n>", doc: "Set how many of a generator are owned." },
+    supernova: { usage: "", doc: "Collapse now, as the dialog's Collapse does (refused under one stardust)." },
+    relaunch: { usage: "<seconds away>", doc: "Close and reopen the game that much later in this process (for tests; a real launch reads the time away from the host's clock): the save read again, the time away credited." },
+    stale_save: { usage: "", doc: "Another device writes a save with more progress, so this one's next write is refused as stale and merged." },
+    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." },
+  },
+  facts: (world) => {
+    const game = world.resource(Game);
+    if (!game.ok) return null;
+    const g = game.value;
+    return {
+      phase: ["title", "play", "nova"][g.phase],
+      sparks: g.sparks,
+      rate: g.rate,
+      tapValue: g.tapValue,
+      owned: counts(g),
+      dust: g.dust,
+      novas: g.novas,
+      runEarned: g.runEarned,
+      lifetime: g.lifetime,
+      taps: g.taps,
+      buys: g.buys,
+      refused: g.refused,
+      saves: g.saves,
+      saveConflicts: g.saveConflicts,
+      offline: g.offline,
+      language: LANGUAGES[g.language]!.code,
+    };
+  },
+});
+

package/archetypes/idle/src/numbers.ts

@@ -0,0 +1,126 @@
+// The economy's formulas and big numbers in words of the locale.
+//
+// Prices, rates, milestones and stardust are pure functions of the counts
+// and the tuning, so the systems, the HUD, the save's merge and the
+// playtests agree on every number.
+//
+// Big numbers come from the string tables (og-i18n): `num.step` is how
+// many digits a unit spans (3 in English: K, M, B…; 4 in Chinese: 万, 亿,
+// 万亿…), `num.<k>` the k-th unit, `num.short` how mantissa and unit join
+// and `num.sci` the scientific form past the last unit. Below the first
+// unit's tenfold a number is whole and grouped by `{n, number}`.
+
+import { og } from "@origingame/engine";
+import type { Value, World } from "@origingame/engine";
+import type { Game, Tuning } from "./components.ts";
+
+type GameV = Value<typeof Game>;
+type TuneV = Value<typeof Tuning>;
+
+/** Generator i's rate and base price from the tuning. */
+export function base(t: TuneV, i: number): { rate: number; cost: number } {
+  switch (i) {
+    case 0:
+      return { rate: t.emberRate, cost: t.emberCost };
+    case 1:
+      return { rate: t.stormRate, cost: t.stormCost };
+    case 2:
+      return { rate: t.crystalRate, cost: t.crystalCost };
+    default:
+      return { rate: t.starRate, cost: t.starCost };
+  }
+}
+
+export function owned(g: GameV, i: number): number {
+  return i === 0 ? g.owned0 : i === 1 ? g.owned1 : i === 2 ? g.owned2 : g.owned3;
+}
+
+export function setOwned(g: GameV, i: number, n: number): void {
+  if (i === 0) g.owned0 = n;
+  else if (i === 1) g.owned1 = n;
+  else if (i === 2) g.owned2 = n;
+  else g.owned3 = n;
+}
+
+/** The next one's price: the base times the growth to the count owned, rounded up. */
+export function price(t: TuneV, i: number, n: number): number {
+  return Math.ceil(base(t, i).cost * Math.pow(t.costGrowth, n));
+}
+
+/** Everything's multiplier from stardust. */
+export function dustMultiplier(t: TuneV, dust: number): number {
+  return 1 + t.dustBonus * dust;
+}
+
+/** What generator i makes a second with n owned: doubled at every milestone. */
+export function generatorRate(t: TuneV, i: number, n: number, dust: number): number {
+  return base(t, i).rate * n * Math.pow(2, Math.floor(n / t.milestone)) * dustMultiplier(t, dust);
+}
+
+export function totalRate(t: TuneV, counts: readonly number[], dust: number): number {
+  let r = 0;
+  counts.forEach((n, i) => (r += generatorRate(t, i, n, dust)));
+  return r;
+}
+
+/** A tap: the base, plus a share of the rate, times the stardust. */
+export function tapValue(t: TuneV, rate: number, dust: number): number {
+  return (t.tapBase * dustMultiplier(t, dust)) + t.tapShare * rate;
+}
+
+/** Stardust a supernova would give now. */
+export function novaGain(t: TuneV, runEarned: number): number {
+  return Math.floor(Math.sqrt(runEarned / t.novaScale));
+}
+
+/** Run sparks at which the supernova gives its first stardust. */
+export function novaAt(t: TuneV): number {
+  return t.novaScale;
+}
+
+/** Sparks made while the game was closed for `away` seconds. */
+export function offlineGain(t: TuneV, rate: number, away: number): number {
+  return rate * t.offlineShare * Math.min(Math.max(0, away), t.offlineCap);
+}
+
+/** Three significant digits, as text (the mantissa of a big number). */
+function mantissa(m: number): string {
+  return m >= 100 ? m.toFixed(0) : m >= 10 ? m.toFixed(1) : m.toFixed(2);
+}
+
+/** The locale's unit for a big number: its value in units, the unit's text and the decimals to show. */
+export function bigParts(world: World, n: number): { value: number; unit: string; decimals: number } {
+  const step = Number(og.i18n.t(world, "num.step")) || 3;
+  const unitBase = Math.pow(10, step);
+  if (!Number.isFinite(n) || n < unitBase * 10) return { value: Math.floor(Math.max(0, n)), unit: "", decimals: 0 };
+  let k = Math.floor(Math.log10(n) / step);
+  let value = n / Math.pow(unitBase, k);
+  // Rounding to three digits can make 1000K: then it is 1.00M.
+  if (Number(mantissa(value)) >= unitBase) {
+    k += 1;
+    value /= unitBase;
+  }
+  const key = `num.${k}`;
+  if (!og.i18n.has(world, key)) return { value, unit: "", decimals: -1 };
+  return { value, unit: og.i18n.t(world, key), decimals: value >= 100 ? 0 : value >= 10 ? 1 : 2 };
+}
+
+/** A number in the locale's words: `9,999`, `12.3K`, `1.20亿`, `4.56e45`. */
+export function big(world: World, n: number): string {
+  const p = bigParts(world, n);
+  if (p.unit === "" && p.decimals === 0) return og.i18n.t(world, "num.whole", { n: p.value });
+  if (p.decimals < 0) {
+    const e = Math.floor(Math.log10(n));
+    return og.i18n.t(world, "num.sci", { m: mantissa(n / Math.pow(10, e)), e });
+  }
+  return og.i18n.t(world, "num.short", { m: mantissa(p.value), u: p.unit });
+}
+
+/** A duration in the locale's words. */
+export function duration(world: World, seconds: number): string {
+  const s = Math.max(0, Math.floor(seconds));
+  const h = Math.floor(s / 3600);
+  const m = Math.floor((s % 3600) / 60);
+  if (h > 0) return og.i18n.t(world, "time.hm", { h, m });
+  return og.i18n.t(world, "time.ms", { m, s: s % 60 });
+}