pixi-rainman-game-engine 0.3.41 → 0.3.42-beta.1

package/dist/Rainman/appConfig.js

@@ -7,6 +7,7 @@ import { Color } from "pixi.js";
 export const defaultAppConfig = {
     gameWidth: 1920,
     gameHeight: 1080,
+    enableInfinityAutoplay: false,
     reinitMode: false,
     reinitSymbolIndexFix: 0,
     idleTimeout: 10000,

package/dist/Rainman/types.d.ts

@@ -13,6 +13,7 @@ export type RequiredAppConfig = {
 export type OptionalAppConfig = {
     gameWidth: number;
     gameHeight: number;
+    enableInfinityAutoplay: boolean;
     reinitMode: boolean;
     reinitSymbolIndexFix: number;
     idleTimeout: number;

package/dist/SettingsUI/components/AutoplaySettings/index.jsx

@@ -4,6 +4,7 @@ import i18next from "i18next";
 import { observer } from "mobx-react-lite";
 import React from "react";
 import { COMPONENTS } from "../../../components";
+import { RainMan } from "../../../Rainman";
 import { UI_ITEMS } from "../../../utils";
 import { useStores } from "../../hooks";
 import { CloseModalButton } from "../CloseModalButton";
@@ -11,11 +12,18 @@ import { RichLimitingSlider } from "../RichLimitingSlider";
 import { SpeedButtonWithHeader, SwitchWithHeader } from "../SwitchWithHeader";
 const initialAutoSpinCount = 10;
 const availableAutoSpinLimits = [10, 20, 50, 70, 100];
+const infiniteAutoSpinCount = 1000000;
 export const AutoplaySettings = observer(() => {
     const { settingStore } = useStores();
+    const infinityAutoplayEnabled = RainMan.config.enableInfinityAutoplay;
     const updateLimitsBounds = (newLimit) => {
+        settingStore.setInfinitySpinsEnabled(false);
         setAutoSpinsCount(newLimit);
     };
+    const enableInfinityAutoplay = () => {
+        settingStore.setInfinitySpinsEnabled(true);
+        setAutoSpinsCount(infiniteAutoSpinCount);
+    };
     const { singleWinExceeds, balancedIncreased, balancedDecreased, howManyAutoSpinsLeft, infinitySpinsEnabled, setSingleWinExceeds, setBalancedIncreased, setBalancedDecreased, setAutoSpinsCount, resetAutoplaySettings } = settingStore;
     return (<div className="autoplay-settings">
             <CloseModalButton layerId={UI_ITEMS.autoplay}/>
@@ -23,9 +31,14 @@ export const AutoplaySettings = observer(() => {
                 <h2>{i18next.t("autoPlay")}</h2>
             </div>
             <div className="autoplay-settings__stop-limits">
-                {availableAutoSpinLimits.map((limiter, index) => (<button key={`${limiter}${index}`} value={limiter} className={`autoplay-settings__limit ${limiter === howManyAutoSpinsLeft ? "autoplay-settings__limit--active" : ""} middle ${infinitySpinsEnabled ? "autoplay-settings__limit--infinity" : ""}`} disabled={settingStore.infinitySpinsEnabled} onClick={(event) => updateLimitsBounds(Number(event.currentTarget.value))}>
+                {availableAutoSpinLimits.map((limiter, index) => (<button key={`${limiter}${index}`} value={limiter} className={`autoplay-settings__limit ${!infinitySpinsEnabled && limiter === howManyAutoSpinsLeft
+                ? "autoplay-settings__limit--active"
+                : ""} middle`} onClick={(event) => updateLimitsBounds(Number(event.currentTarget.value))}>
                         <p>{limiter}</p>
                     </button>))}
+                {infinityAutoplayEnabled && (<button value="infinity" className={`autoplay-settings__limit ${infinitySpinsEnabled ? "autoplay-settings__limit--active" : ""} right`} onClick={enableInfinityAutoplay}>
+                        <p>∞</p>
+                    </button>)}
             </div>
             <div className="separator"/>
             <div className="autoplay-settings__title">

package/dist/application/SoundManager/SoundManager.d.ts

@@ -16,7 +16,11 @@ export declare class SoundManagerInstance implements SpeedAdapterInterface<Sound
     readonly speedLevelMapper: SpeedLevelDirectory<SoundOverrides>;
     private musicCatalogue;
     private currentAmbientTrack;
+    private currentAmbientOffset;
+    private loadedSoundAssets;
+    private audioContextRecoveryPromise;
     constructor();
+    private loadSound;
     /**
      * Function for loading sounds into pixi
      * @public
@@ -37,7 +41,7 @@ export declare class SoundManagerInstance implements SpeedAdapterInterface<Sound
      * @returns {void}
      */
     stopPlayingFxSounds(): void;
-    stopSoundsForPageHide(): void;
+    pauseSoundsForPageHide(): void;
     /**
      * Function for resuming and pausing sound in game
      * @public
@@ -61,7 +65,19 @@ export declare class SoundManagerInstance implements SpeedAdapterInterface<Sound
     getVolumeLevel(soundName: SoundTrack): number;
     private isAmbientTrack;
     private getOppositeAmbientTrack;
+    private getCurrentAmbientTrack;
     private getSound;
+    private getAmbientPlaybackOffset;
+    private trackAmbientPlaybackProgress;
+    /**
+     * Saves active ambient position before the browser interrupts WebAudio playback.
+     * @public
+     * @returns {void}
+     */
+    captureAmbientPlaybackPositionForPageHide(): void;
+    private isIOSWebAudioRuntime;
+    private recreatePixiSoundContext;
+    private recreatePixiSoundContextOnce;
     stopAmbientMusic(): void;
     /**
      * Function for resuming all sounds in game
@@ -76,6 +92,19 @@ export declare class SoundManagerInstance implements SpeedAdapterInterface<Sound
      * @returns {void}
      */
     restoreAmbientPlayback(): void;
+    /**
+     * Recreates the active ambient WebAudio source after iOS app interruptions.
+     * Existing Pixi instances can report isPlaying=true even when the native audio pipeline is silent.
+     * @private
+     * @returns {void}
+     */
+    private restartAmbientPlaybackAfterInterruption;
+    /**
+     * Restores ambient playback after page visibility change or iOS app interruption.
+     * @public
+     * @returns {boolean} True when audio context is ready after recovery.
+     */
+    restorePlaybackAfterPageHide(): Promise<boolean>;
     /**
      * Function for pausing all sounds in game
      * If sound is not playing, it will be skipped
@@ -121,13 +150,13 @@ export declare class SoundManagerInstance implements SpeedAdapterInterface<Sound
     /**
      * Function that resumes sounds and music when game is back in focus.
      * @public
-     * @returns {void}
+     * @returns {Promise<boolean>} True when audio context is running.
      */
     resumeAudioContext(): Promise<boolean>;
     /**
      * Function that resumes sounds and music when game is back in focus.
      * @public
-     * @returns {void}
+     * @returns {Promise<boolean>} True when audio context and ambient recovery are ready.
      */
     resumeOnFocus(): Promise<boolean>;
     /**

package/dist/application/SoundManager/SoundManager.js

@@ -31,9 +31,25 @@ export class SoundManagerInstance {
     };
     musicCatalogue = new Map();
     currentAmbientTrack = null;
+    currentAmbientOffset = 0;
+    loadedSoundAssets = {};
+    audioContextRecoveryPromise = null;
     constructor() {
         this.overrides = this.speedLevelMapper.slow;
     }
+    loadSound(soundName, url) {
+        return new Promise((resolve) => {
+            const sound = Sound.from({
+                url,
+                autoPlay: false,
+                preload: true,
+                volume: this.getVolumeLevel(soundName),
+                loaded: () => resolve()
+            });
+            sound.name = soundName;
+            this.musicCatalogue.set(soundName, sound);
+        });
+    }
     /**
      * Function for loading sounds into pixi
      * @public
@@ -41,22 +57,13 @@ export class SoundManagerInstance {
      * @returns {Promise<void>} - promise that resolves when all sounds are loaded
      */
     async loadSounds(assets) {
+        this.loadedSoundAssets = { ...assets };
         const loadingSoundsPromises = [];
         for (const [soundName, url] of Object.entries(assets)) {
             if (!url) {
                 continue;
             }
-            loadingSoundsPromises.push(new Promise((resolve) => {
-                const sound = Sound.from({
-                    url,
-                    autoPlay: false,
-                    preload: true,
-                    volume: this.getVolumeLevel(soundName),
-                    loaded: () => resolve()
-                });
-                sound.name = soundName;
-                this.musicCatalogue.set(soundName, sound);
-            }));
+            loadingSoundsPromises.push(this.loadSound(soundName, url));
         }
         await Promise.allSettled(loadingSoundsPromises);
     }
@@ -94,19 +101,16 @@ export class SoundManagerInstance {
             sound.stop();
         }
     }
-    stopSoundsForPageHide() {
-        const music = this.getSound(SoundTracks.music);
-        const freeSpinsMusic = this.getSound(SoundTracks.freeSpinsMusic);
-        const isMusicPlaying = Boolean(music?.isPlaying && !music.paused);
-        const isFreeSpinsMusicPlaying = Boolean(freeSpinsMusic?.isPlaying && !freeSpinsMusic.paused);
-        if (isFreeSpinsMusicPlaying) {
-            this.currentAmbientTrack = SoundTracks.freeSpinsMusic;
-        }
-        else if (isMusicPlaying) {
-            this.currentAmbientTrack = SoundTracks.music;
-        }
-        this.stopAmbientMusic();
-        this.stopPlayingFxSounds();
+    pauseSoundsForPageHide() {
+        this.musicCatalogue.forEach((sound, soundName) => {
+            if (!sound.isPlaying || sound.paused) {
+                return;
+            }
+            if (soundName === SoundTracks.freeSpinsMusic || soundName === SoundTracks.music) {
+                this.currentAmbientTrack = soundName;
+            }
+        });
+        sound.pauseAll();
     }
     /**
      * Function for resuming and pausing sound in game
@@ -150,12 +154,15 @@ export class SoundManagerInstance {
                 return;
             }
         }
-        sound.play({
+        const instance = sound.play({
             singleInstance: true,
             loop: soundsToLoop.includes(soundName),
             volume: this.getVolumeLevel(soundName),
             speed: soundName === "cardDrawing" ? 0.8 : 1
         });
+        if (this.isAmbientTrack(soundName) && !(instance instanceof Promise)) {
+            this.trackAmbientPlaybackProgress(soundName, sound, instance);
+        }
     }
     /**
      * Returns the volume level for a given sound track.
@@ -178,10 +185,86 @@ export class SoundManagerInstance {
     getOppositeAmbientTrack(soundName) {
         return soundName === SoundTracks.freeSpinsMusic ? SoundTracks.music : SoundTracks.freeSpinsMusic;
     }
+    getCurrentAmbientTrack() {
+        return (this.currentAmbientTrack ??
+            (RainMan.settingsStore.isFreeSpinsStarted ? SoundTracks.freeSpinsMusic : SoundTracks.music));
+    }
     getSound(soundName) {
         const overrideSoundName = this.overrides[soundName];
         return this.musicCatalogue.get(overrideSoundName ?? soundName);
     }
+    getAmbientPlaybackOffset(sound) {
+        if (!sound.isPlayable || !Number.isFinite(sound.duration) || sound.duration <= 0) {
+            return 0;
+        }
+        return this.currentAmbientOffset % sound.duration;
+    }
+    trackAmbientPlaybackProgress(soundName, sound, instance) {
+        if (!sound.isPlayable || sound.duration <= 0) {
+            return;
+        }
+        instance.on("progress", (progress) => {
+            if (this.currentAmbientTrack !== soundName || !Number.isFinite(progress)) {
+                return;
+            }
+            this.currentAmbientOffset = (progress * sound.duration) % sound.duration;
+        });
+    }
+    /**
+     * Saves active ambient position before the browser interrupts WebAudio playback.
+     * @public
+     * @returns {void}
+     */
+    captureAmbientPlaybackPositionForPageHide() {
+        if (!RainMan.settingsStore.isSoundStarted || !RainMan.settingsStore.shouldPlayAmbientMusic) {
+            return;
+        }
+        const ambientTrack = this.getCurrentAmbientTrack();
+        const ambientSound = this.getSound(ambientTrack);
+        const ambientInstance = ambientSound?.instances.find((instance) => Number.isFinite(instance.progress) && instance.progress > 0);
+        if (!ambientSound || !ambientInstance || !ambientSound.isPlayable || ambientSound.duration <= 0) {
+            return;
+        }
+        this.currentAmbientTrack = ambientTrack;
+        this.currentAmbientOffset = (ambientInstance.progress * ambientSound.duration) % ambientSound.duration;
+    }
+    isIOSWebAudioRuntime() {
+        const userAgent = navigator.userAgent;
+        const platform = navigator.platform;
+        return /iPad|iPhone|iPod/.test(userAgent) || (platform === "MacIntel" && navigator.maxTouchPoints > 1);
+    }
+    async recreatePixiSoundContext() {
+        if (this.audioContextRecoveryPromise) {
+            return this.audioContextRecoveryPromise;
+        }
+        this.audioContextRecoveryPromise = this.recreatePixiSoundContextOnce().finally(() => {
+            this.audioContextRecoveryPromise = null;
+        });
+        return this.audioContextRecoveryPromise;
+    }
+    async recreatePixiSoundContextOnce() {
+        if (!Object.keys(this.loadedSoundAssets).length) {
+            return;
+        }
+        this.musicCatalogue.forEach((sound) => sound.destroy());
+        this.musicCatalogue.clear();
+        try {
+            sound.context.destroy();
+        }
+        catch (error) {
+            console.error("Could not destroy Pixi sound context", error);
+        }
+        sound.init();
+        sound.disableAutoPause = false;
+        const loadingSoundsPromises = [];
+        for (const [soundName, url] of Object.entries(this.loadedSoundAssets)) {
+            if (!url) {
+                continue;
+            }
+            loadingSoundsPromises.push(this.loadSound(soundName, url));
+        }
+        await Promise.allSettled(loadingSoundsPromises);
+    }
     stopAmbientMusic() {
         this.stop(SoundTracks.music);
         this.stop(SoundTracks.freeSpinsMusic);
@@ -196,23 +279,8 @@ export class SoundManagerInstance {
         if (!RainMan.settingsStore.isSoundStarted) {
             return;
         }
-        this.musicCatalogue.forEach((sound, soundName) => {
-            if (sound.paused && sound.isPlaying && sound) {
-                sound.resume();
-            }
-            if (RainMan.settingsStore.shouldPlayAmbientMusic &&
-                !RainMan.settingsStore.isFreeSpinsPlayEnabled &&
-                soundName === SoundTracks.music &&
-                sound.paused) {
-                sound.resume();
-            }
-            if (RainMan.settingsStore.shouldPlayAmbientMusic &&
-                RainMan.settingsStore.isFreeSpinsPlayEnabled &&
-                soundName === SoundTracks.freeSpinsMusic &&
-                sound.paused) {
-                sound.resume();
-            }
-        });
+        sound.resumeAll();
+        this.restoreAmbientPlayback();
     }
     /**
      * Restores currently active ambient loop if browser dropped it while page was inactive.
@@ -227,10 +295,62 @@ export class SoundManagerInstance {
             this.stopAmbientMusic();
             return;
         }
-        const ambientTrack = this.currentAmbientTrack ??
-            (RainMan.settingsStore.isFreeSpinsStarted ? SoundTracks.freeSpinsMusic : SoundTracks.music);
+        const ambientTrack = this.getCurrentAmbientTrack();
         this.play(ambientTrack);
     }
+    /**
+     * Recreates the active ambient WebAudio source after iOS app interruptions.
+     * Existing Pixi instances can report isPlaying=true even when the native audio pipeline is silent.
+     * @private
+     * @returns {void}
+     */
+    restartAmbientPlaybackAfterInterruption() {
+        if (!RainMan.settingsStore.isSoundStarted) {
+            return;
+        }
+        if (!RainMan.settingsStore.shouldPlayAmbientMusic) {
+            this.stopAmbientMusic();
+            return;
+        }
+        const ambientTrack = this.getCurrentAmbientTrack();
+        const ambientSound = this.getSound(ambientTrack);
+        if (!ambientSound) {
+            return;
+        }
+        this.stop(this.getOppositeAmbientTrack(ambientTrack));
+        ambientSound.stop();
+        this.currentAmbientTrack = ambientTrack;
+        const instance = ambientSound.play({
+            singleInstance: true,
+            loop: soundsToLoop.includes(ambientTrack),
+            start: this.getAmbientPlaybackOffset(ambientSound),
+            volume: this.getVolumeLevel(ambientTrack),
+            speed: 1
+        });
+        if (!(instance instanceof Promise)) {
+            this.trackAmbientPlaybackProgress(ambientTrack, ambientSound, instance);
+        }
+    }
+    /**
+     * Restores ambient playback after page visibility change or iOS app interruption.
+     * @public
+     * @returns {boolean} True when audio context is ready after recovery.
+     */
+    async restorePlaybackAfterPageHide() {
+        if (!RainMan.settingsStore.isSoundStarted) {
+            return false;
+        }
+        sound.resumeAll();
+        if (this.isIOSWebAudioRuntime()) {
+            await this.recreatePixiSoundContext();
+        }
+        const isAudioContextRunning = await this.resumeAudioContext();
+        if (!isAudioContextRunning) {
+            return false;
+        }
+        this.restartAmbientPlaybackAfterInterruption();
+        return true;
+    }
     /**
      * Function for pausing all sounds in game
      * If sound is not playing, it will be skipped
@@ -238,7 +358,7 @@ export class SoundManagerInstance {
      * @returns {void}
      */
     pauseAll() {
-        this.musicCatalogue.forEach((sound) => sound.pause());
+        sound.pauseAll();
     }
     /**
      * Function for stopping all sounds in game
@@ -288,7 +408,7 @@ export class SoundManagerInstance {
     /**
      * Function that resumes sounds and music when game is back in focus.
      * @public
-     * @returns {void}
+     * @returns {Promise<boolean>} True when audio context is running.
      */
     async resumeAudioContext() {
         const pixiSoundContext = sound.context;
@@ -307,7 +427,7 @@ export class SoundManagerInstance {
     /**
      * Function that resumes sounds and music when game is back in focus.
      * @public
-     * @returns {void}
+     * @returns {Promise<boolean>} True when audio context and ambient recovery are ready.
      */
     async resumeOnFocus() {
         if (!RainMan.settingsStore.isSoundStarted) {
@@ -317,8 +437,7 @@ export class SoundManagerInstance {
         if (!isAudioContextRunning) {
             return false;
         }
-        this.restoreAmbientPlayback();
-        return true;
+        return this.restorePlaybackAfterPageHide();
     }
     /**
      * Returns information if audio context is ready to play sounds.

package/dist/components/AbstractMainContainer/AbstractMainContainer.js

@@ -563,6 +563,10 @@ export class AbstractMainContainer extends Container {
             this.messageBox.visible = true;
             RainMan.settingsStore.isGambleGameActive = false;
             this._controller.updateGambleValues(RainMan.settingsStore.gambleGameWin);
+            if (RainMan.settingsStore.gambleGameWin > 0) {
+                RainMan.settingsStore.useTakeAction?.();
+            }
+            RainMan.settingsStore.disableSpecialButtons();
             this.gambleGame = null;
         }
         this.hideOverlay();

package/dist/components/GambleGame/GambleGame.js

@@ -88,6 +88,8 @@ export class GambleGame extends Container {
         this.redButton.setOnClick(() => this.handleGamblePlay("red"));
         this.blackButton.setOnClick(() => this.handleGamblePlay("black"));
         this.collectButton.setOnClick(() => {
+            SoundManager.stop("cardDrawing");
+            SoundManager.play("music");
             RainMan.settingsStore.gambleGameWin = this.lastWinAmount;
             RainMan.componentRegistry.get(BUTTONS.gamble).flipDisabledFlag(true);
             SoundManager.play("cardCollect");
@@ -210,8 +212,10 @@ export class GambleGame extends Container {
             this.card.state.addAnimation(0, "idle", true, 0);
             await this.loseDoubleAndWinFields();
             window.setTimeout(() => {
+                SoundManager.stop("cardDrawing");
+                SoundManager.play("music");
                 this.closeGame();
-            }, 2000);
+            }, 500);
         }
     }
     /**

package/dist/components/messageBox/MessageBox.d.ts

@@ -34,6 +34,8 @@ export declare class MessageBox extends Container {
     private possibleWinShown;
     private incentiveMessageShown;
     private winLineIndicatorShown;
+    private winLineIndicatorXOffset;
+    private winLineIndicatorYOffset;
     constructor();
     /**
      * Updates the incentive text displayed in the message box.
@@ -84,6 +86,15 @@ export declare class MessageBox extends Container {
      * @returns {void}
      */
     hideWinLineIndicator(): void;
+    /**
+     * Sets the offset of the win line indicator along the x and y axes. Each time winLineIndicator is shown,
+     * the indicator is positioned at the current offset.
+     * @public
+     * @param {number} xOffset - The amount to move the win line indicator along the x-axis.
+     * @param {number} yOffset - The amount to move the win line indicator along the y-axis.
+     * @returns {void}
+     */
+    setWinWinLineIndicatorOffset(xOffset?: number, yOffset?: number): void;
     /**
      * Function for resizing message box
      * It sets the scale of the message box to the global minimum ratio.

package/dist/components/messageBox/MessageBox.js

@@ -39,6 +39,8 @@ export class MessageBox extends Container {
     possibleWinShown = false;
     incentiveMessageShown = false;
     winLineIndicatorShown = false;
+    winLineIndicatorXOffset = 0;
+    winLineIndicatorYOffset = 0;
     constructor() {
         super();
         this.name = MessageBox.registryName;
@@ -165,6 +167,18 @@ export class MessageBox extends Container {
             this.winLineIndicator = undefined;
         }
     }
+    /**
+     * Sets the offset of the win line indicator along the x and y axes. Each time winLineIndicator is shown,
+     * the indicator is positioned at the current offset.
+     * @public
+     * @param {number} xOffset - The amount to move the win line indicator along the x-axis.
+     * @param {number} yOffset - The amount to move the win line indicator along the y-axis.
+     * @returns {void}
+     */
+    setWinWinLineIndicatorOffset(xOffset, yOffset) {
+        this.winLineIndicatorXOffset += xOffset ?? 0;
+        this.winLineIndicatorYOffset += yOffset ?? 0;
+    }
     /**
      * Function for resizing message box
      * It sets the scale of the message box to the global minimum ratio.
@@ -334,6 +348,12 @@ export class MessageBox extends Container {
         };
         this.winLineIndicator = new WinLineIndicator(winLineTextStyle, getImageForSymbolId, message, symbolIds);
         this.winLineIndicator.y = 50;
+        if (this.winLineIndicatorXOffset) {
+            this.winLineIndicator.x = this.winLineIndicatorXOffset;
+        }
+        if (this.winLineIndicatorYOffset) {
+            this.winLineIndicator.y = this.winLineIndicatorYOffset;
+        }
         this.winLineIndicatorShown = true;
         this.centerTextOnX(this.winLineIndicator);
         this.addChild(this.winLineIndicator);

package/dist/connectivity/serverData.d.ts

@@ -74,6 +74,7 @@ export interface MiniGameInterface {
     };
     extra_data: ExtraData;
     win_amount: number;
+    round_win_amount: number;
     wins: Record<string, RawWin>;
     matrix: {
         height: number;

package/dist/controllers/AbstractController.js

@@ -311,6 +311,7 @@ export class AbstractController {
         if (RainMan.componentRegistry.has(BUTTONS.gamble)) {
             this.buttonsEventManager.initGambleButton(() => {
                 RainMan.settingsStore.isGambleGameAvailable = false;
+                SoundManager.stopAll();
                 this.mainContainer.invokeGambleGame();
             }, !RainMan.settingsStore.isGambleGameAvailable ||
                 RainMan.settingsStore.isPlayingAnyAction ||
@@ -841,6 +842,13 @@ export class AbstractController {
         this.uiController.totalNumberOfFreeSpins += this.getBoughtNumberOfFreeSpins();
         RainMan.componentRegistry.getIfExists(FreeSpinButton.registryName)?.setInteractivity(false);
         RainMan.settingsStore.setIsFreeSpinBought(false);
+        if (this.speedLevelBeforeFreeSpins === null) {
+            this.speedLevelBeforeFreeSpins = RainMan.settingsStore.currentSpeed;
+        }
+        RainMan.settingsStore.setIsTemporarySpeed(false);
+        RainMan.componentRegistry.setSpeedLevel(SPEED_LEVELS.slow);
+        this.uiController.updateShownSpeedLevel(SPEED_LEVELS.slow);
+        this.disableSpeedButton(false);
     }
     /**
      * This function is responsible for getting the number of free spins bought
@@ -903,6 +911,7 @@ export class AbstractController {
             logInfo("Take action can't be performed");
             return;
         }
+        this.shouldPlayNextSpin = false;
         if (this.currentlyPlayedAction !== undefined) {
             this.changeGamePhase(gamePhases.STOPPING_HANDLING_ACTIONS);
             this.stopPlayingSymbolsStreak();
@@ -913,7 +922,7 @@ export class AbstractController {
         if (takeData.status.code === 200) {
             RainMan.settingsStore.isTakeActionAvailable = false;
             logInfo(`💰 Round ${takeData.round_number} ended with balance:`, takeData.balance);
-            this.uiController.currentBalance = takeData.balance;
+            await this.uiController.animateCurrentBalance(takeData.balance);
         }
         else {
             RainMan.settingsStore.isTakeActionAvailable = true;
@@ -1219,7 +1228,9 @@ export class AbstractController {
         }
         await this.performActionsAfterSpin();
         this.freeSpinsWin = gambleWinAmount > 0 ? gambleWinAmount : null;
-        this.gambleGameEnabler(gambleWinAmount);
+        if (!RainMan.globals.isSuperBonusGameEnabled) {
+            this.gambleGameEnabler(gambleWinAmount);
+        }
         if (RainMan.settingsStore.isAutoplayEnabled ||
             (RainMan.settingsStore.howManyFreeSpinsLeft !== 0 && this.shouldAutoplayFreeSpins)) {
             this.handleAutoplayLogic();

package/dist/controllers/UiController.d.ts

@@ -149,7 +149,6 @@ export declare class UiController {
     updateShownPossibleWin(): void;
     /**
      * Shows game pays in a bottom panel, if exists
-     * @param amount
      * @public
      * @returns {void}
      */
@@ -189,6 +188,13 @@ export declare class UiController {
      * @returns {Promise<void>}
      */
     updateDisplayedBalance(amount: number): Promise<void>;
+    /**
+     * Function for animating current balance to a final value.
+     * @public
+     * @param {number} finalBalance - final balance to display
+     * @returns {Promise<void>}
+     */
+    animateCurrentBalance(finalBalance: number): Promise<void>;
     /**
      * Function for resetting win amount
      * @public

package/dist/controllers/UiController.js

@@ -216,7 +216,6 @@ export class UiController {
     }
     /**
      * Shows game pays in a bottom panel, if exists
-     * @param amount
      * @public
      * @returns {void}
      */
@@ -282,6 +281,23 @@ export class UiController {
     async updateDisplayedBalance(amount) {
         this.promisesToSetBalances.push(RainMan.componentRegistry.get(COMPONENTS.creditText).update(amount));
     }
+    /**
+     * Function for animating current balance to a final value.
+     * @public
+     * @param {number} finalBalance - final balance to display
+     * @returns {Promise<void>}
+     */
+    async animateCurrentBalance(finalBalance) {
+        const balanceDiff = ceilToDecimal(finalBalance - this._currentBalance);
+        this._currentBalance = finalBalance;
+        if (balanceDiff === 0) {
+            this.setDisplayedBalance();
+            return;
+        }
+        const animationPromise = RainMan.componentRegistry.get(COMPONENTS.creditText).update(balanceDiff);
+        this.promisesToSetBalances.push(animationPromise);
+        await animationPromise;
+    }
     /**
      * Function for resetting win amount
      * @public

package/dist/loading/AbstractLoadingContainer.js

@@ -24,7 +24,7 @@ export class AbstractLoadingContainer extends Container {
         this.name = "loadingContainer";
         this.x = 0;
         this.y = 0;
-        this.loaderContainer = new SpriteLoadingContainer("./assets/images/materials/texture.png");
+        this.loaderContainer = new SpriteLoadingContainer("./assets/images/materials/texture.webp");
         this.presentationFinishedPromise = new Promise((resolve) => {
             this.resolvePresentationFinished = resolve;
         });

package/dist/stores/SettingsStore.d.ts

@@ -113,6 +113,12 @@ export declare class SettingsStore {
      * @returns {void}
      */
     disableSpecialButtons(): void;
+    /**
+     * Enables special buttons like gamble and take.
+     * @public
+     * @returns {void}
+     */
+    enableSpecialButtons(): void;
     /**
      * Swaps the bet change disabled flag.
      * @public
@@ -338,6 +344,13 @@ export declare class SettingsStore {
      * @returns {void}
      */
     setAutoSpinsCount(count: number): void;
+    /**
+     * Setter for the infinite autoplay flag
+     * @public
+     * @param {boolean} newState new state for infinite autoplay
+     * @returns {void}
+     */
+    setInfinitySpinsEnabled(newState: boolean): void;
     /**
      * Setter for the autoplay enabled flag
      * @public

package/dist/stores/SettingsStore.js

@@ -79,6 +79,7 @@ export class SettingsStore {
     initialAutoplaySettingsState = {
         onAnyWin: false,
         howManyAutoSpinsLeft: INITIAL_AUTO_SPIN_COUNT,
+        infinitySpinsEnabled: false,
         singleWinExceeds: 0,
         balancedIncreased: 0,
         balancedDecreased: 0,
@@ -185,6 +186,21 @@ export class SettingsStore {
             RainMan.componentRegistry.get(BUTTONS.take).flipDisabledFlag(true);
         }
     }
+    /**
+     * Enables special buttons like gamble and take.
+     * @public
+     * @returns {void}
+     */
+    enableSpecialButtons() {
+        if (RainMan.componentRegistry.has(BUTTONS.gamble)) {
+            RainMan.settingsStore.isGambleGameAvailable = true;
+            RainMan.componentRegistry.get(BUTTONS.gamble).flipDisabledFlag(false);
+        }
+        if (RainMan.componentRegistry.has(BUTTONS.take)) {
+            RainMan.settingsStore.isTakeActionAvailable = true;
+            RainMan.componentRegistry.get(BUTTONS.take).flipDisabledFlag(false);
+        }
+    }
     /**
      * Swaps the bet change disabled flag.
      * @public
@@ -576,6 +592,15 @@ export class SettingsStore {
     setAutoSpinsCount(count) {
         this.howManyAutoSpinsLeft = count;
     }
+    /**
+     * Setter for the infinite autoplay flag
+     * @public
+     * @param {boolean} newState new state for infinite autoplay
+     * @returns {void}
+     */
+    setInfinitySpinsEnabled(newState) {
+        this.infinitySpinsEnabled = newState;
+    }
     /**
      * Setter for the autoplay enabled flag
      * @public
@@ -713,6 +738,7 @@ export class SettingsStore {
     resetAutoplaySettings() {
         this.onAnyWin = this.initialAutoplaySettingsState.onAnyWin;
         this.howManyAutoSpinsLeft = this.initialAutoplaySettingsState.howManyAutoSpinsLeft;
+        this.infinitySpinsEnabled = this.initialAutoplaySettingsState.infinitySpinsEnabled;
         this.singleWinExceeds = this.initialAutoplaySettingsState.singleWinExceeds;
         this.balancedIncreased = this.initialAutoplaySettingsState.balancedIncreased;
         this.balancedDecreased = this.initialAutoplaySettingsState.balancedDecreased;

package/dist/utils/common/sound.js

@@ -16,15 +16,16 @@ const interruptedAudioResume = () => {
     window.addEventListener("touchend", resumeAudioOnInterruption, { once: true, passive: true });
 };
 /**
- * Pauses audio when the page goes to the background.
+ * Clears pending foreground recovery when the page goes to the background.
+ * Pixi handles the actual pause state through its WebAudio auto-pause flow.
  * @returns {void}
  */
-const pauseAudio = () => {
+const prepareAudioForPageHide = () => {
     isResumingAudio = false;
     shouldResumeAudioOnInterruption = false;
     removeInterruptedAudioResumeListeners();
     if (RainMan.settingsStore.isSoundEnabled()) {
-        SoundManager.stopSoundsForPageHide();
+        SoundManager.captureAmbientPlaybackPositionForPageHide();
     }
 };
 /**
@@ -71,19 +72,19 @@ function resumeAudioOnInterruption() {
  */
 const handleVisibilityChange = () => {
     if (document.hidden) {
-        pauseAudio();
+        prepareAudioForPageHide();
         return;
     }
-    interruptedAudioResume();
+    resumeAudio();
 };
 /**
  * Sets up audio states for tab switches and iOS app interruptions.
  * @returns {void}
  */
 export const loadSoundsOnTabChange = () => {
-    sound.disableAutoPause = true;
+    sound.disableAutoPause = false;
     document.addEventListener("visibilitychange", handleVisibilityChange);
-    window.addEventListener("pagehide", () => pauseAudio());
-    window.addEventListener("pageshow", () => interruptedAudioResume());
-    window.addEventListener("focus", () => interruptedAudioResume());
+    window.addEventListener("pagehide", () => prepareAudioForPageHide());
+    window.addEventListener("pageshow", () => resumeAudio());
+    window.addEventListener("focus", () => resumeAudio());
 };

package/dist/winComponents/TexturedText.d.ts

@@ -25,6 +25,8 @@ export declare class TexturedText extends UpdatableValueComponent {
      * @returns {void}
      */
     randomizeSet(value: number, _possibleValues: number[]): void;
+    adjustTextureSpriteLength(): void;
+    set(newValue: number): void;
     /**
      * Plays the animation for the text element
      * @public

package/dist/winComponents/TexturedText.js

@@ -18,6 +18,7 @@ export class TexturedText extends UpdatableValueComponent {
         this.registryName = registryName;
         this.valueTextComponent.style = { ...this.valueTextComponent.style, fontSize: 120, padding: 50 };
         this.valueTextComponent.anchor.set(0.5, 0.5);
+        this.updateFontSize();
         if (textureName) {
             this.textureSprite = new TilingSprite(getTexture(textureName), this.valueTextComponent.width, this.valueTextComponent.height);
             this.textureSprite.scale.set(1.1);
@@ -48,6 +49,17 @@ export class TexturedText extends UpdatableValueComponent {
         this.valueTextComponent.style.fontSize = -10 * new MoneyText(value).toString().length + this.baseFontSize;
         super.update(value, 1);
     }
+    adjustTextureSpriteLength() {
+        if (!this.textureSprite) {
+            return;
+        }
+        this.textureSprite.width = this.valueTextComponent.width;
+        this.textureSprite.height = this.valueTextComponent.height;
+    }
+    set(newValue) {
+        super.set(newValue);
+        this.adjustTextureSpriteLength();
+    }
     /**
      * Plays the animation for the text element
      * @public
@@ -89,5 +101,6 @@ export class TexturedText extends UpdatableValueComponent {
      */
     updateFontSize() {
         this.valueTextComponent.style.fontSize = -10 * super.value.length + this.baseFontSize;
+        this.adjustTextureSpriteLength();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pixi-rainman-game-engine",
-    "version": "0.3.41",
+    "version": "0.3.42-beta.1",
     "description": "This repository contains all of the mechanics that used in rainman games.",
     "main": "./dist/index.js",
     "module": "./dist/index.js",