@energy8platform/game-engine 0.43.3 → 0.43.5

package/dist/host.esm.js

@@ -2852,6 +2852,8 @@ async function createSlotGame(opts) {
         let playErrorOpen = false;
         let stopAutoplay = () => { }; // wired to the autoplay loop once it's created (below)
         let haltAutoplay = () => { }; // ditto — stops the run but KEEPS its counter
+        let holdAutoplay = () => { }; // ditto — pauses the run, owing it a resume
+        let releaseAutoplay = () => { }; // ditto — gives back a run that hold() paused
         const reload = () => {
             try {
                 window.location.reload();
@@ -2895,6 +2897,9 @@ async function createSlotGame(opts) {
         const { createConnectionRecovery } = await Promise.resolve().then(function () { return connectionRecovery; });
         const connection = createConnectionRecovery({
             haltAutoplay: () => haltAutoplay(),
+            // A reconnect ends the run for good (Artube): the counter the halt preserved while the link
+            // was down is cleared here, and the disc goes back to a plain SPIN.
+            resetAutoplay: () => stopAutoplay(),
             showReconnecting: () => shell.openModal({
                 availableClose: false,
                 title: shell.t('Reconnecting…'),
@@ -2936,8 +2941,10 @@ async function createSlotGame(opts) {
         game.scenes.root.eventMode = 'static';
         game.scenes.root.on('pointertap', () => skip.tap(performance.now()));
         // Full auto-pause: on tab blur, freeze the ticker (stops tweens/onUpdate/in-flight onSpin),
-        // duck music to silence, hold autoplay, and notify the scene. On focus, reverse it all.
-        // `stopAutoplay` is reassigned in the base-mode block below — the closure reads it live.
+        // duck music to silence, hold autoplay, and notify the scene. On focus, reverse it all —
+        // autoplay included: a tab switch is not the player pressing STOP.
+        // `holdAutoplay`/`releaseAutoplay` are reassigned in the base-mode block below — the closures
+        // read them live.
         const { createPauseController } = await Promise.resolve().then(function () { return pauseController; });
         createPauseController({
             isHidden: () => typeof document !== 'undefined' && document.hidden,
@@ -2950,12 +2957,19 @@ async function createSlotGame(opts) {
             onHidden: () => {
                 game.app.ticker.stop(); // freezes tweens, onUpdate, in-flight onSpin animation
                 game.audio.duckMusic(0); // silence music (ducked to 0; restored on resume)
-                stopAutoplay(); // hold autoplay — don't start the next auto-round
+                // Hold, don't stop. No auto-round may start while the tab is hidden (the ticker is frozen,
+                // so an animation would never finish, and a play fired here spends the player's money out
+                // of sight) — but the run is owed back: the lab reads "the autoplay sequence stops when the
+                // Stop button is pressed" as ONLY the Stop button, and stopAutoplay() here ended the run and
+                // zeroed its counter on every alt-tab. `hold()` forgets itself if anything else ends the run
+                // meanwhile (a lost connection, a failed round), so those don't come back on the way in.
+                holdAutoplay();
                 gameScene()?.onPause?.();
             },
             onVisible: () => {
                 game.app.ticker.start();
                 game.audio.unduckMusic();
+                releaseAutoplay(); // the run the blur paused picks up where it left off
                 gameScene()?.onResume?.();
             },
         });
@@ -3172,6 +3186,8 @@ async function createSlotGame(opts) {
             });
             stopAutoplay = () => autoplay$1.stop();
             haltAutoplay = () => autoplay$1.halt();
+            holdAutoplay = () => autoplay$1.hold();
+            releaseAutoplay = () => autoplay$1.release();
             shell.on('autoplayStart', (o) => autoplay$1.start(o?.remaining ?? 0));
             shell.on('autoplayStop', () => autoplay$1.stop());
             // Resume offer: when the game scene is (or becomes) current on a reload, ask the host whether
@@ -3397,7 +3413,7 @@ const DISCLAIMER_TITLE = 'DISCLAIMER';
 /** The copyright/brand line ("TM and © {year} Engine.") is shown verbatim; the legal body
  *  lines localize. Detecting the brand keeps " Engine" out of the translation lookup entirely. */
 function isBrandLine(line) {
-    return /stake\s+engine/i.test(line);
+    return /engine/i.test(line);
 }
 /** A disclaimer section from initData's disclaimer lines; null when none supplied. The legal body is
  *  run through `t` so it localizes per language, EXCEPT the brand line, which stays verbatim. The
@@ -4225,6 +4241,9 @@ function createConnectionRecovery(deps) {
             if (!linkLost)
                 return; // nothing of ours is on screen; nothing of ours to recover
             linkLost = false;
+            // The run does not resume across a reconnect. Like the halt above, this runs even when a
+            // modal owns the screen — the counter must not outlive the drop that ended the run.
+            deps.resetAutoplay();
             if (!blocked())
                 deps.dismiss();
             await recover();
@@ -4394,7 +4413,9 @@ function createAutoplayLoop(deps) {
     let active = false;
     let remaining = 0;
     let running = false; // guards against a second concurrent loop
+    let held = false; // a hold() is outstanding — the tab is hidden and the run is owed a resume
     const stop = () => {
+        held = false;
         if (!active && remaining === 0)
             return;
         active = false;
@@ -4402,6 +4423,7 @@ function createAutoplayLoop(deps) {
         deps.onState({ active: false, remaining: 0 });
     };
     const halt = () => {
+        held = false; // whatever is halting the run outranks a pending hold — see hold()'s doc comment
         if (!active)
             return; // nothing running — nothing to preserve
         active = false;
@@ -4438,27 +4460,45 @@ function createAutoplayLoop(deps) {
             running = false;
         }
     }
+    const start = (count) => {
+        if (active || count <= 0)
+            return;
+        held = false; // a run that is starting is no longer one that owes a resume
+        active = true;
+        remaining = count;
+        deps.onState({ active: true, remaining });
+        // `running` bars a SECOND loop, not a new run. After stop(), the round already in flight keeps
+        // animating and the loop stays parked on `await playRound`, so `running` is still true for as
+        // long as that takes — several seconds through a win. Bailing here made the restart a silent
+        // no-op, and silent is what hurt: ShellController.startAutoplay has already lit the disc with
+        // the chosen count, so the player saw autoplay running with a counter that never moved.
+        // The parked loop re-reads `active`/`remaining` on its next turn and simply carries on with
+        // the new budget — no second loop, nothing dropped.
+        if (!running)
+            void loop();
+    };
     return {
-        start(count) {
-            if (active || count <= 0)
-                return;
-            active = true;
-            remaining = count;
-            deps.onState({ active: true, remaining });
-            // `running` bars a SECOND loop, not a new run. After stop(), the round already in flight keeps
-            // animating and the loop stays parked on `await playRound`, so `running` is still true for as
-            // long as that takes — several seconds through a win. Bailing here made the restart a silent
-            // no-op, and silent is what hurt: ShellController.startAutoplay has already lit the disc with
-            // the chosen count, so the player saw autoplay running with a counter that never moved.
-            // The parked loop re-reads `active`/`remaining` on its next turn and simply carries on with
-            // the new budget — no second loop, nothing dropped.
-            if (!running)
-                void loop();
-        },
+        start,
         stop,
         halt,
-        get active() { return active; },
-        get remaining() { return remaining; },
+        hold() {
+            if (!active)
+                return; // nothing running — nothing to hold, and nothing to bring back
+            halt(); // clears `held`; we set it again below, so only a hold() ever leaves it set
+            held = true;
+        },
+        release() {
+            if (!held)
+                return;
+            held = false;
+            start(remaining); // no-op when the remainder is gone (something retired it while hidden)
+        },
+        get active() {
+            return active;
+        },
+        get remaining() {
+            return remaining;
+        },
     };
 }