@energy8platform/game-engine 0.33.7 → 0.33.9

package/dist/host.cjs.js

@@ -2455,10 +2455,11 @@ async function createSlotGame(opts) {
         // (hidden over the intro / non-slot scenes). Applies in BOTH base and replay modes.
         shell.setVisible(!!gameScene());
         game.scenes.on('change', () => shell.setVisible(!!gameScene()));
-        // The gate tracks the live wallet (for the affordability guard) but only PAINTS the balance per
-        // the HUD-timing rule: the debit is buffered during play→present and shown at afterPresent; the
-        // 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`.
+        // The gate tracks the live wallet (for the affordability guard) and PAINTS the balance per the
+        // HUD-timing rule: the debit paints immediately (the stake leaves the balance on spin); a win
+        // credit landing during play→present is held to afterPresent so it doesn't post before the
+        // animation; the async 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);
@@ -2501,6 +2502,11 @@ async function createSlotGame(opts) {
             size: () => ({ width: game.app.screen.width, height: game.app.screen.height }),
         });
         game.on('resize', ({ width, height }) => overlayCtl.resize(width, height));
+        // Progressive WIN readout for cascade/tumble scenes. The window is open from the moment a
+        // segment starts (WIN cleared to 0) until the host has painted that segment's final win; outside
+        // it the host owns the readout alone. See winReporter.ts.
+        const { createWinReporter } = await Promise.resolve().then(function () { return winReporter; });
+        const winReporter$1 = createWinReporter((amount, opts) => shell.setWin(amount, opts));
         // Capabilities injected once per controller scene via onCreate (see `gameScene`/`ensureCreated`).
         sceneApi = {
             audio: createSceneAudio(game.audio),
@@ -2509,6 +2515,7 @@ async function createSlotGame(opts) {
                 get safeArea() {
                     return shell.safeArea;
                 },
+                reportWin: winReporter$1.report,
             },
             formatAmount: (v) => shell.formatWin(v),
             get bet() {
@@ -2729,7 +2736,8 @@ async function createSlotGame(opts) {
             // RETURN the promise: the replay modal awaits onReplay() and only reopens once the round's
             // 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).
+                // Open the play→present window: the debit still paints immediately, but a win credit that
+                // lands mid-animation is held until afterPresent (HUD timing).
                 play: (a, b, rid) => {
                     balanceGate.beginPlay();
                     return slotPlay$1.play(a, b, rid);
@@ -2747,12 +2755,15 @@ async function createSlotGame(opts) {
                     // then counts UP to this segment's delta. prevWin (the cumulative-delta tracker) is
                     // untouched; this only resets the DISPLAY.
                     shell.setWin(0, { animate: false });
+                    winReporter$1.open(); // the scene may now grow WIN per cascade step
                 },
                 onSpinStart: () => scene.onSpinStart?.(),
                 onSpinEnd: (last, ctx) => scene.onSpinEnd?.(last, ctx),
                 afterPresent: (r) => {
                     // WIN readout = THIS spin's win (cumulative delta); the cumulative total goes to the
-                    // bonus counter (totalWin) via settle(), not the WIN readout.
+                    // bonus counter (totalWin) via settle(), not the WIN readout. A scene that reported
+                    // per-step wins already landed on this number, so the count-up is a no-op there.
+                    winReporter$1.close();
                     shell.setWin(r.totalWin - prevWin);
                     prevWin = r.totalWin;
                     balanceGate.afterPresent();
@@ -2764,6 +2775,7 @@ async function createSlotGame(opts) {
                 .catch(showPlayError)
                 .finally(() => {
                 presenting = false;
+                winReporter$1.close(); // also closes the window when a segment threw mid-flight
                 shell.setBusy(false);
             });
         };
@@ -2808,6 +2820,8 @@ async function createSlotGame(opts) {
                     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) {
@@ -2815,6 +2829,7 @@ async function createSlotGame(opts) {
                     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
@@ -2839,6 +2854,7 @@ async function createSlotGame(opts) {
                 }
             }
             finally {
+                winReporter$1.close(); // also closes the window when a drained segment threw
                 shell.setBusy(false);
             }
         };
@@ -3368,6 +3384,31 @@ var sceneStart = /*#__PURE__*/Object.freeze({
     resolveStartScene: resolveStartScene
 });
 
+function createWinReporter(paint) {
+    let accepting = false;
+    return {
+        report(amountSoFar, opts) {
+            if (!accepting || !Number.isFinite(amountSoFar))
+                return;
+            paint(Math.max(0, amountSoFar), opts);
+        },
+        open() {
+            accepting = true;
+        },
+        close() {
+            accepting = false;
+        },
+        get accepting() {
+            return accepting;
+        },
+    };
+}
+
+var winReporter = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createWinReporter: createWinReporter
+});
+
 // packages/game-engine/src/host/index.ts
 
 /**
@@ -3485,18 +3526,27 @@ var runRound$1 = /*#__PURE__*/Object.freeze({
 
 function createBalanceGate(paint, initial = 0) {
     let latest = initial;
+    let painted = initial;
     let suppressed = false;
+    const show = (amount) => {
+        painted = amount;
+        paint(amount);
+    };
     return {
         onBalance(amount) {
             latest = amount;
-            if (!suppressed)
-                paint(amount);
+            // During play→present, hold a CREDIT (balance rising) back so the win doesn't post before the
+            // animation. A DEBIT (balance falling — the stake) always paints now: spin deducts instantly.
+            if (suppressed && amount > painted)
+                return;
+            show(amount);
         },
         beginPlay() {
             suppressed = true;
         },
         afterPresent() {
-            paint(latest);
+            if (latest !== painted)
+                show(latest); // flush a credit that landed mid-present
             suppressed = false;
         },
         get balance() {
@@ -3784,6 +3834,7 @@ Object.defineProperty(exports, "socialize", {
 });
 exports.buildShellConfig = buildShellConfig;
 exports.createSlotGame = createSlotGame;
+exports.createWinReporter = createWinReporter;
 exports.resolveReplayBonusId = resolveReplayBonusId;
 exports.resolveStartScene = resolveStartScene;
 exports.stakeForAction = stakeForAction;