@energy8platform/game-engine 0.38.0 → 0.40.0

package/dist/host.cjs.js

@@ -2692,6 +2692,8 @@ async function createSlotGame(opts) {
             social: config?.socialMode,
             disclaimerLines: config?.disclaimerLines,
             jurisdiction: config?.jurisdiction,
+            // Decides whether the shell offers a keyboard at all — see buildShellConfig.
+            device: initData?.device,
             // Currency-specific ladder + per-currency default from /wallet/authenticate (Stake) or the
             // backend's `allowed_bets` (Artube); absent on dev/devBridge → buildShellConfig falls back to
             // the spec.
@@ -2842,33 +2844,41 @@ async function createSlotGame(opts) {
                 return currentTurbo;
             },
         });
-        // Play-error + connection handling. A play rejection is classified into a player-facing modal
-        // (ACTIVE_SESSION_EXISTS → Reload, etc.) instead of a misleading reconnect overlay; the reconnect
-        // overlay is suppressed while a play-error modal owns the screen.
+        // Play-error + connection handling. A play rejection is classified (playError.ts): a failed
+        // ROUND gets a player-facing modal (ACTIVE_SESSION_EXISTS → Reload, etc.), a failed LINK gets
+        // none — the reconnect overlay owns that screen (connectionRecovery.ts). Either way the failure
+        // halts an autoplay run WITHOUT clearing its counter. The overlay stays suppressed while a
+        // play-error modal owns the screen.
         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
+        const reload = () => {
+            try {
+                window.location.reload();
+            }
+            catch {
+                /* non-browser */
+            }
+        };
         const showPlayError = (err) => {
-            stopAutoplay(); // a play error halts an autoplay run (the .catch swallows, so stop explicitly)
             const v = resolvePlayError(err);
+            // Halt, don't stop: the spins the player still has coming outlive the failure, so the bar can
+            // show them (and offer to resume). The .catch in playRound swallows the rejection, so the
+            // autoplay loop can't see it — this is what ends the run.
+            haltAutoplay();
+            // A failed LINK is not a failed round. The bridge is already reconnecting and the connection
+            // overlay owns the screen; a modal here is exactly the "reload the page" screen that showed
+            // up on every network blip — and only in autoplay, since only autoplay always has a play in
+            // flight when the socket dies.
+            if (v.connection)
+                return;
             playErrorOpen = true;
             shell.openModal({
                 availableClose: !v.reload,
                 title: shell.t(v.title),
                 body: shell.t(v.body),
                 actions: v.reload
-                    ? [
-                        {
-                            title: shell.t('Reload'),
-                            on: () => {
-                                try {
-                                    window.location.reload();
-                                }
-                                catch {
-                                    /* non-browser */
-                                }
-                            },
-                        },
-                    ]
+                    ? [{ title: shell.t('Reload'), on: reload }]
                     : [
                         {
                             title: shell.t('OK'),
@@ -2879,20 +2889,31 @@ async function createSlotGame(opts) {
                     ],
             });
         };
-        ps?.on('connectionStateChanged', (s) => {
-            if (s.status === 'restored') {
-                if (!playErrorOpen)
-                    shell.closeModal();
-                return;
-            }
-            if (playErrorOpen)
-                return; // a play-error modal owns the screen — don't mask it with "reconnecting"
-            shell.openModal({
+        // Connection loss/return. Assigned below, once `resumeDrain` exists: a restored link finishes
+        // the round the drop interrupted, and it must not reach the drain before it is defined.
+        let recoverRound = async () => { };
+        const { createConnectionRecovery } = await Promise.resolve().then(function () { return connectionRecovery; });
+        const connection = createConnectionRecovery({
+            haltAutoplay: () => haltAutoplay(),
+            showReconnecting: () => shell.openModal({
                 availableClose: false,
                 title: shell.t('Reconnecting…'),
                 body: shell.t('Lost connection to the game server. Trying to reconnect…'),
-            });
+            }),
+            // The bridge stopped retrying: say so instead of leaving "Reconnecting…" up for good.
+            showGone: () => shell.openModal({
+                availableClose: false,
+                title: shell.t('Connection lost'),
+                body: shell.t('Could not reconnect to the game server. Please reload the game.'),
+                actions: [{ title: shell.t('Reload'), on: reload }],
+            }),
+            dismiss: () => shell.closeModal(),
+            getState: async () => (await ps?.getState()) ?? null,
+            drain: (snapshot) => recoverRound(snapshot),
+            onError: showPlayError,
+            isBlocked: () => playErrorOpen,
         });
+        ps?.on('connectionStateChanged', (s) => void connection.onState(s));
         // Skip state: `currentSegmentAbort` is the controller for the segment presently animating;
         // `presenting` is true for the whole play→drain window (gates the double-tap detector so taps
         // only skip while a round is animating).
@@ -3076,85 +3097,27 @@ async function createSlotGame(opts) {
                 shell.setBusy(false);
             });
         };
-        /**
-         * Drain a recovered open round to completion and settle it. Plays EVERY remaining segment from
-         * the bonus start (Continue animates each; Finish fast-forwards without animation), reaching the
-         * final ack so /wallet/end-round credits the win — fixing the old resume that presented one
-         * snapshot and never settled. The original trigger is gone on reload, so the FS counter here uses
-         * the bridge's session counts; FS mode is entered/exited around the drain.
-         */
-        const resumeDrain = async (firstRaw, animate) => {
-            const scene = gameScene();
-            if (!scene || !ps)
-                return;
-            // A recovered drain isn't skippable (no live skip gesture wired to it), so it gets a stable,
-            // never-aborted signal to satisfy onSpin's RenderContext. ctx carries the round identity (built
-            // once from the trigger action) — recovery drains a single flat bonus using the bridge session
-            // counts; the full per-level nesting is a LIVE-play concern (playRound).
-            const ctx = {
-                ...makeContext(firstRaw.action ?? 'spin'),
-                signal: new AbortController().signal,
-            };
-            const fsView = (raw, totalWin) => {
-                const s = raw.session;
-                if (!s)
-                    return null;
-                // The bridge session counts ALL segments incl. the trigger (segment 0); the free-spins
-                // counter is over FREE spins only, so drop the one trigger segment → 1/10, not 2/11.
-                const played = s.spinsPlayed ?? 0;
-                const current = Math.max(0, played - 1);
-                const total = Math.max(0, played + (s.spinsRemaining ?? 0) - 1);
-                return { current, total, totalWin };
-            };
-            let raw = firstRaw;
-            let r = enrichRoundMeta(opts.normalize(raw), raw);
-            let inBonus = false;
-            let prevWin = 0; // cumulative win up to the previous segment — WIN readout shows the delta
-            const applySegment = async () => {
-                // A recovered open round with remaining segments is a bonus → show bonus mode + counter.
-                if (!inBonus && !r.complete) {
-                    inBonus = true;
-                    shell.setMode(bonusShellMode);
-                }
-                shell.setWin(0, { animate: false }); // clear WIN before this segment animates (see playRound)
-                if (animate)
-                    winReporter$1.open(); // a fast-forward drain doesn't present → no reports expected
-                if (animate)
-                    await scene.onSpin(r, ctx);
-                if (inBonus) {
-                    const v = fsView(raw, r.totalWin);
-                    if (v)
-                        applyBonusReadout(r, v, ctx.mode);
-                }
-                winReporter$1.close();
-                shell.setWin(r.totalWin - prevWin); // THIS spin's win, not the cumulative bonus total
-                prevWin = r.totalWin;
-                ps.playAck(raw); // settles via /wallet/end-round on the FINAL segment
-            };
-            shell.setBusy(true); // block input while the recovered round drains
-            try {
-                await applySegment();
-                while (!r.complete && r.nextActions && r.nextActions.length > 0) {
-                    raw = (await ps.play({
-                        action: r.nextActions[0],
-                        bet: ctx.bet,
-                        roundId: r.roundId,
-                    }));
-                    r = enrichRoundMeta(opts.normalize(raw), raw);
-                    await applySegment();
-                }
-                if (inBonus) {
-                    shell.setMode('base');
-                    // Same as playRound: on return to base the WIN readout must show the round's cumulative
-                    // total (r is the final drained segment), not the last segment's per-spin delta.
-                    shell.setWin(r.totalWin);
-                }
-            }
-            finally {
-                winReporter$1.close(); // also closes the window when a drained segment threw
-                shell.setBusy(false);
-            }
-        };
+        // Drain a recovered open round (reload / dropped connection) to settlement — see resumeDrain.ts.
+        // `scene` folds in the old `!ps` guard: with no session there is nothing to play or ack.
+        const { createResumeDrain } = await Promise.resolve().then(function () { return resumeDrain; });
+        const resumeDrain$1 = createResumeDrain({
+            scene: () => (ps ? gameScene() : undefined),
+            play: (req) => ps.play(req),
+            ack: (raw) => ps.playAck(raw),
+            normalize: opts.normalize,
+            context: makeContext,
+            setWin: (amount, o) => shell.setWin(amount, o),
+            setMode: (m) => shell.setMode(m),
+            setBusy: (b) => shell.setBusy(b),
+            winReporter: winReporter$1,
+            applyBonusReadout,
+            bonusMode: bonusShellMode,
+        });
+        // A round interrupted by a dropped connection is finished the same way a round interrupted by a
+        // reload is — animated, through to settlement — except nothing asks the player first: it is
+        // their own round, and an extra confirmation screen is what the reconnect flow is meant to
+        // avoid. (The reload path keeps its Continue/Finish offer: there, the player has been away.)
+        recoverRound = (snapshot) => resumeDrain$1(snapshot, true);
         if (mode === 'base') {
             let activeFeature = null;
             shell.on('featureActivate', ({ id }) => {
@@ -3180,6 +3143,9 @@ async function createSlotGame(opts) {
                 const action = activeFeature ?? 'spin';
                 if (!ensureAffordable(action))
                     return;
+                // Spinning by hand retires whatever a halted run left on the counter — the player moved on.
+                // (No-op unless a run was halted: `stop()` returns early when there is nothing to clear.)
+                stopAutoplay();
                 void playRound(action);
             });
             shell.on('betChange', (bet) => {
@@ -3189,6 +3155,7 @@ async function createSlotGame(opts) {
             shell.on('buyBonusSelect', ({ id }) => {
                 if (!ensureAffordable(id))
                     return;
+                stopAutoplay(); // as with a manual spin: a bought bonus retires a halted run's counter
                 void playRound(id);
             });
             // Autoplay: the shell owns the picker/confirm/STOP/counter/lockout (all driven by state.autoplay);
@@ -3204,6 +3171,7 @@ async function createSlotGame(opts) {
                 },
             });
             stopAutoplay = () => autoplay$1.stop();
+            haltAutoplay = () => autoplay$1.halt();
             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
@@ -3232,14 +3200,14 @@ async function createSlotGame(opts) {
                         {
                             title: shell.t('Continue'),
                             on: () => {
-                                void resumeDrain(snap, true);
+                                void resumeDrain$1(snap, true);
                             },
                         },
                         // Finish: fast-forward the remaining segments (no animation) to settle the win now.
                         {
                             title: shell.t('Finish'),
                             on: () => {
-                                void resumeDrain(snap, false);
+                                void resumeDrain$1(snap, false);
                             },
                         },
                     ],
@@ -3661,6 +3629,11 @@ function buildShellConfig(opts, model, runtime) {
         ...(opts.features ?? {}),
     };
     applyJurisdiction(features, runtime.jurisdiction);
+    // A phone has no keys to press: no Spacebar-to-spin, and no keycap chart advertising it. Applied
+    // after the author's features for the same reason a jurisdiction restriction is — the platform
+    // knows what it launched us on, and a game can't opt out of the hardware.
+    if (runtime.device === 'mobile')
+        features.hotkeys = false;
     return {
         language: runtime.language ?? 'en',
         isSocial,
@@ -4058,6 +4031,13 @@ var freeSpinsCounter = /*#__PURE__*/Object.freeze({
     createFreeSpinsCounter: createFreeSpinsCounter
 });
 
+/**
+ * Codes that mean "the connection died", per bridge:
+ *  - `ConnectionLost` / `ConnectionFailed` — Artube's WS client (a pending play on a dropped
+ *    socket, or a play attempted while the socket is down);
+ *  - `ERR_NET` — Stake's RGS client, after its retries are exhausted on a network-level failure.
+ */
+const CONNECTION_CODES = new Set(['ConnectionLost', 'ConnectionFailed', 'ERR_NET']);
 /** Pull a Stake/SDK error code off an unknown thrown value. */
 function errorCode(err) {
     const code = err?.code;
@@ -4066,6 +4046,14 @@ function errorCode(err) {
 function resolvePlayError(err) {
     const code = errorCode(err);
     const message = err instanceof Error ? err.message : typeof err === 'string' ? err : '';
+    if (code && CONNECTION_CODES.has(code)) {
+        return {
+            title: 'Connection lost',
+            body: 'Lost connection to the game server. Trying to reconnect…',
+            reload: false,
+            connection: true,
+        };
+    }
     switch (code) {
         case 'ACTIVE_SESSION_EXISTS':
             return {
@@ -4189,6 +4177,66 @@ var overlayController = /*#__PURE__*/Object.freeze({
     createOverlayController: createOverlayController
 });
 
+// packages/game-engine/src/host/connectionRecovery.ts
+/** The bridge has stopped retrying — see `ArtubeClient`'s exhausted reconnect loop. */
+const GONE = 'ConnectionGone';
+function createConnectionRecovery(deps) {
+    let linkLost = false;
+    const blocked = () => deps.isBlocked?.() ?? false;
+    async function recover() {
+        let snapshot = null;
+        try {
+            snapshot = await deps.getState();
+        }
+        catch {
+            // The platform couldn't tell us. Nothing to finish, and nothing worth a screen: the player
+            // is back in the game, and the next play resolves the open round (or refuses it, loudly).
+            return;
+        }
+        if (!snapshot)
+            return;
+        try {
+            await deps.drain(snapshot);
+        }
+        catch (err) {
+            deps.onError(err);
+        }
+    }
+    return {
+        async onState(state) {
+            if (state.status === 'connecting')
+                return; // in transit — the screen stays as it is
+            if (state.status === 'lost') {
+                // Halt first: it is what the remark asks for, and it holds even when a modal already owns
+                // the screen and the overlay below is skipped.
+                deps.haltAutoplay();
+                if (state.code === GONE) {
+                    if (!blocked())
+                        deps.showGone();
+                    return;
+                }
+                if (linkLost)
+                    return; // already announced — reconnect attempts don't restack the overlay
+                linkLost = true;
+                if (!blocked())
+                    deps.showReconnecting();
+                return;
+            }
+            if (!linkLost)
+                return; // nothing of ours is on screen; nothing of ours to recover
+            linkLost = false;
+            if (!blocked())
+                deps.dismiss();
+            await recover();
+        },
+    };
+}
+
+var connectionRecovery = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createConnectionRecovery: createConnectionRecovery
+});
+
 /** Pure double-tap recognizer. The host feeds it pointer `tap(now)` (e.g. performance.now()) and
  *  supplies the enabled/active gates + the onSkip effect. */
 function createDoubleTapSkip(deps) {
@@ -4232,6 +4280,116 @@ var pauseController = /*#__PURE__*/Object.freeze({
     createPauseController: createPauseController
 });
 
+// packages/game-engine/src/host/resumeDrain.ts
+/**
+ * Rebuild the free-spins counter from a resumed segment's session counts.
+ *
+ * The bridge session counts ALL segments including the trigger (segment 0); the free-spins counter
+ * is over FREE spins only, so one trigger segment is dropped → `1 / 10`, not `2 / 11`. `null` when
+ * the snapshot carries no session at all — there is nothing to count, and painting zeroes would be
+ * a claim, not a reading.
+ */
+function resumeBonusView(raw, totalWin) {
+    const s = raw?.session;
+    if (!s)
+        return null;
+    const played = s.spinsPlayed ?? 0;
+    return {
+        current: Math.max(0, played - 1),
+        total: Math.max(0, played + (s.spinsRemaining ?? 0) - 1),
+        totalWin,
+    };
+}
+/**
+ * Fold a segment's own free-spins counts over the session-derived view.
+ *
+ * Same precedence live play uses (`overrideView` in createSlotGame): when the book states the count
+ * outright, it is the authority — the session's segment arithmetic is only a reconstruction, and it
+ * assumes a shape (exactly one trigger segment ahead of the free spins) that not every game has.
+ */
+function overrideWithBook(view, fs) {
+    if (!fs || (fs.total == null && fs.remaining == null))
+        return view;
+    const base = view ?? { current: 0, total: 0, totalWin: 0 };
+    const total = fs.total ?? base.total;
+    const current = fs.remaining != null ? Math.max(0, total - fs.remaining) : base.current;
+    return { current, total, totalWin: base.totalWin };
+}
+function createResumeDrain(deps) {
+    return async function drain(firstRaw, animate) {
+        const scene = deps.scene();
+        if (!scene)
+            return;
+        // A recovered drain isn't skippable (no live skip gesture wired to it), so it gets a stable,
+        // never-aborted signal to satisfy onSpin's RenderContext. ctx carries the round identity (built
+        // once from the trigger action) — recovery drains a single flat bonus using the bridge session
+        // counts; the full per-level nesting is a LIVE-play concern (playRound).
+        const ctx = {
+            ...deps.context(firstRaw.action ?? 'spin'),
+            signal: new AbortController().signal,
+        };
+        let raw = firstRaw;
+        let r = enrichRoundMeta(deps.normalize(raw), raw);
+        let inBonus = false;
+        let prevWin = 0; // cumulative win up to the previous segment — WIN readout shows the delta
+        /** Push the current segment's counts to the bar (book counts win over the session's). */
+        const paintCounter = () => {
+            const view = overrideWithBook(resumeBonusView(raw, r.totalWin), r.freeSpins);
+            if (view)
+                deps.applyBonusReadout(r, view, ctx.mode);
+        };
+        const applySegment = async () => {
+            // A recovered open round with remaining segments is a bonus → show bonus mode + counter.
+            if (!inBonus && !r.complete) {
+                inBonus = true;
+                deps.setMode(deps.bonusMode);
+                // BEFORE the segment animates, not after. The bar has just switched to its bonus face, and
+                // its counter still holds the zeroes it was born with; leaving it that way means the player
+                // watches a whole free spin play out under `0 / 0` and only then sees where the round
+                // actually stands. The snapshot already carries the counts — paint them.
+                paintCounter();
+            }
+            deps.setWin(0, { animate: false }); // clear WIN before this segment animates (see playRound)
+            if (animate)
+                deps.winReporter.open(); // a fast-forward drain doesn't present → no reports expected
+            if (animate)
+                await scene.onSpin(r, ctx);
+            if (inBonus)
+                paintCounter();
+            deps.winReporter.close();
+            deps.setWin(r.totalWin - prevWin); // THIS spin's win, not the cumulative bonus total
+            prevWin = r.totalWin;
+            deps.ack(raw); // settles via /wallet/end-round on the FINAL segment
+        };
+        deps.setBusy(true); // block input while the recovered round drains
+        try {
+            await applySegment();
+            while (!r.complete && r.nextActions && r.nextActions.length > 0) {
+                raw = await deps.play({ action: r.nextActions[0], bet: ctx.bet, roundId: r.roundId });
+                r = enrichRoundMeta(deps.normalize(raw), raw);
+                await applySegment();
+            }
+            if (inBonus) {
+                deps.setMode('base');
+                // Same as playRound: on return to base the WIN readout must show the round's cumulative
+                // total (r is the final drained segment), not the last segment's per-spin delta.
+                deps.setWin(r.totalWin);
+            }
+        }
+        finally {
+            deps.winReporter.close(); // also closes the window when a drained segment threw
+            deps.setBusy(false);
+        }
+    };
+}
+
+var resumeDrain = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createResumeDrain: createResumeDrain,
+    overrideWithBook: overrideWithBook,
+    resumeBonusView: resumeBonusView
+});
+
 function createAutoplayLoop(deps) {
     let active = false;
     let remaining = 0;
@@ -4243,6 +4401,12 @@ function createAutoplayLoop(deps) {
         remaining = 0;
         deps.onState({ active: false, remaining: 0 });
     };
+    const halt = () => {
+        if (!active)
+            return; // nothing running — nothing to preserve
+        active = false;
+        deps.onState({ active: false, remaining });
+    };
     async function loop() {
         if (running)
             return;
@@ -4261,7 +4425,9 @@ function createAutoplayLoop(deps) {
                     await deps.playRound(action);
                 }
                 catch {
-                    stop(); // a play error already surfaced its own modal — just halt the run
+                    // The round failed (the host surfaces its own message, if any is due). Halt rather than
+                    // stop: a connection blip must not eat the spins the player still has coming.
+                    halt();
                     return;
                 }
             }
@@ -4282,6 +4448,7 @@ function createAutoplayLoop(deps) {
             void loop();
         },
         stop,
+        halt,
         get active() { return active; },
         get remaining() { return remaining; },
     };