@energy8platform/game-engine 0.29.0 → 0.30.0

package/dist/host.cjs.js

@@ -2270,10 +2270,19 @@ async function createSlotGame(opts) {
                 availableClose: false,
                 title: shell.t('Something went wrong'),
                 body: shell.t(message),
-                actions: [{ title: shell.t('Reload'), on: () => { try {
-                            location.reload();
-                        }
-                        catch { /* non-browser */ } } }],
+                actions: [
+                    {
+                        title: shell.t('Reload'),
+                        on: () => {
+                            try {
+                                location.reload();
+                            }
+                            catch {
+                                /* non-browser */
+                            }
+                        },
+                    },
+                ],
             });
             return;
         }
@@ -2403,7 +2412,9 @@ async function createSlotGame(opts) {
                 const { lookupCurrency } = await import('@energy8platform/stake-bridge');
                 currencyMeta = lookupCurrency(opts.model.spec.currency);
             }
-            catch { /* stake-bridge not installed — resolveCurrency falls back to the code */ }
+            catch {
+                /* stake-bridge not installed — resolveCurrency falls back to the code */
+            }
         }
         const runtime = {
             balance,
@@ -2430,7 +2441,11 @@ async function createSlotGame(opts) {
         // pixi-shell mounts its root onto the engine's unscaled, screen-space UI layer (above the
         // scaled world/scene root) so the control bar fills the real screen, not the letterboxed game.
         // The host adds the mount target (`app`) + parent; buildShellConfig produces everything else.
-        const pixiShellCfg = { ...buildShellConfig(opts.shell, opts.model, runtime), app: game.app, parent: game.uiLayer };
+        const pixiShellCfg = {
+            ...buildShellConfig(opts.shell, opts.model, runtime),
+            app: game.app,
+            parent: game.uiLayer,
+        };
         // The game may swap in its own shell (a custom renderer over the same core) via shellFactory;
         // default is the built-in Pixi shell. The host drives whichever it gets through the Shell contract.
         shell = (opts.shellFactory ?? createPixiShell)(pixiShellCfg);
@@ -2443,10 +2458,15 @@ async function createSlotGame(opts) {
         // async win credit (/wallet/end-round, after the final ack) paints when it lands. `balanceGate`
         // is the single source for both the displayed balance and `ensureAffordable`.
         const balanceGate = createBalanceGate((b) => shell.setBalance(b), balance);
-        ps?.on('balanceUpdate', (d) => { balanceGate.onBalance(d.balance); });
+        ps?.on('balanceUpdate', (d) => {
+            balanceGate.onBalance(d.balance);
+        });
         // Live turbo level (0..3) — read fresh on each ctx.turbo access so a mid-round toggle is honoured.
         let currentTurbo = shell.state.turbo;
-        shell.on('turboChange', (level) => { currentTurbo = level; gameScene()?.onTurboChanged?.(level); });
+        shell.on('turboChange', (level) => {
+            currentTurbo = level;
+            gameScene()?.onTurboChanged?.(level);
+        });
         // Double-tap-to-skip is a game-level option (default on), set once via createSlotGame({ skipGesture }).
         const skipEnabled = opts.skipGesture ?? true;
         // Shell settings → engine state. Sound/volume map onto the AudioManager.
@@ -2483,11 +2503,21 @@ async function createSlotGame(opts) {
         sceneApi = {
             audio: createSceneAudio(game.audio),
             overlay: overlayCtl.overlay,
-            shell: { get safeArea() { return shell.safeArea; } },
+            shell: {
+                get safeArea() {
+                    return shell.safeArea;
+                },
+            },
             formatAmount: (v) => shell.formatWin(v),
-            get bet() { return currentBet; },
-            get mode() { return opts.model.modeMap['spin'] ?? 'BASE'; },
-            get turbo() { return currentTurbo; },
+            get bet() {
+                return currentBet;
+            },
+            get mode() {
+                return opts.model.modeMap['spin'] ?? 'BASE';
+            },
+            get turbo() {
+                return currentTurbo;
+            },
         };
         const roleOf = (action) => opts.model.spec.actions[action]?.role;
         // The signal-less context. runRound injects a per-segment `signal` (for skip); resumeDrain
@@ -2497,7 +2527,9 @@ async function createSlotGame(opts) {
             action,
             mode: opts.model.modeMap[action] ?? action.toUpperCase(),
             formatAmount: (v) => shell.formatWin(v),
-            get turbo() { return currentTurbo; },
+            get turbo() {
+                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
@@ -2513,11 +2545,27 @@ async function createSlotGame(opts) {
                 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('OK'), on: () => { playErrorOpen = false; } }],
+                    ? [
+                        {
+                            title: shell.t('Reload'),
+                            on: () => {
+                                try {
+                                    window.location.reload();
+                                }
+                                catch {
+                                    /* non-browser */
+                                }
+                            },
+                        },
+                    ]
+                    : [
+                        {
+                            title: shell.t('OK'),
+                            on: () => {
+                                playErrorOpen = false;
+                            },
+                        },
+                    ],
             });
         };
         ps?.on('connectionStateChanged', (s) => {
@@ -2546,7 +2594,10 @@ async function createSlotGame(opts) {
         const skip = createDoubleTapSkip({
             enabled: () => skipEnabled,
             active: () => presenting,
-            onSkip: () => { currentSegmentAbort?.abort(); gameScene()?.onSkip?.(); },
+            onSkip: () => {
+                currentSegmentAbort?.abort();
+                gameScene()?.onSkip?.();
+            },
         });
         // Listen for taps on the scene root (game.worldRoot — the scaled scene container). The shell
         // lives on the sibling uiLayer, so its bar taps never reach worldRoot — taps here are the play area.
@@ -2576,6 +2627,27 @@ async function createSlotGame(opts) {
                 gameScene()?.onResume?.();
             },
         });
+        /** Push a bonus segment's readout to the shell bar. Default (no `opts.bonus`) = the free-spins
+         *  counter (label 'Free spins', value current/total). With `opts.bonus`, the game supplies the
+         *  label + value string (adventure / hold-and-spin / respins) and we drive the generic 'bonus'
+         *  hero instead — the shell stays free of any per-game bonus concept. */
+        const applyBonusReadout = (result, view, mode) => {
+            const b = opts.bonus;
+            if (!b) {
+                shell.setFreeSpins(view);
+                return;
+            }
+            const label = typeof b.label === 'function' ? b.label(mode) : (b.label ?? 'Free spins');
+            const value = b.readout
+                ? b.readout(result, { view, mode })
+                : view.current == null
+                    ? String(view.total)
+                    : `${view.current} / ${view.total}`;
+            shell.setBonus({ label, value, totalWin: view.totalWin });
+        };
+        /** The mode entered via setMode for a bonus — 'bonus' when the game customises the readout,
+         *  else 'freeSpins' (the back-compat default the shell already renders). */
+        const bonusShellMode = opts.bonus ? 'bonus' : 'freeSpins';
         /** Drive a full round (trigger + drain) against the current scene. HUD readouts (win + balance)
          *  update only AFTER each onSpin(), per the HUD-timing requirement. */
         const playRound = (action) => {
@@ -2586,6 +2658,7 @@ async function createSlotGame(opts) {
             // (growing on retriggers) + cumulative win per spin. `inBonus` gates the per-spin counter so
             // the trigger segment (rendered by onSpin before onEnterMode) doesn't count as a free spin.
             let inBonus = false;
+            let bonusMode = ''; // the mode string captured on bonus-enter, reused for each settled spin
             let prevWin = 0; // cumulative win up to the previous segment — the WIN readout shows the delta
             const fsCounter = createFreeSpinsCounter();
             shell.setBusy(true); // block re-spin / spacebar while the round plays out
@@ -2594,13 +2667,18 @@ async function createSlotGame(opts) {
             // animation has finished — returning void would reopen it instantly, over a running animation.
             return runRound({
                 // Suppress the debit paint from play() until this segment's afterPresent (HUD timing).
-                play: (a, b, rid) => { balanceGate.beginPlay(); return slotPlay$1.play(a, b, rid); },
+                play: (a, b, rid) => {
+                    balanceGate.beginPlay();
+                    return slotPlay$1.play(a, b, rid);
+                },
                 ack: slotPlay$1.ack,
                 scene,
                 context: makeContext,
                 roleOf,
                 // Hand the host the per-segment AbortController so a double-tap can skip the live segment.
-                beforeSegment: (ac) => { currentSegmentAbort = ac; },
+                beforeSegment: (ac) => {
+                    currentSegmentAbort = ac;
+                },
                 onSpinStart: () => scene.onSpinStart?.(),
                 onSpinEnd: (last, ctx) => scene.onSpinEnd?.(last, ctx),
                 afterPresent: (r) => {
@@ -2610,12 +2688,13 @@ async function createSlotGame(opts) {
                     prevWin = r.totalWin;
                     balanceGate.afterPresent();
                     if (inBonus)
-                        shell.setFreeSpins(fsCounter.spin(r.freeSpins?.awarded ?? 0, r.totalWin));
+                        applyBonusReadout(r, fsCounter.spin(r.freeSpins?.awarded ?? 0, r.totalWin), bonusMode);
                 },
                 onEnterMode: async (trigger, ctx) => {
                     inBonus = true;
-                    shell.setMode('freeSpins');
-                    shell.setFreeSpins(fsCounter.enter(trigger.freeSpins?.awarded ?? trigger.freeSpins?.total ?? 0));
+                    bonusMode = ctx.mode;
+                    shell.setMode(bonusShellMode);
+                    applyBonusReadout(trigger, fsCounter.enter(trigger.freeSpins?.awarded ?? trigger.freeSpins?.total ?? 0), bonusMode);
                     await scene.onEnterMode?.(trigger, ctx);
                 },
                 onExitMode: async (last, ctx) => {
@@ -2623,7 +2702,12 @@ async function createSlotGame(opts) {
                     await scene.onExitMode?.(last, ctx);
                     shell.setMode('base');
                 },
-            }, action).catch(showPlayError).finally(() => { presenting = false; shell.setBusy(false); });
+            }, action)
+                .catch(showPlayError)
+                .finally(() => {
+                presenting = false;
+                shell.setBusy(false);
+            });
         };
         /**
          * Drain a recovered open round to completion and settle it. Plays EVERY remaining segment from
@@ -2661,14 +2745,14 @@ async function createSlotGame(opts) {
                 // A recovered open round with remaining segments is a bonus → show FS mode + counter.
                 if (!inBonus && !r.complete) {
                     inBonus = true;
-                    shell.setMode('freeSpins');
+                    shell.setMode(bonusShellMode);
                 }
                 if (animate)
                     await scene.onSpin(r, ctx);
                 if (inBonus) {
                     const v = fsView(raw, r.totalWin);
                     if (v)
-                        shell.setFreeSpins(v);
+                        applyBonusReadout(r, v, ctx.mode);
                 }
                 shell.setWin(r.totalWin - prevWin); // THIS spin's win, not the cumulative bonus total
                 prevWin = r.totalWin;
@@ -2678,7 +2762,11 @@ async function createSlotGame(opts) {
             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 }));
+                    raw = (await ps.play({
+                        action: r.nextActions[0],
+                        bet: ctx.bet,
+                        roundId: r.roundId,
+                    }));
                     r = enrichRoundMeta(opts.normalize(raw), raw);
                     await applySegment();
                 }
@@ -2691,8 +2779,12 @@ async function createSlotGame(opts) {
         };
         if (mode === 'base') {
             let activeFeature = null;
-            shell.on('featureActivate', ({ id }) => { activeFeature = id; });
-            shell.on('featureDeactivate', ({ id: _id }) => { activeFeature = null; });
+            shell.on('featureActivate', ({ id }) => {
+                activeFeature = id;
+            });
+            shell.on('featureDeactivate', ({ id: _id }) => {
+                activeFeature = null;
+            });
             const { stakeForAction } = await Promise.resolve().then(function () { return shellConfig; });
             // Guard a play: if the stake exceeds the balance, show a shell modal and DON'T play.
             const ensureAffordable = (action) => {
@@ -2712,7 +2804,10 @@ async function createSlotGame(opts) {
                     return;
                 void playRound(action);
             });
-            shell.on('betChange', (bet) => { currentBet = bet; gameScene()?.onBetChanged?.(bet); });
+            shell.on('betChange', (bet) => {
+                currentBet = bet;
+                gameScene()?.onBetChanged?.(bet);
+            });
             shell.on('buyBonusSelect', ({ id }) => {
                 if (!ensureAffordable(id))
                     return;
@@ -2743,7 +2838,7 @@ async function createSlotGame(opts) {
                 resumeOffered = true;
                 let snap = null;
                 try {
-                    snap = await ps?.getState() ?? null;
+                    snap = (await ps?.getState()) ?? null;
                 }
                 catch {
                     snap = null;
@@ -2756,13 +2851,25 @@ async function createSlotGame(opts) {
                     body: shell.t('You have an unfinished round. Continue it or finish it now?'),
                     actions: [
                         // Continue: replay the round from the start with animation, then settle.
-                        { title: shell.t('Continue'), on: () => { void resumeDrain(snap, true); } },
+                        {
+                            title: shell.t('Continue'),
+                            on: () => {
+                                void resumeDrain(snap, true);
+                            },
+                        },
                         // Finish: fast-forward the remaining segments (no animation) to settle the win now.
-                        { title: shell.t('Finish'), on: () => { void resumeDrain(snap, false); } },
+                        {
+                            title: shell.t('Finish'),
+                            on: () => {
+                                void resumeDrain(snap, false);
+                            },
+                        },
                     ],
                 });
             };
-            game.scenes.on('change', () => { void offerResume(); });
+            game.scenes.on('change', () => {
+                void offerResume();
+            });
             void offerResume();
         }
         else {