dotframe 0.1.7 → 0.1.9

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # 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).
+
+- `doctor` sim:math skips files marked `// dotframe-allow-math-file`, for render-only files the sim reaches because it builds the renderer.
+- `deploy init` pins images: bun from `packageManager` (game or repo root, else the local bun) and the relay's dotframe from the version installed in the game.
+- The vendor fix (doctor and native builds) names `DOTFRAME_VENDOR` for reusing an existing vendor dir.
+
 ## 0.1.7
 
 From dogfood rounds 5 and 6 (Craft Ones on iOS, online, and on the VPS).

package/cli/commands/docker.ts

@@ -14,14 +14,38 @@ async function gitRoot(ctx: Ctx, root: string): Promise<string> {
   return r.output.trim();
 }
 
+interface Versions {
+  bun: string;
+  dotframe: string;
+}
+
+// Pinned versions, so an image built tomorrow is the image built today: bun from packageManager (the game's
+// package.json, then the repo root's), else the bun running this CLI; dotframe as installed in the game.
+function versions(gameRoot: string, repo: string): Versions {
+  let bun = Bun.version;
+  for (const dir of [gameRoot, repo]) {
+    const file = join(dir, "package.json");
+    if (!existsSync(file)) continue;
+    const manager = (JSON.parse(readFileSync(file, "utf8")) as { packageManager?: string }).packageManager ?? "";
+    const match = manager.match(/^bun@(\d+\.\d+\.\d+)/);
+    if (match) {
+      bun = match[1];
+      break;
+    }
+  }
+  const installed = join(gameRoot, "node_modules", "dotframe", "package.json");
+  const dotframe = existsSync(installed) ? (JSON.parse(readFileSync(installed, "utf8")) as { version: string }).version : pkg.version;
+  return { bun, dotframe };
+}
+
 // game: the game's path inside the repo ("" at the root); context: the repo root, relative to deploy/.
-function files(config: Config, game: string, out: string, context: string): Record<string, string> {
+function files(config: Config, game: string, out: string, context: string, v: Versions): Record<string, string> {
   const requires = (config.requires ?? []).filter((t: string): boolean => t !== "bun");
   const apt = requires.length > 0 ? `RUN apt-get update && apt-get install -y --no-install-recommends ${requires.join(" ")} && rm -rf /var/lib/apt/lists/*\n` : "";
   const at = game === "" ? "." : game;
   return {
     "Dockerfile.web": `# Static web build of ${config.name}, served by nginx. Generated by dotframe deploy init; edit freely.
-FROM oven/bun:1 AS build
+FROM oven/bun:${v.bun} AS build
 ${apt}WORKDIR /app
 COPY . .
 RUN cd ${at} && bun install --frozen-lockfile && bun node_modules/dotframe/cli/main.ts build web
@@ -32,9 +56,10 @@ COPY --from=build ${join("/app", at, out)} /usr/share/nginx/html
 EXPOSE 80
 `,
     "Dockerfile.relay": `# Netplay relay for ${config.name}: dotframe relay serve. Generated by dotframe deploy init.
-FROM oven/bun:1-alpine
+FROM oven/bun:${v.bun}-alpine
 WORKDIR /app
-RUN bun add dotframe@${pkg.version}
+# The dotframe version the game has installed; bump it together with the game's.
+RUN bun add dotframe@${v.dotframe}
 ENV PORT=8787
 EXPOSE 8787
 CMD ["bun", "node_modules/dotframe/cli/main.ts", "relay", "serve"]
@@ -86,7 +111,7 @@ export async function deployInit(ctx: Ctx, name: string | undefined, provider: s
   const repo = await gitRoot(ctx, config.root);
   const game = relative(repo, config.root);
   // compose.yaml sits in <game>/deploy; the web build context is the repo root, so workspace code is visible.
-  const generated = files(config, game, t.out, relative(join(config.root, DIR), repo) || ".");
+  const generated = files(config, game, t.out, relative(join(config.root, DIR), repo) || ".", versions(config.root, repo));
   const dir = join(config.root, DIR);
   const written = Object.keys(generated).map((f: string): string => join(DIR, f));
   const existing = written.filter((f: string): boolean => existsSync(join(config.root, f)));

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" });
       }
@@ -147,8 +150,9 @@ async function renderCheck(sim: Sim, root: string): Promise<Check> {
 }
 
 // Math.sin and friends differ in the last bits between engines and OSes, so simulation code that calls them drifts
-// between netplay peers and breaks replays on another machine. Render code may use them; mark a line with
-// `dotframe-allow-math` to silence it.
+// between netplay peers and breaks replays on another machine. Render code may use them: mark a line with
+// `dotframe-allow-math`, or a whole render-only file with `// dotframe-allow-math-file`. (The sim module builds the
+// renderer for desync's purity check, so render files are reachable and a static scan cannot tell them apart.)
 const NONDETERMINISTIC = /\bMath\.(sin|cos|tan|asin|acos|atan|atan2|sinh|cosh|tanh|asinh|acosh|atanh|exp|expm1|log|log1p|log2|log10|pow|cbrt|hypot)\b|[\w)\]]\s*\*\*\s*[\w(]/;
 
 // The engine's own files (draw2d's arcs, raster2d) are render code, however the game imports them: a vendored
@@ -173,7 +177,9 @@ function mathCheck(simFile: string): Check {
   const engine = new Map<string, boolean>();
   for (const file of importGraph(simFile).files) {
     if (!/\.tsx?$/.test(file) || file.includes(`${sep}node_modules${sep}`) || engineFile(file, engine)) continue;
-    readFileSync(file, "utf8")
+    const text = readFileSync(file, "utf8");
+    if (text.includes("dotframe-allow-math-file")) continue;
+    text
       .split("\n")
       .forEach((line: string, i: number): void => {
         const code = line.replace(/\/\/.*$/, "");
@@ -187,6 +193,6 @@ function mathCheck(simFile: string): Check {
     ok: false,
     warn: true,
     detail: `${hits.length} platform-dependent math call(s) in code the sim reaches: ${shown}`,
-    fix: "use dotframe/src/detmath (dsin, dcos, datan2, dexp, dpow, ...) in simulation code; mark render-only lines with // dotframe-allow-math",
+    fix: "use dotframe/src/detmath (dsin, dcos, datan2, dexp, dpow, ...) in simulation code; mark render-only lines with // dotframe-allow-math, or a render-only file with // dotframe-allow-math-file",
   };
 }

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/cli/native.ts

@@ -46,7 +46,7 @@ export function sdlLibrary(platform: NativePlatform): string {
 }
 
 export function vendorFix(platform: NativePlatform): string {
-  return `dotframe vendor ${platform}`;
+  return `dotframe vendor ${platform} (builds into ~/.dotframe/vendor), or point DOTFRAME_VENDOR at an existing vendor dir such as a dotframe checkout's vendor/`;
 }
 
 const SPECIFIER = /(?:from\s+|import\s*\(\s*|import\s+)(["'])([^"']+)\1/g;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotframe",
-  "version": "0.1.7",
+  "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/export-web/SKILL.md

@@ -29,6 +29,7 @@ dotframe config set targets.web.deploy.compose '"<compose id>"'   # vps compose
 dotframe deploy web --dry-run && dotframe deploy web --yes
 ```
 
+- Images are pinned: bun from `packageManager` (game or repo root, else the local bun) and the relay's dotframe from the version installed in the game. Rerun `deploy init --yes` after bumping either.
 - The web image installs the tools in `requires` (dotframe.json, for example `["ffmpeg"]`) and builds with dotframe; the relay image runs `dotframe relay serve`. The build context is the repo root, so monorepo ports see workspace code.
 - In Dokploy, route the domain's `/` to service `web` (port 80) and `/relay` to service `relay` (port 8787). For Discord, map `/` and `/relay` to that host.
 - Dokploy builds the pushed branch, not your working tree: deploy warns about unpushed or uncommitted work. On failure it returns the build log (through `vps compose logs`).

package/skill-data/ios/SKILL.md

@@ -6,6 +6,7 @@ description: Build and install the iOS target of a dotframe game. Use when build
 
 ```sh
 dotframe vendor ios                  # once per machine: SDL3 (Xcode generator) and wgpu-native for iOS
+# or reuse an existing vendor (a dotframe checkout's vendor/): export DOTFRAME_VENDOR=<path>
 dotframe doctor                      # vendor:ios, ios-runtime (scriptc pack matching the compiler), team placeholder
 dotframe build ios --json            # dist/ios/<Scheme>.app
 dotframe device install ios --dry-run

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.
 
@@ -43,7 +43,7 @@ Run several seeds and a high latency (474 ms is what a transatlantic relay measu
 
 ## Rules
 
-- Simulation code uses `dotframe/src/detmath` (dsin, dcos, datan2, dexp, dlog, dpow, ...), never `Math.sin` and friends or `**`: those differ in the last bits between engines and operating systems, so peers and replays drift (Craft Ones' replays diverged between macOS and Linux at frame 120). `dotframe doctor` warns about them (`sim:math`); mark render-only lines with `// dotframe-allow-math`. A replay passing on one machine proves nothing about another: run CI on a second OS.
+- Simulation code uses `dotframe/src/detmath` (dsin, dcos, datan2, dexp, dlog, dpow, ...), never `Math.sin` and friends or `**`: those differ in the last bits between engines and operating systems, so peers and replays drift (Craft Ones' replays diverged between macOS and Linux at frame 120). `dotframe doctor` warns about them (`sim:math`); mark render-only lines with `// dotframe-allow-math`, or a whole render-only file with `// dotframe-allow-math-file` (the sim builds the renderer for desync, so render files count as reachable). A replay passing on one machine proves nothing about another: run CI on a second OS.
 - `desync` reports `restoreMs` early vs late; it warns when late restores cost more than twice the early ones (a heuristic for restore that replays from an earlier frame, which passes desync but stalls real rollbacks late in a match).
 - Build checksums from numbers in a fixed order, never from `JSON.stringify`: native builds can order keys differently from JavaScript, so a web peer and a native peer would report false desyncs.
 

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;
       }