dotframe 0.1.8 → 0.1.9

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.1.9
+
+The rest of round 7, which missed the 0.1.8 merge.
+
+- `dotframe/src/probe`: `createProbe()` publishes `globalThis.__dotframe` for `play --online`, and `createMasher(seed, random)` gives scripted inputs, so games do not write either by hand. Templates use them.
+- `play --online --seeds a,b` picks each peer's mash seed.
+- `doctor` fails on the template's placeholder iOS bundle id (`com.example.*`), which Apple will not register.
+
 ## 0.1.8
 
 From dogfood round 7 (Craft Ones on 0.1.7).

package/cli/commands/doctor.ts

@@ -47,6 +47,9 @@ export async function doctor(ctx: Ctx, fix: boolean, docker = false): Promise<vo
       }
     }
     for (const [name, t] of Object.entries(config.targets)) {
+      if (t.native?.platform === "ios" && t.native.bundleId.startsWith("com.example.")) {
+        checks.push({ check: `ios:${name}:bundleId`, ok: false, detail: `bundle id ${t.native.bundleId} is the template placeholder; Apple will not register it`, fix: `dotframe config set targets.${name}.native.bundleId '"<reverse domain you own>.<game>"'`, skill: "ios" });
+      }
       if (t.native?.platform === "ios" && t.native.team === "YOUR_TEAM_ID") {
         checks.push({ check: `ios:${name}`, ok: false, detail: "the iOS team is still the template placeholder", fix: `dotframe config set targets.${name}.native.team '"<Apple team id>"'`, skill: "ios" });
       }

package/cli/commands/online.ts

@@ -13,13 +13,17 @@ interface Probe {
 // Two browsers play one online match through a local relay, each with a scripted masher, and their checksums at
 // every 30th confirmed frame must agree. The game's web entry honors ?room=, ?relay= and ?mash=, and publishes
 // globalThis.__dotframe = { frame, confirmed, status, sums } (the templates do; see the netplay skill).
-export async function playOnline(ctx: Ctx, room: string | undefined, args: { frames?: string; out?: string }): Promise<void> {
+export async function playOnline(ctx: Ctx, room: string | undefined, args: { frames?: string; out?: string; seeds?: string }): Promise<void> {
   const skill = "netplay";
   const config = loadConfig();
   const t = target(config, "web");
   if (!t.out) throw new CliError("NO_OUT", "the web target needs an out dir", "", "export-web");
   if (!which("agent-browser")) throw new CliError("TOOL_MISSING", "agent-browser not found (play drives two browsers)", "npm i -g agent-browser && agent-browser install", skill);
   const frames = num("frames", args.frames, 600, 60);
+  // One mash seed per peer; different seeds make the peers press different inputs, which is what exercises rollback.
+  const seedParts = (args.seeds ?? "1,2").split(",");
+  if (seedParts.length !== 2) throw new CliError("BAD_ARG", `--seeds needs two comma-separated seeds, got "${args.seeds}"`, "--seeds 7,42", skill);
+  const seeds = seedParts.map((part: string): number => num("seeds", part.trim(), 1));
   const name = room ?? `play-${Date.now().toString(36)}`;
   const outDir = resolve(process.cwd(), args.out ?? ".dotframe/play");
   await runSteps({ ...ctx, json: true }, config.root, t.steps ?? [], "export-web");
@@ -46,7 +50,7 @@ export async function playOnline(ctx: Ctx, room: string | undefined, args: { fra
   };
   try {
     for (const [i, session] of sessions.entries()) {
-      const url = `http://localhost:${server.port}/?room=${encodeURIComponent(name)}&relay=${encodeURIComponent(`ws://localhost:${relay.port}`)}&mash=${i + 1}`;
+      const url = `http://localhost:${server.port}/?room=${encodeURIComponent(name)}&relay=${encodeURIComponent(`ws://localhost:${relay.port}`)}&mash=${seeds[i]}`;
       const opened = await ab(session, "open", url);
       if (opened.code !== 0) throw new CliError("BROWSER_FAILED", opened.tail, "agent-browser install", skill);
     }
@@ -78,7 +82,7 @@ export async function playOnline(ctx: Ctx, room: string | undefined, args: { fra
       if (shot.code !== 0 || !existsSync(shots[i])) throw new CliError("BROWSER_FAILED", `screenshot of peer ${i} failed: ${shot.tail}`, "", skill);
     }
     const ok = mismatch === undefined && compared.length > 0;
-    print(ctx, { ok, room: name, frames: Math.min(a.confirmed, b.confirmed), compared: compared.length, firstMismatch: mismatch ?? null, seconds: Math.round((Date.now() - started) / 1000), screenshots: shots }, (): string =>
+    print(ctx, { ok, room: name, seeds, frames: Math.min(a.confirmed, b.confirmed), compared: compared.length, firstMismatch: mismatch ?? null, seconds: Math.round((Date.now() - started) / 1000), screenshots: shots }, (): string =>
       [
         ok ? `in sync: ${compared.length} checksums compared over ${Math.min(a.confirmed, b.confirmed)} confirmed frames` : mismatch !== undefined ? `DESYNC at frame ${mismatch}` : "no checksums to compare",
         `screenshots: ${shots.join(", ")} (open them and look)`,

package/cli/main.ts

@@ -21,7 +21,7 @@ Play (headless, deterministic)
   sim      [--inputs f.jsonl | --mash <seed>] [--frames 600] [--seed 1] [--options json] [--every n]
   snap     --frame <n> [--out frame.png] [--inputs f | --mash <seed>] [--seed 1] [--options json]
   replay   record <file> | verify <file...>
-  play     --online [room] [--frames 600]   two browsers, local relay, scripted match
+  play     --online [room] [--frames 600] [--seeds 1,2]   two browsers, local relay, scripted match
   desync   [--latency 100ms] [--jitter 0ms] [--delay 2] [--frames 1800] [--renders 3]
 
 Build and ship
@@ -74,11 +74,13 @@ Compares checksums every frame and the full inspect() state every --every frames
 Warns when rollbacks exceed the sim's rollbackWindow.
 
   dotframe desync --latency 474ms --jitter 40ms --mash 42 --json`,
-  play: `dotframe play --online [room] [--frames 600] [--out .dotframe/play] [--json]
+  play: `dotframe play --online [room] [--frames 600] [--seeds 1,2] [--out .dotframe/play] [--json]
 
-Builds the web target, starts a local relay, and opens two agent-browser sessions on ?room=<room>&relay=...&mash=1|2.
+Builds the web target, starts a local relay, and opens two agent-browser sessions on ?room=<room>&relay=...&mash=<seed>
+(one seed per peer from --seeds).
 Waits until both confirm --frames frames, compares their checksums every 30 frames, and saves a screenshot of each.
-The web entry must honor ?room=, ?relay=, ?mash= and publish globalThis.__dotframe (templates do).`,
+The web entry must honor ?room=, ?relay=, ?mash= and publish globalThis.__dotframe: createProbe() and createMasher()
+from dotframe/src/probe do both (templates show it).`,
   build: `dotframe build <target> [--release] [--dry-run] [--json]
 
 Runs targets.<target>.steps from dotframe.json, or for a native target ({"native": {"platform": "macos",
@@ -168,6 +170,7 @@ const { values, positionals } = parseArgs({
     "through-over": { type: "boolean" },
     docker: { type: "boolean" },
     online: { type: "boolean" },
+    seeds: { type: "string" },
     provider: { type: "string" },
     compose: { type: "string" },
   },
@@ -181,7 +184,7 @@ try {
   if (values.version) console.log(pkg.version);
   else if (command && values.help && COMMAND_HELP[command]) console.log(COMMAND_HELP[command]);
   else if (!command || values.help) console.log(HELP);
-  else if (command === "play" && values.online === true) await playOnline(ctx, rest[0], { frames: v.frames, out: v.out });
+  else if (command === "play" && values.online === true) await playOnline(ctx, rest[0], { frames: v.frames, out: v.out, seeds: v.seeds });
   else if (command === "sim") await sim(ctx, v);
   else if (command === "snap") await snap(ctx, v);
   else if (command === "replay" && rest[0] === "record") await record(ctx, rest[1], v);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotframe",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "TS-first game engine and agent-first CLI: one codebase for web, Discord, iOS and native binaries",
   "license": "MIT",
   "type": "module",

package/skill-data/netplay/SKILL.md

@@ -15,7 +15,7 @@ dotframe relay serve                  # local relay on :8787, same protocol as p
 dotframe play --online --frames 900   # two browsers, scripted match, checksums compared, screenshots saved
 ```
 
-`play --online` needs the web entry to honor `?room=`, `?relay=` and `?mash=<seed>` and to publish `globalThis.__dotframe = { frame, confirmed, status, sums }` (sums: checksum per 30th confirmed frame). The templates show it.
+`play --online` needs the web entry to honor `?room=`, `?relay=` and `?mash=<seed>` and to publish `globalThis.__dotframe = { frame, confirmed, status, sums }` (sums: checksum per 30th confirmed frame). `dotframe/src/probe` does both: `createProbe()` publishes it (call `probe.update(rollback, link.status())` each step, or `probe.update(null, "local", frame)` offline), and `createMasher(seed, randomInput)` returns a function giving the scripted input for each step. `--seeds 7,42` picks each peer's seed. The templates show the wiring.
 
 dotframe online play is rollback netcode: each peer predicts the remote input (repeat the last one), simulates ahead, and when the real input arrives and differs, restores a snapshot and resimulates. It only works if every peer computes bit-identical state from the same inputs.
 

package/src/probe.ts

@@ -0,0 +1,53 @@
+// The state `dotframe play --online` reads from each browser: frame, confirmed frame, link status, and this peer's
+// checksum at every 30th confirmed frame. Call update() once per fixed step; publish() exposes it as
+// globalThis.__dotframe.
+import type { Rollback } from "./netplay";
+
+export interface ProbeState {
+  frame: number;
+  confirmed: number;
+  status: string;
+  sums: Record<number, number>;
+}
+
+export interface Probe {
+  state: ProbeState;
+  // Online: pass the rollback and the link status. Local: pass null and the frame just simulated.
+  update: (rollback: Rollback | null, status: string, localFrame?: number) => void;
+}
+
+const EVERY = 30;
+
+export function createProbe(): Probe {
+  const state: ProbeState = { frame: 0, confirmed: 0, status: "local", sums: {} };
+  (globalThis as { __dotframe?: ProbeState }).__dotframe = state;
+  return {
+    state,
+    update: (rollback: Rollback | null, status: string, localFrame?: number): void => {
+      state.status = status;
+      if (!rollback) {
+        if (localFrame !== undefined) state.frame = localFrame;
+        return;
+      }
+      state.frame = rollback.stats().frame;
+      state.confirmed = rollback.confirmedFrame();
+      for (let f = EVERY; f < state.confirmed; f += EVERY) if (state.sums[f] === undefined) state.sums[f] = rollback.sumAt(f) ?? 0;
+    },
+  };
+}
+
+// A scripted masher for tests: a new random input every 6 frames from a seed, like the CLI's --mash.
+export function createMasher(seed: number, random: (next: () => number) => number): () => number {
+  let s = seed >>> 0;
+  const next = (): number => {
+    s = (Math.imul(s, 1103515245) + 12345) >>> 0;
+    return s / 4294967296;
+  };
+  let frame = 0;
+  let input = 0;
+  return (): number => {
+    if (frame % 6 === 0) input = random(next);
+    frame += 1;
+    return input;
+  };
+}

package/templates/_base/src/setup.ts

@@ -6,6 +6,7 @@ import type { Frame, RenderGpu } from "dotframe/src/gpu";
 import type { Input } from "dotframe/src/input";
 import { Key, MouseButton } from "dotframe/src/input";
 import { createRollback, type RelayLink, type Rollback } from "dotframe/src/netplay";
+import { createMasher, createProbe } from "dotframe/src/probe";
 import { checksum, createGame, type Game, keyInput, PLAYERS, POINTER_BIT, randomInput, render, restore, snapshot, step, WINDOW } from "./game";
 
 export interface SetupOptions {
@@ -15,13 +16,6 @@ export interface SetupOptions {
   mash: number | null;
 }
 
-// What `dotframe play --online` reads from each browser.
-interface Probe {
-  frame: number;
-  confirmed: number;
-  status: string;
-  sums: Record<number, number>;
-}
 
 const STEP = 1 / 60;
 // A full charge takes one second of holding.
@@ -47,15 +41,10 @@ export function createSetup(options: SetupOptions): (platform: SetupPlatform) =>
     // Online peers must start from the same state, so the seed is fixed there.
     const game: Game = createGame(options.link ? 1 : Math.floor(Math.random() * 1e9));
     let rollback: Rollback | null = null;
-    let mashState = options.mash ?? 0;
-    const nextRandom = (): number => {
-      mashState = (Math.imul(mashState, 1103515245) + 12345) >>> 0;
-      return mashState / 4294967296;
-    };
-    let mashed = 0;
-    let mashInput = 0;
-    const probe: Probe = { frame: 0, confirmed: 0, status: options.link ? "connecting" : "local", sums: {} };
-    (globalThis as { __dotframe?: Probe }).__dotframe = probe;
+    const mash = options.mash === null ? null : createMasher(options.mash, randomInput);
+    // What dotframe play --online reads from each browser.
+    const probe = createProbe();
+    let localFrame = 0;
     let simulated = -1;
     // Hold to charge, release to act: the pattern most mouse and touch games need.
     let charge = 0;
@@ -77,15 +66,9 @@ export function createSetup(options: SetupOptions): (platform: SetupPlatform) =>
         wasDown = down;
         const keys = [keyInput(input, [Key.A, Key.D, Key.W, Key.J]), keyInput(input, [Key.Left, Key.Right, Key.Up, Key.L])];
         if (released) keys[0] = keys[0] | POINTER_BIT;
-        if (options.mash !== null) {
-          // A new random input every 6 frames, like a mashing player.
-          if (mashed % 6 === 0) mashInput = randomInput(nextRandom);
-          keys[0] = mashInput;
-          mashed += 1;
-        }
+        if (mash) keys[0] = mash();
         const link = options.link;
         if (link) {
-          probe.status = link.status();
           if (!rollback && link.status() === "paired") {
             rollback = createRollback({
               sim: {
@@ -102,15 +85,12 @@ export function createSetup(options: SetupOptions): (platform: SetupPlatform) =>
             });
           }
           // Online, each browser controls its own player with player 1's keys.
-          if (rollback) {
-            rollback.tick(keys[0]);
-            probe.frame = rollback.stats().frame;
-            probe.confirmed = rollback.confirmedFrame();
-            for (let f = 30; f < probe.confirmed; f += 30) if (probe.sums[f] === undefined) probe.sums[f] = rollback.sumAt(f) ?? 0;
-          }
+          if (rollback) rollback.tick(keys[0]);
+          probe.update(rollback, link.status());
         } else {
           step(game, keys.slice(0, PLAYERS));
-          probe.frame += 1;
+          localFrame += 1;
+          probe.update(null, "local", localFrame);
         }
         simulated += STEP;
       }