ugly-game 0.7.4 → 0.7.6

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,17 @@ 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).
     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)
-        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.d.ts

@@ -19,6 +19,10 @@ export interface CoopOpts {
     onNeedSnap?: (from: string) => void;
     onSnapReady?: (from: string) => void;
     onLate?: (n: number) => void;
+    /** Whether co-op is active from construction (default true). Pass false for OPT-IN co-op (no ambient socket): the
+     *  lockstep driver + transport are wired but `ctl.coop` stays false — the game flips it on join/leave, and until
+     *  then the sim free-runs solo. */
+    autoStart?: boolean;
 }
 export interface SimHostOpts<State, Input> {
     layout: Layout<State>;

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) => {
@@ -80,7 +80,7 @@ export function createSimHost(opts) {
                 onSnapReady: opts.coop.onSnapReady ?? (() => undefined),
             },
         });
-        ctl.coop = true;
+        ctl.coop = opts.coop.autoStart ?? true; // opt-in co-op leaves this false until the game joins a session
     }
     // ── Per-frame driver ─────────────────────────────────────────
     // Co-op bookkeeping runs on the MAIN thread from the shared state, so the local sample and the value sent to
@@ -91,7 +91,7 @@ export function createSimHost(opts) {
     let acc = 0;
     const hashEvery = opts.coop?.hashEvery ?? 600;
     const drive = (nowMs, doStep) => {
-        if (lockstep) {
+        if (lockstep && ctl.coop) {
             const tk = worker ? ctl.tick : opts.tickOf(state);
             if (tk % hashEvery === 0 && !sampled.has(tk))
                 sampled.set(tk, probe());
@@ -142,8 +142,8 @@ export function createSimHost(opts) {
         },
         available: useWorker,
         send(input) {
-            if (lockstep)
-                lockstep.send(input); // stamped + forwarded; comes back via onCommand
+            if (lockstep && ctl.coop)
+                lockstep.send(input); // co-op: stamped + forwarded; comes back via onCommand
             else
                 enqueue({ c: input, at: opts.tickOf(state) + 1 }); // solo: apply next tick
         },

package/dist/loop/simHost.worker.js

@@ -10,7 +10,6 @@ export function runSimWorker(cfg) {
     let state = null;
     let ctl = null;
     let acc = 0;
-    let coop = false;
     const clock = { now: () => performance.now() };
     const lastRef = { t: 0 };
     let fps = 60;
@@ -23,7 +22,9 @@ export function runSimWorker(cfg) {
             const onLate = (n) => {
                 c.addLate(n);
             };
-            if (coop) {
+            // Co-op mode is read from the control block EVERY loop (not fixed at init): a game can join/leave a session
+            // at runtime (co-op is opt-in — no ambient socket), toggling ctl.coop from the main thread.
+            if (ctl.coop) {
                 coopStepBatch({
                     sim: cfg.sim,
                     state,
@@ -84,7 +85,8 @@ export function runSimWorker(cfg) {
             state = layout.attach(init.dataBuf);
             ctl = createControlView(init.ctlBuf, init.scalars ?? []);
             fps = init.simFps ?? 60;
-            coop = !!init.coop;
+            // ctl.coop is set by the main thread (createSimHost) before init and read live each loop — the worker doesn't
+            // latch it here (co-op can start/stop mid-session).
             ctl.running = true;
             lastRef.t = clock.now();
             loop();

package/package.json

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