ugly-game 0.7.5 → 0.7.7

package/dist/loop/simCore.js

@@ -8,11 +8,16 @@ export function soloStepBatch(opts, acc) {
     const maxCatch = opts.maxCatchUpFrames ?? 6;
     const now = opts.clock.now();
     const elapsed = Math.max(0, (now - opts.lastRef.t) / 1000);
-    opts.lastRef.t = now;
-    let a = Math.min(acc + elapsed, maxCatch * T);
-    const frames = Math.floor(a / T);
-    a -= frames * T;
-    opts.ctl.targetTick = opts.tickOf(opts.state) + frames;
+    opts.lastRef.t = now; // keep the clock base current even while paused, so resuming doesn't spend a huge catch-up
+    let a = acc;
+    // Only derive a wall-clock target while PLAYING; paused leaves targetTick where it was (coopStepBatch won't chase
+    // past it) so a paused solo world holds still. STEP_BUDGET still drains inside coopStepBatch.
+    if (opts.ctl.playing) {
+        a = Math.min(acc + elapsed, maxCatch * T);
+        const frames = Math.floor(a / T);
+        a -= frames * T;
+        opts.ctl.targetTick = opts.tickOf(opts.state) + frames;
+    }
     const stepped = coopStepBatch({
         sim: opts.sim,
         state: opts.state,
@@ -53,14 +58,18 @@ export function coopStepBatch(opts) {
         opts.sim.tick(opts.state, due.map((d) => d.c));
         stepped++;
     };
-    // STEP_BUDGET burst first (forced, deterministic — independent of the target).
+    // STEP_BUDGET burst first (forced, deterministic — independent of the target AND of play/pause, so a harness can
+    // advance a paused world). The FULL budget runs (not maxCatch-bounded): it's a caller-chosen finite count, so a
+    // replay/harness step(N) advances exactly N — dropping the remainder would make deterministic advance lossy.
     let budget = opts.ctl.takeStepBudget();
-    while (budget-- > 0 && stepped < maxCatch)
-        stepOnce();
-    // Then chase the target.
-    const target = opts.ctl.targetTick;
-    while (opts.tickOf(opts.state) < target && stepped < maxCatch)
+    while (budget-- > 0)
         stepOnce();
+    // Then chase the target — but only while PLAYING. Pausing freezes the sim without touching the queue or budget.
+    if (opts.ctl.playing) {
+        const target = opts.ctl.targetTick;
+        while (opts.tickOf(opts.state) < target && stepped < maxCatch)
+            stepOnce();
+    }
     return stepped;
 }
 export function fixedStepBatch(opts, acc) {

package/dist/loop/simHost.js

@@ -23,6 +23,7 @@ export function createSimHost(opts) {
     const probe = () => opts.sim.probeHash ? opts.sim.probeHash(state) : opts.sim.hash(state);
     const sampled = new Map(); // our probe hash per grid tick (for divergence compare)
     let lastHash = opts.sim.hash(state);
+    ctl.playing = true; // games start playing; the sim honors ctl.playing (pause freezes stepping, STEP_BUDGET aside)
     // ── Worker path ──────────────────────────────────────────────
     // request()/reply round-trip: the game's worker `onMessage` answers a diagnostics request by posting a reply that
     // echoes `rid`; we resolve the matching pending Promise here. Keyed on `rid` alone, so it's oblivious to payload.
@@ -56,7 +57,6 @@ export function createSimHost(opts) {
             coop: !!opts.coop,
             ...opts.initParams,
         });
-        ctl.playing = true;
     }
     // ── Lockstep driver (co-op) — lives on the main thread; feeds commands to the queue (fallback) or worker. ──
     const enqueue = (s) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ugly-game",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "type": "module",
   "exports": {
     ".": {