@origingame/engine 0.4.0 → 0.5.0

package/shell/page.ts

@@ -600,6 +600,10 @@ export async function play(): Promise<PlayHandle> {
     pausedByPlayer = m.paused;
     if (m.started && phase === "gate") start();
   };
+  // The usual case with a real Player: it answered the shell's hello while the engine loaded,
+  // and the handler above was not installed yet (the first one only released og.platform).
+  // What that hello says applies now: its rooms, and a Play link's room through them.
+  if (!page && player.hosted) playerEvents.hello({ started: player.started, paused: player.paused, capabilities: player.capabilities });
   playerEvents.start = () => {
     byPlayer = true;
     if (phase === "gate") start();

package/src/generated/abi.ts

@@ -397,6 +397,8 @@ export interface HostAbi<A, V> {
   og_anim_humanoid(world: number, desc: string | undefined): string;
   /** `og.anim.retarget` */
   og_anim_retarget(world: number, desc: string | undefined): string;
+  /** `og.anim.mirror` */
+  og_anim_mirror(world: number, desc: string | undefined): string;
   /** `og.anim.rig2dInfo` */
   og_anim_rig2d_info(world: number, rig: number): string;
   /** `og.anim.skeleton2dBoxes` */
@@ -978,6 +980,7 @@ export const SYMBOLS: readonly string[] = [
   "og_anim_graph",
   "og_anim_humanoid",
   "og_anim_retarget",
+  "og_anim_mirror",
   "og_anim_rig2d_info",
   "og_anim_skeleton2d_boxes",
   "og_tween_to",

package/src/index.ts

@@ -72,6 +72,7 @@ export const LineMode = ((value = "strip" as Api.LineMode, options) => spec("Lin
 export const DofQuality = ((value = "low" as Api.DofQuality, options) => spec("DofQuality", value, options)) as typeof Api.DofQuality;
 export const ReflectionProbeMode = ((value = "baked" as Api.ReflectionProbeMode, options) => spec("ReflectionProbeMode", value, options)) as typeof Api.ReflectionProbeMode;
 export const SpriteBlend = ((value = "alpha" as Api.SpriteBlend, options) => spec("SpriteBlend", value, options)) as typeof Api.SpriteBlend;
+export const SpriteFacing = ((value = "none" as Api.SpriteFacing, options) => spec("SpriteFacing", value, options)) as typeof Api.SpriteFacing;
 export const StripBlend = ((value = "additive" as Api.StripBlend, options) => spec("StripBlend", value, options)) as typeof Api.StripBlend;
 export const Palette = ((value = 0 as Api.Palette, options) => spec("Palette", value, options)) as typeof Api.Palette;
 export const DitherPattern = ((value = "none" as Api.DitherPattern, options) => spec("DitherPattern", value, options)) as typeof Api.DitherPattern;
@@ -79,6 +80,11 @@ export const StyliseSpace = ((value = "screen" as Api.StyliseSpace, options) =>
 export const TextureArray = ((value = 0 as Api.TextureArray, options) => spec("TextureArray", value, options)) as typeof Api.TextureArray;
 export const Asset = ((value = 0 as Api.Asset, options) => spec("Asset", value, options)) as typeof Api.Asset;
 export const Sound = ((value = 0 as Api.Sound, options) => spec("Sound", value, options)) as typeof Api.Sound;
+export const Font = ((value = 0 as Api.Font, options) => spec("Font", value, options)) as typeof Api.Font;
+export const Style = ((value = 0 as Api.Style, options) => spec("Style", value, options)) as typeof Api.Style;
+export const Look = ((value = 0 as Api.Look, options) => spec("Look", value, options)) as typeof Api.Look;
+export const Shader = ((value = 0 as Api.Shader, options) => spec("Shader", value, options)) as typeof Api.Shader;
+export const Rig = ((value = 0 as Api.Rig, options) => spec("Rig", value, options)) as typeof Api.Rig;
 export const SkeletonAsset = ((value = 0 as Api.SkeletonAsset, options) => spec("SkeletonAsset", value, options)) as typeof Api.SkeletonAsset;
 export const ClipAsset = ((value = 0 as Api.ClipAsset, options) => spec("ClipAsset", value, options)) as typeof Api.ClipAsset;
 export const GraphAsset = ((value = 0 as Api.GraphAsset, options) => spec("GraphAsset", value, options)) as typeof Api.GraphAsset;
@@ -99,6 +105,10 @@ export const BlendshapeSource = ((value = "component" as Api.BlendshapeSource, o
 export const IkSolver = ((value = "twoBone" as Api.IkSolver, options) => spec("IkSolver", value, options)) as typeof Api.IkSolver;
 export const IkSpace = ((value = "world" as Api.IkSpace, options) => spec("IkSpace", value, options)) as typeof Api.IkSpace;
 export const AudioBus = ((value = "master" as Api.AudioBus, options) => spec("AudioBus", value, options)) as typeof Api.AudioBus;
+export const PanningModel = ((value = "equalpower" as Api.PanningModel, options) => spec("PanningModel", value, options)) as typeof Api.PanningModel;
+export const AudioResampler = ((value = "linear" as Api.AudioResampler, options) => spec("AudioResampler", value, options)) as typeof Api.AudioResampler;
+export const SpringSpace = ((value = "world" as Api.SpringSpace, options) => spec("SpringSpace", value, options)) as typeof Api.SpringSpace;
+export const SpringColliderShape = ((value = "sphere" as Api.SpringColliderShape, options) => spec("SpringColliderShape", value, options)) as typeof Api.SpringColliderShape;
 export const Navigation = ((value = 0 as Api.Navigation, options) => spec("Navigation", value, options)) as typeof Api.Navigation;
 export const Behaviour = ((value = 0 as Api.Behaviour, options) => spec("Behaviour", value, options)) as typeof Api.Behaviour;
 
@@ -147,6 +157,7 @@ export const SOUND_STOPPED: typeof Api.SOUND_STOPPED = 1;
 export const SOUND_REMOVED: typeof Api.SOUND_REMOVED = 2;
 export const SOUND_REPLACED: typeof Api.SOUND_REPLACED = 3;
 export const SOUND_CULLED: typeof Api.SOUND_CULLED = 4;
+export const SOUND_RETRIGGERED: typeof Api.SOUND_RETRIGGERED = 5;
 export const NAV_IDLE: typeof Api.NAV_IDLE = 0;
 export const NAV_MOVING: typeof Api.NAV_MOVING = 1;
 export const NAV_ARRIVED: typeof Api.NAV_ARRIVED = 2;

package/src/node/device.ts

@@ -514,7 +514,7 @@ async function connectAndroid(wanted: string | null, port: number, scheme: strin
 
 const ELEMENT = "element-6066-11e4-a52e-4f735466cecf";
 const IPHONE_FIX =
-  "on the iPhone turn on Settings > Apps > Safari > Advanced > Web Inspector and Remote Automation; on the Mac run `safaridriver --enable` once and pair the phone in Xcode (Window > Devices and Simulators)";
+  "on the iPhone turn on Settings > Apps > Safari > Advanced > Web Inspector and Remote Automation; on the Mac turn on Safari > Develop > Allow Remote Automation, run `safaridriver --enable` once and pair the phone in Xcode (Window > Devices and Simulators)";
 
 /** Safari on an iPhone over WebDriver (safaridriver). */
 async function connectIphone(udid: string | null): Promise<Driver> {
@@ -568,7 +568,10 @@ async function connectIphone(udid: string | null): Promise<Driver> {
     );
     session = s.sessionId;
   } catch (e) {
-    return refuse(`safaridriver could not open Safari on the iPhone (${(e as Error).message.split("\n")[0]}): ${IPHONE_FIX}`);
+    // The whole answer: safaridriver names the device it found and why it
+    // could not use it on the lines after the first.
+    const why = (e as Error).message.split("\n").map((l) => l.trim()).filter(Boolean).join("; ");
+    return refuse(`safaridriver could not open Safari on the iPhone (${why}): ${IPHONE_FIX}`);
   }
   await call("POST", `/session/${session}/timeouts`, { script: 120_000, pageLoad: 120_000 });
   return {

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/runtime.ts

@@ -1470,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