@origingame/engine 0.3.0 → 0.5.0

package/src/node/polish.ts

@@ -611,7 +611,8 @@ interface PlaytestMeasures {
   hud: { gameplayShots: number; worstShare: number; worstCentre: number };
   ui: { screenChanges: number; withMotion: number; presses: number; pressesWithSound: number; motionTicks: number };
   latency: { inputs: number; answered: number; medianTicks: number; maxTicks: number; baselineShare: number; sound: number };
-  damage: { moments: number; hitStop: number; shake: number; floating: number; sound: number; flash: number; particles: number; facts: string[] };
+  /** Per signal, the moments that had it; `whole`, the moments with three of the four (hit stop, shake, floating text, a sound: og-feel §7's rule); `credit`, each moment's min(3, its signals) summed, what the score reads. */
+  damage: { moments: number; hitStop: number; shake: number; floating: number; sound: number; flash: number; particles: number; whole: number; credit: number; facts: string[] };
   idle: { share: number };
   particles: { peakSystems: number; bursts: number };
   /** `rendered` false: no renderer (tier `none`), so render and frame time were not measured. */
@@ -757,22 +758,39 @@ function measure(rec: RunRecord, frameDir: string, frames: number, relTo: string
     const tick = rec.facts[i]!.tick;
     if (hit && (moments.length === 0 || tick - moments.at(-1)! > 3)) moments.push(tick);
   }
-  const dmg = { moments: moments.length, hitStop: 0, shake: 0, floating: 0, sound: 0, flash: 0, particles: 0, facts: [...factKeys].slice(0, 6) };
+  const dmg = { moments: moments.length, hitStop: 0, shake: 0, floating: 0, sound: 0, flash: 0, particles: 0, whole: 0, credit: 0, facts: [...factKeys].slice(0, 6) };
+  // The four signals an impact is held to, in the order a finding names them: three of four make it whole.
+  const FOUR = ["hit stop", "shake", "floating text", "a sound"] as const;
+  const FIX: Record<(typeof FOUR)[number], string> = { "hit stop": "og-feel §3 (hit stop by impact weight)", shake: "og-feel §4 (trauma, not offsets)", "floating text": "og-feel §7 (floating text)", "a sound": "og-audio §1 (every event sounds; a hit's sound on its tick)" };
+  const lacking = new Map<(typeof FOUR)[number], number>(FOUR.map((k) => [k, 0]));
+  let short = 0;
   for (const t of moments) {
     const i = tickIndex.get(t) ?? -1;
-    if (i < 0) continue;
-    const w = sig.slice(Math.max(1, i - 3), Math.min(s.length, i + 9));
-    const held = s.slice(Math.max(0, i - 3), Math.min(s.length, i + 9)).some((p) => p.hitStop > 0 || p.scale < 1);
-    if (held || w.some((x) => x.hitStop)) dmg.hitStop++;
-    if (w.some((x) => x.shake)) dmg.shake++;
-    if (w.some((x) => x.floating)) dmg.floating++;
-    if (w.some((x) => x.sfx)) dmg.sound++;
+    // A moment the record cannot place is short of all four.
+    const w = i < 0 ? [] : sig.slice(Math.max(1, i - 3), Math.min(s.length, i + 9));
+    const held = i >= 0 && s.slice(Math.max(0, i - 3), Math.min(s.length, i + 9)).some((p) => p.hitStop > 0 || p.scale < 1);
+    const has = { "hit stop": held || w.some((x) => x.hitStop), shake: w.some((x) => x.shake), "floating text": w.some((x) => x.floating), "a sound": w.some((x) => x.sfx) };
+    if (has["hit stop"]) dmg.hitStop++;
+    if (has.shake) dmg.shake++;
+    if (has["floating text"]) dmg.floating++;
+    if (has["a sound"]) dmg.sound++;
     if (w.some((x) => x.tween)) dmg.flash++;
     if (w.some((x) => x.particles)) dmg.particles++;
+    const n = FOUR.filter((k) => has[k]).length;
+    dmg.credit += Math.min(3, n);
+    if (n >= 3) {
+      dmg.whole++;
+      continue;
+    }
+    // Short of three: each signal it lacks is owed. A whole moment owes none,
+    // so a party game's bump with hit stop, shake and a sound is not asked
+    // for a floating number (og-feel §7: damage and score numbers).
+    short++;
+    for (const k of FOUR) if (!has[k]) lacking.set(k, lacking.get(k)! + 1);
   }
-  if (dmg.moments > 0) {
-    const missing = [["hit stop", dmg.hitStop, "og-feel §3 (hit stop by impact weight)"], ["shake", dmg.shake, "og-feel §4 (trauma, not offsets)"], ["floating text", dmg.floating, "og-feel §7 (floating text)"], ["a sound", dmg.sound, "og-audio §1 (every event sounds; a hit's sound on its tick)"]] as const;
-    for (const [what, n, fix] of missing) if (n < dmg.moments) findings.push({ measure: "hit feedback", where: rec.playtest, detail: `${dmg.moments - n} of ${dmg.moments} damage moments (${dmg.facts.join(", ")}) had no ${what} within 8 ticks`, fix });
+  for (const k of FOUR) {
+    const n = lacking.get(k)!;
+    if (n > 0) findings.push({ measure: "hit feedback", where: rec.playtest, detail: `${n} of ${dmg.moments} damage moments (${dmg.facts.join(", ")}) had no ${k} within 8 ticks, and fewer than three of hit stop, shake, floating text and a sound (${short} short)`, fix: FIX[k] });
   }
 
   // Idle frames, particles, frame time.
@@ -844,7 +862,8 @@ function scores(ms: PlaytestMeasures[], missingKeys: number, hasLocales: boolean
   const lat = ms.filter((m) => m.latency.inputs > 0);
   const latency = lat.length === 0 ? null : Math.round(lat.reduce((n, m) => n + (m.latency.answered / m.latency.inputs) * (m.latency.medianTicks <= 1 ? 100 : m.latency.medianTicks <= 3 ? 70 : m.latency.medianTicks <= 6 ? 40 : 0), 0) / lat.length);
   const dm = sum((m) => m.damage.moments);
-  const hitFeedback = dm === 0 ? null : Math.round((100 * sum((m) => Math.min(3, [m.damage.hitStop, m.damage.shake, m.damage.floating, m.damage.sound].filter((n) => n > 0).length) / 3 * m.damage.moments)) / dm);
+  // Per impact: each moment scores min(3, its signals) of 3, so three of four is 100 and no moment's lack hides behind another's signal.
+  const hitFeedback = dm === 0 ? null : Math.round((100 * sum((m) => m.damage.credit)) / (3 * dm));
   const gameplay = ms.filter((m) => m.hud.gameplayShots > 0);
   const hud = gameplay.length === 0 ? null : Math.min(...gameplay.map((m) => Math.min(band(m.hud.worstShare, 15, 45), band(m.hud.worstCentre, 5, 30))));
   const timed = ms.filter((m) => m.frame.rendered);
@@ -894,7 +913,7 @@ function markdown(project: string, ms: PlaytestMeasures[], sc: Scores, findings:
   L.push(`| Locale keys | ${show(sc.locale)} | string tables without missing keys (og cook) |`);
   L.push(`| **Feel** | **${show(sc.feel)}** | mean of the feel rows |`);
   L.push(`| Input latency | ${show(sc.latency)} | inputs answered, by the median ticks to the answer (0–1: 100) |`);
-  L.push(`| Hit feedback | ${show(sc.hitFeedback)} | damage moments with hit stop, shake, floating text or a sound (three of four: 100) |`);
+  L.push(`| Hit feedback | ${show(sc.hitFeedback)} | each damage moment with three of hit stop, shake, floating text and a sound (every moment so: 100) |`);
   L.push(`| Idle frames | ${show(sc.idle)} | ticks where nothing new is seen or heard (10 %: 100, 60 %: 0) |`);
   L.push(`| Frame time | ${sc.frameTime === null && ms.length > 0 && ms.every((m) => !m.frame.rendered) ? "n/a (no renderer)" : show(sc.frameTime)} | p95 step + render (8.3 ms: 100, 33 ms: 0), worst playtest${ms.some((m) => !m.frame.rendered) ? "; no renderer: not measured" : ""} |`);
   L.push(`| Sound on input | ${show(sc.inputSound)} | inputs answered by a sound within 6 ticks |`, "");
@@ -920,7 +939,7 @@ function markdown(project: string, ms: PlaytestMeasures[], sc: Scores, findings:
     L.push(`| HUD | ${m.hud.gameplayShots} gameplay frame(s), up to ${m.hud.worstShare} % of the surface, ${m.hud.worstCentre} % of the centre |`);
     L.push(`| UI | ${m.ui.screenChanges} screen change(s), ${m.ui.withMotion} with motion; ${m.ui.motionTicks} ticks of UI motion; ${m.ui.presses} press(es), ${m.ui.pressesWithSound} with a ui-bus sound |`);
     L.push(`| Inputs | ${m.latency.inputs}, ${m.latency.answered} answered, median ${m.latency.medianTicks} ticks, max ${m.latency.maxTicks}; ${m.latency.sound} with a sound; ${m.latency.baselineShare} % of input-free ticks also change something |`);
-    L.push(`| Damage | ${m.damage.moments} moment(s)${m.damage.facts.length ? ` from ${m.damage.facts.map((f) => `\`${f}\``).join(", ")}` : ""}: hit stop ${m.damage.hitStop}, shake ${m.damage.shake}, floating text ${m.damage.floating}, sound ${m.damage.sound}, tween ${m.damage.flash}, particles ${m.damage.particles} |`);
+    L.push(`| Damage | ${m.damage.moments} moment(s)${m.damage.facts.length ? ` from ${m.damage.facts.map((f) => `\`${f}\``).join(", ")}` : ""}: hit stop ${m.damage.hitStop}, shake ${m.damage.shake}, floating text ${m.damage.floating}, sound ${m.damage.sound} (three of four: ${m.damage.whole}), tween ${m.damage.flash}, particles ${m.damage.particles} |`);
     L.push(`| Idle | ${m.idle.share} % of ticks |`);
     L.push(`| Particles | peak ${m.particles.peakSystems} system(s), ${m.particles.bursts} burst(s) |`);
     if (m.frame.rendered) L.push(`| Frame (${m.frame.tier}) | step ${m.frame.stepMedianMs} ms median, ${m.frame.stepP95Ms} p95; render ${m.frame.renderMedianMs} median, ${m.frame.renderP95Ms} p95; frame p95 ${m.frame.frameP95Ms}, max ${m.frame.frameMaxMs} |`);

package/src/node/run.ts

@@ -44,7 +44,7 @@ import { loadNativeHost, native } from "./index.ts";
 import { openAudio, type AudioSink } from "./audio.ts";
 import { nativePlatform } from "./platform.ts";
 import { Trace, unixMs, type TraceDocument } from "../trace.ts";
-import { beginBundle, boundHost, createEngine, fixedClock, type Engine, type GameToken } from "../runtime.ts";
+import { beginBundle, boundHost, createEngine, fixedClock, type Engine, type GameToken, type Result } from "../runtime.ts";
 
 const argv = process.argv.slice(2);
 let entry = "";
@@ -298,7 +298,7 @@ if (!probing) {
   if (!advanced.ok) fail(advanced.reason);
   sink.pump();
 } else {
-  let pendingReload: { mtimeMs: number } | null = null;
+  let pendingReload: { mtimeMs: number; importMs: number } | null = null;
   // Imports in flight: a reload swaps only once the last one has declared
   // everything (a second write of the bundle starts another import, whose
   // beginBundle clears the declarations the first one made).
@@ -313,9 +313,10 @@ if (!probing) {
         const mtimeMs = statSync(watchFile!).mtimeMs;
         importing++;
         try {
+          const started = performance.now();
           beginBundle();
           await importGame(watchFile!);
-          pendingReload = { mtimeMs };
+          pendingReload = { mtimeMs, importMs: performance.now() - started };
         } catch (e) {
           process.stderr.write(`WARN reload: the bundle failed to import (${e instanceof Error ? e.message : String(e)}); the old one keeps running\n`);
         } finally {
@@ -328,13 +329,29 @@ if (!probing) {
   let last = performance.now();
   for (;;) {
     if (pendingReload && importing === 0) {
-      const { mtimeMs } = pendingReload as { mtimeMs: number };
+      const { mtimeMs, importMs } = pendingReload as { mtimeMs: number; importMs: number };
       pendingReload = null;
+      const restoring = performance.now();
       const report = engine.probe.reload() as { ms: number; tick: number } | null;
+      const restored = performance.now();
       const first = engine.frame(0);
-      const captured = render && engine.probe.capture(0, 0) !== null;
+      const submitted = performance.now();
+      let rendered = false;
+      if (first.rendered) {
+        // Measure the completed first frame, without rendering and encoding
+        // an unused second frame through probe.capture.
+        const waited: Result<void> = JSON.parse(extras.og_node_wait_gpu(engine.id));
+        if (!waited.ok) fail(`reload's first frame: ${waited.reason}`);
+        rendered = true;
+      }
+      const timings = {
+        importMs,
+        reloadMs: restored - restoring,
+        frameMs: submitted - restored,
+        gpuWaitMs: performance.now() - submitted,
+      };
       const latencyMs = Date.now() - mtimeMs;
-      process.stdout.write(JSON.stringify({ event: "reload", ok: report !== null, report, tick: first.tick, captured, latencyMs: +latencyMs.toFixed(1) }) + "\n");
+      process.stdout.write(JSON.stringify({ event: "reload", ok: report !== null && first.ok, report, tick: first.tick, rendered, timings, latencyMs: +latencyMs.toFixed(1) }) + "\n");
       drain();
     }
     const elapsed = realtime ? performance.now() - last : tickMs;

package/src/platform-local.ts

@@ -28,6 +28,8 @@ export interface PlatformHost {
   /** `player`, `local` or `none` (og.platform.info). */
   readonly host: string;
   readonly capabilities: readonly string[];
+  /** The Player hello's UTC milliseconds, sampled when this host attaches. */
+  readonly time?: number | undefined;
   /** Handle calls in order; answer every one but `telemetry`, now or later. */
   handle(calls: readonly PlatformCall[], answer: (request: number, result: PlatformAnswer) => void): void;
 }

package/src/playtest.ts

@@ -127,6 +127,14 @@ export interface PlaytestDesc {
   readonly seed?: number;
   /** The render target, `WIDTHxHEIGHT` (default 1280x720). */
   readonly size?: string;
+  /**
+   * `action[:args];...` run once through the command channel after `start`, before the first
+   * tick (`og run --setup`), in every process of the playtest: the stand-ins for what a host does
+   * around the game, such as `cover:12,12,40,40`, the published page's Back over the play surface
+   * (`Viewport.covered`), so the frames lay out as the page's. Not part of `commands`: the
+   * published page plays a script without it and covers itself.
+   */
+  readonly setup?: string;
   /** Run the script this many times in fresh processes (default 1) and report every end hash in `run.hashes`: a determinism check. The files are the first run's. */
   readonly runs?: number;
   /**

package/src/runtime.ts

@@ -42,6 +42,8 @@ export interface ColumnSpec {
   readonly stride: number;
   /** The stride is each field's capacity (`str(32)`), not the kind's. */
   readonly capacity?: boolean;
+  /** The list factory (`list(u32(), 8)`): no kind of its own, a list field's kind is its element's. */
+  readonly list?: boolean;
 }
 
 export const COLUMNS: ReadonlyMap<string, ColumnSpec> = new Map(
@@ -122,6 +124,8 @@ export interface FieldSpec {
   readonly options: Record<string, unknown>;
   /** A `str` field's capacity in bytes. */
   readonly capacity?: number;
+  /** A list field's capacity in elements (`list(u32(), 8)`); `kind` is the element's. */
+  readonly list?: number;
 }
 
 export interface Token {
@@ -138,6 +142,7 @@ function fieldList(fields: Readonly<Record<string, FieldSpec>>): unknown[] {
     default: spec?.default,
     options: spec?.options ?? {},
     ...(spec?.capacity === undefined ? {} : { capacity: spec.capacity }),
+    ...(spec?.list === undefined ? {} : { list: spec.list }),
   }));
 }
 
@@ -150,13 +155,18 @@ export function defineRecord(kind: "component" | "resource", name: string, field
   return token;
 }
 
-function builtinFields(fields: ReadonlyArray<{ name: string; column?: string; type?: string; default?: unknown }>): Record<string, FieldSpec> {
+type DeclField = { name: string; column?: string; type?: string; default?: unknown; list?: number };
+
+function builtinFields(fields: ReadonlyArray<DeclField>): Record<string, FieldSpec> {
   const out: Record<string, FieldSpec> = {};
-  for (const f of fields) out[f.name] = Object.freeze({ kind: f.column ?? f.type ?? "", default: f.default, options: Object.freeze({}) });
+  for (const f of fields) {
+    const spec = { kind: f.column ?? f.type ?? "", default: f.default, options: Object.freeze({}) };
+    out[f.name] = Object.freeze(f.list === undefined ? spec : { ...spec, list: f.list });
+  }
   return out;
 }
 
-type Decl = { name: string; schema: string; fields: Array<{ name: string; column?: string; type?: string; default?: unknown }> };
+type Decl = { name: string; schema: string; fields: Array<DeclField> };
 
 /** The engine-owned tokens on `og`, under their schema names (`og.Transform`). */
 export const BUILTINS: Readonly<Record<string, Token>> = Object.freeze(
@@ -316,7 +326,9 @@ function layoutOf(component: Token): { names: string[]; kinds: ColumnSpec[] } {
       const kind = COLUMNS.get(field.kind);
       if (!kind) throw new Error(`'${component.name}.${n}' is not a column field`);
       // A str column's stride is the field's capacity: one byte lane per byte.
-      return kind.capacity ? { ...kind, stride: field.capacity ?? 0 } : kind;
+      if (kind.capacity) return { ...kind, stride: field.capacity ?? 0 };
+      // A list's is its element's, once for the count and once per element.
+      return field.list === undefined ? kind : { ...kind, stride: kind.stride * (field.list + 1) };
     });
     layouts.set(component, (l = { names, kinds }));
   }
@@ -483,6 +495,9 @@ interface RecordField {
   readonly size: number;
   readonly readonly: boolean;
   readonly variants?: readonly string[];
+  /** A list's element kind (`f32`, `f64`, `u32`, `i32`, `handle`) and capacity in elements. */
+  readonly element?: string;
+  readonly capacity?: number;
 }
 
 interface RecordLayout {
@@ -599,9 +614,55 @@ const LANES: Readonly<Record<string, readonly string[]>> = {
   Color: ["r", "g", "b"],
 };
 
+/** Bytes of one lane of a list's element kind. */
+const LANE_SIZE: Readonly<Record<string, number>> = { f32: 4, f64: 8, u32: 4, i32: 4, handle: 8 };
+
+function readLane(v: DataView, o: number, element: string): number {
+  switch (element) {
+    case "f32": return v.getFloat32(o, true);
+    case "f64": return v.getFloat64(o, true);
+    case "u32": return v.getUint32(o, true);
+    case "i32": return v.getInt32(o, true);
+    default: return v.getUint32(o, true) + v.getUint32(o + 4, true) * 4294967296;
+  }
+}
+
+function writeLane(v: DataView, o: number, element: string, n: number): void {
+  switch (element) {
+    case "f32": return v.setFloat32(o, n, true);
+    case "f64": return v.setFloat64(o, n, true);
+    case "u32": return v.setUint32(o, n, true);
+    case "i32": return v.setInt32(o, n, true);
+    default:
+      v.setUint32(o, n % 4294967296, true);
+      v.setUint32(o + 4, Math.floor(n / 4294967296), true);
+  }
+}
+
+/** A list element checked as the engine's JSON path checks it; throws what it refuses. */
+function listElement(value: unknown, element: string, i: number): number {
+  const n = number(value, `element ${i}`);
+  const whole = (lo: number, hi: number, what: string) => {
+    if (!Number.isInteger(n) || n < lo || n > hi) throw new Error(`element ${i}: ${n} is not ${what}`);
+  };
+  if (element === "u32") whole(0, 4294967295, "a u32");
+  else if (element === "i32") whole(-2147483648, 2147483647, "an i32");
+  else if (element === "handle") whole(0, 9007199254740991, "a handle");
+  return n;
+}
+
 function decodeField(v: DataView, bytes: Uint8Array, f: RecordField): unknown {
   const o = f.offset;
   switch (f.kind) {
+    case "list": {
+      // A frozen copy: `push` throws instead of changing nothing.
+      const element = f.element ?? "f32";
+      const lane = LANE_SIZE[element] ?? 4;
+      const count = Math.min(readLane(v, o, element), f.capacity ?? 0);
+      const out: number[] = [];
+      for (let i = 0; i < count; i++) out.push(readLane(v, o + lane * (i + 1), element));
+      return Object.freeze(out);
+    }
     case "f32": return v.getFloat32(o, true);
     case "f64": return v.getFloat64(o, true);
     case "u32": return v.getUint32(o, true);
@@ -639,6 +700,23 @@ function number(value: unknown, what: string): number {
 function encodeField(v: DataView, bytes: Uint8Array, f: RecordField, value: unknown): void {
   const o = f.offset;
   switch (f.kind) {
+    case "list": {
+      // The whole list: an array, at most the capacity, every element checked before a byte moves.
+      const element = f.element ?? "f32";
+      const capacity = f.capacity ?? 0;
+      const items = value === null || value === undefined ? [] : value;
+      if (!Array.isArray(items)) throw new Error(`a list is written whole, as an array, got ${JSON.stringify(value)}`);
+      if (items.length > capacity) {
+        const kind = element === "handle" ? "Asset" : element;
+        throw new Error(`${items.length} elements and the field holds ${capacity}: remove ${items.length - capacity}, or declare the field list(${kind}(), ${items.length}) or larger`);
+      }
+      const lanes = items.map((x, i) => listElement(x, element, i));
+      const lane = LANE_SIZE[element] ?? 4;
+      bytes.fill(0, o, o + f.size);
+      writeLane(v, o, element, lanes.length);
+      lanes.forEach((n, i) => writeLane(v, o + lane * (i + 1), element, n));
+      return;
+    }
     case "f32": return v.setFloat32(o, number(value, "the value"), true);
     case "f64": return v.setFloat64(o, number(value, "the value"), true);
     case "u32": {
@@ -732,7 +810,9 @@ function recordHandle(world: WorldImpl, r: RecordCopy): object {
         if (!refresh(r)) {
           const answer = parse<Result<Record<string, unknown>>>(host!.abi.og_world_resource(id, name));
           if (!answer.ok) throw new Error(`${name}: ${answer.reason}`);
-          return (lastValue = answer.value[key]);
+          const value = answer.value[key];
+          // A list reads as a frozen copy on this path too.
+          return (lastValue = Array.isArray(value) ? Object.freeze(value) : value);
         }
       }
       return (lastValue = decodeField(r.view, r.bytes, field()));
@@ -1122,7 +1202,7 @@ export class Engine {
   /** Attach what answers og.platform's calls: the native host's local store, the web shell's Player bridge. */
   attachPlatform(host: PlatformHost): void {
     this.#platform = host;
-    abi().og_platform_set_host(this.id, JSON.stringify({ host: host.host, capabilities: host.capabilities, time: this.#clock.now(), clock: this.#clock.kind }));
+    abi().og_platform_set_host(this.id, JSON.stringify({ host: host.host, capabilities: host.capabilities, time: host.time ?? this.#clock.now(), clock: host.time === undefined ? this.#clock.kind : "player" }));
   }
 
   /** Set the clock og.platform tells the game (before attachPlatform, which tells it the time). */
@@ -1335,6 +1415,7 @@ export const render = Object.freeze({
     parse(abi().og_render_update_material(world.id, material, json(desc))),
   capabilities: (world: WorldImpl) => parse(abi().og_render_capabilities(world.id)),
   applyLook: (world: WorldImpl, look: number) => parse(abi().og_render_apply_look(world.id, look)),
+  applyQuality: (world: WorldImpl, preset: string) => parse(abi().og_render_apply_quality(world.id, preset)),
   look: (world: WorldImpl) => parse(abi().og_render_look(world.id)),
   text: (world: WorldImpl, desc?: unknown) => parse(abi().og_render_text(world.id, json(desc))),
   sprite: (world: WorldImpl, desc?: unknown) => parse(abi().og_render_sprite(world.id, json(desc))),
@@ -1389,6 +1470,7 @@ export const anim = Object.freeze({
   graph: (world: WorldImpl, desc?: unknown) => parse(abi().og_anim_graph(world.id, json(desc))),
   humanoid: (world: WorldImpl, desc?: unknown) => parse(abi().og_anim_humanoid(world.id, json(desc))),
   retarget: (world: WorldImpl, desc?: unknown) => parse(abi().og_anim_retarget(world.id, json(desc))),
+  mirror: (world: WorldImpl, desc?: unknown) => parse(abi().og_anim_mirror(world.id, json(desc))),
   rig2dInfo: (world: WorldImpl, rig: number) => parse(abi().og_anim_rig2d_info(world.id, rig)),
   skeleton2dBoxes: (world: WorldImpl, entity: number) => parse(abi().og_anim_skeleton2d_boxes(world.id, entity)),
   // One lookup for a flipbook's or a 2D rig's clips (an index, -1 when

package/src/ui-kit/settings.ts

@@ -2,8 +2,11 @@
 // game's GameSettings. The game owns the values (a resource, a save); the
 // screen answers the new ones every tick and calls the hooks: onChange on
 // every change (apply it at once), onSave when it closes after changes.
+// A new graphics preset is applied to SettingsDesc.world by the screen
+// itself (og.render.applyQuality) before onChange.
 
 import type * as Api from "@origingame/engine";
+import { render } from "../runtime.ts";
 import { kit } from "./bind.ts";
 import { frame, grow, px, token } from "./util.ts";
 
@@ -119,6 +122,12 @@ export function settingsScreen(id: string, desc: Api.SettingsDesc = {}): Api.Set
   const changed = JSON.stringify(s) !== JSON.stringify(before);
   if (changed) {
     dirty = true;
+    // The preset is RenderSettings' quality fields (og.render.applyQuality):
+    // the next frame draws it, and the probe reads what is drawn.
+    if (s.quality !== before.quality && desc.world) {
+      const r = render.applyQuality(desc.world as unknown as Parameters<typeof render.applyQuality>[0], s.quality) as Api.Result<void>;
+      if (!r.ok) throw new Error(`og.ui.settingsScreen: ${r.reason}`);
+    }
     desc.onChange?.(s);
   }
   if (closed && dirty) {