pixi-rainman-game-engine 0.3.40 → 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/SettingsUI/components/SpeedSwitchButton/index.jsx

@@ -5,13 +5,13 @@ export const SpeedButtonSwitch = observer(() => {
     const speedLevelMapper = {
         slow: "turtle",
         normal: "rabbit",
-        fast: "cheetah",
+        fast: "cheetah"
     };
     const { settingStore } = useStores();
     const { currentSpeed } = settingStore;
     return (<label className="switch turtle-switch speed-level-id">
             <span className="turtle-switch-round-box"/>
-            <img className="turtle-switch__icon" src={`assets/settings/speed-${speedLevelMapper[currentSpeed]}.png`}/>
+            <img className="turtle-switch__icon" src={`assets/settings/speed-${speedLevelMapper[currentSpeed]}.webp`}/>
             <div className="dot-container">
                 {Array.from({ length: 3 }).map((_, i) => (<div key={i} className={`white-dot ${i < settingStore.indexOfSpeedLevel ? "white-dot--active" : ""}`}/>))}
             </div>

package/dist/SettingsUI/components/VolumeSettings/volume.css

@@ -36,7 +36,7 @@
     bottom: 5px;
     width: 30px;
     height: 30px;
-    background-image: url("/assets/settings/sound-icon.png");
+    background-image: url("/assets/settings/sound-icon.webp");
     background-position: center;
     background-size: contain;
     background-repeat: no-repeat;

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

@@ -1,7 +1,12 @@
 import { Sound, sound } from "@pixi/sound";
 import { RainMan } from "../../Rainman";
 import { SoundTracks } from "./types";
-const soundsToLoop = [SoundTracks.mysteryFxLoop, SoundTracks.music, SoundTracks.freeSpinsMusic];
+const soundsToLoop = [
+    SoundTracks.mysteryFxLoop,
+    SoundTracks.music,
+    SoundTracks.freeSpinsMusic,
+    SoundTracks.cardDrawing
+];
 export const pixiSoundContext = sound.context;
 /**
  * Class for managing sound in game, uses the pixi sound library
@@ -26,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
@@ -36,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);
     }
@@ -89,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
@@ -145,11 +154,15 @@ export class SoundManagerInstance {
                 return;
             }
         }
-        sound.play({
+        const instance = sound.play({
             singleInstance: true,
             loop: soundsToLoop.includes(soundName),
-            volume: this.getVolumeLevel(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.
@@ -172,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);
@@ -190,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.
@@ -221,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
@@ -232,7 +358,7 @@ export class SoundManagerInstance {
      * @returns {void}
      */
     pauseAll() {
-        this.musicCatalogue.forEach((sound) => sound.pause());
+        sound.pauseAll();
     }
     /**
      * Function for stopping all sounds in game
@@ -282,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;
@@ -301,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) {
@@ -311,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/application/SoundManager/types.d.ts

@@ -64,6 +64,10 @@ export interface SoundTracks {
     rouletteStop: "rouletteStop";
     mysterySymbol: "mysterySymbol";
     jackpotWin: "jackpotWin";
+    cardWin: "cardWin";
+    cardLose: "cardLose";
+    cardDrawing: "cardDrawing";
+    cardCollect: "cardCollect";
 }
 export type SoundTrack = SoundTracks[keyof SoundTracks];
 /**

package/dist/application/SoundManager/types.js

@@ -61,5 +61,9 @@ export const SoundTracks = {
     rouletteStart: "rouletteStart",
     rouletteLoop: "rouletteLoop",
     rouletteStop: "rouletteStop",
-    jackpotWin: "jackpotWin"
+    jackpotWin: "jackpotWin",
+    cardWin: "cardWin",
+    cardLose: "cardLose",
+    cardDrawing: "cardDrawing",
+    cardCollect: "cardCollect"
 };

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

@@ -1,6 +1,7 @@
 import i18next from "i18next";
 import { Container, Sprite, Text, Texture } from "pixi.js";
 import { Spine } from "pixi-spine";
+import { SoundManager } from "../../application";
 import { COLOR_BUTTONS_CENTER_OFFSET, COLOR_BUTTONS_SCALE_X, gamblesTextStyle } from "../../constants";
 import { RainMan } from "../../Rainman";
 import { getDeviceOrientation, getSpineData, globalMinRatio } from "../../utils";
@@ -60,6 +61,7 @@ export class GambleGame extends Container {
         this.addChildrenOnce();
         this.bindButtonsOnce();
         this.resize();
+        SoundManager.play("cardDrawing");
     }
     configureButtons() {
         this.collectButton.eventMode = "static";
@@ -86,8 +88,11 @@ 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");
             this.resolver(this.balanceValue);
         });
     }
@@ -170,6 +175,8 @@ export class GambleGame extends Container {
         if (this.lastWinAmount === 0) {
             return;
         }
+        SoundManager.stop("cardDrawing");
+        this.collectButton.flipDisabledFlag(true);
         this.redButton.flipDisabledFlag(true);
         this.blackButton.flipDisabledFlag(true);
         this.card.state.addAnimation(0, "wait", true, 0);
@@ -178,6 +185,12 @@ export class GambleGame extends Container {
             this.card.state.clearTracks();
             this.card.state.clearListeners();
             this.card.state.addAnimation(0, gambleData.winning_card, false, 0);
+            if (gambleData.win_amount > 0) {
+                SoundManager.play("cardWin");
+            }
+            else {
+                SoundManager.play("cardLose");
+            }
             this.card.state.addListener({ complete: () => resolve() });
         });
         if (gambleData.win_amount > 0) {
@@ -186,6 +199,8 @@ export class GambleGame extends Container {
             this.blackButton.flipDisabledFlag(false);
             this.redButton.eventMode = "static";
             this.blackButton.eventMode = "static";
+            SoundManager.play("cardDrawing");
+            this.collectButton.flipDisabledFlag(false);
         }
         this.card.state.addAnimation(0, "wait2", true, 0);
         this.lastWinAmount = gambleData.win_amount;
@@ -197,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/frame/AbstractColumnsContainer.d.ts

@@ -95,6 +95,16 @@ export declare abstract class AbstractColumnsContainer extends Container impleme
      * @returns {Promise<void>}
      */
     configBlindSpin(finalSymbolReels: SymbolReels, afterSpinResolver: (value: void | PromiseLike<void>) => void, indexesOfReelsToExtendSpinningTime: number[]): Promise<void>;
+    /**
+     * This function is responsible for setting symbols in single column
+     * @public
+     * @param {SymbolReels} finalSymbolReels final symbols in columns
+     * @param {(value: void | PromiseLike<void>) => void} afterSpinResolver resolver for after spin
+     * @param {number} columnIndex index of column to configure
+     * @param {boolean} shouldExtendSpinningTime determines whether to extend spinning time for the column
+     * @returns {Promise<void>}
+     */
+    configBlindSpinForColumn(finalSymbolReels: SymbolReels, afterSpinResolver: (value: void | PromiseLike<void>) => void, columnIndex: number, shouldExtendSpinningTime?: boolean): Promise<void>;
     /**
      * This cancels the timeout, removes the stored delayed action and invalidates
      * any older timeout callback that might still try to execute later.
@@ -227,4 +237,12 @@ export declare abstract class AbstractColumnsContainer extends Container impleme
      * @returns {PlayableAction[]} - array of playable actions
      */
     protected prepareConfiguringReelsEnd(finalSymbolReels: SymbolReels): PlayableAction[];
+    /**
+     * Function for preparing configuring for single reel
+     * @protected
+     * @param {SymbolReels} finalSymbolReels - final symbol reels
+     * @param {number} columnIndex - column index
+     * @returns {PlayableAction} - playable action
+     */
+    protected prepareConfiguringReelsEndForIndex(finalSymbolReels: SymbolReels, columnIndex: number): PlayableAction;
 }

package/dist/components/frame/AbstractColumnsContainer.js

@@ -187,6 +187,63 @@ export class AbstractColumnsContainer extends Container {
             resolve();
         });
     }
+    /**
+     * This function is responsible for setting symbols in single column
+     * @public
+     * @param {SymbolReels} finalSymbolReels final symbols in columns
+     * @param {(value: void | PromiseLike<void>) => void} afterSpinResolver resolver for after spin
+     * @param {number} columnIndex index of column to configure
+     * @param {boolean} shouldExtendSpinningTime determines whether to extend spinning time for the column
+     * @returns {Promise<void>}
+     */
+    async configBlindSpinForColumn(finalSymbolReels, afterSpinResolver, columnIndex, shouldExtendSpinningTime = false) {
+        return new Promise(async (resolve) => {
+            this.clearPendingMysteryDelay();
+            this.mysteryFxGeneration = 0;
+            this.skipRemainingMysteryFxs = false;
+            const frame = RainMan.componentRegistry.get(AbstractFrame.registryName);
+            const column = this.allColumns[columnIndex];
+            if (column === undefined) {
+                afterSpinResolver();
+                resolve();
+                return;
+            }
+            const configureSpinAction = this.prepareConfiguringReelsEndForIndex(finalSymbolReels, columnIndex);
+            if (this.quickReelsStop ||
+                this.skipRemainingMysteryFxs ||
+                RainMan.settingsStore.currentSpeed === SPEED_LEVELS.fast) {
+                await configureSpinAction();
+                SoundManager.play(SoundTracks.allRollStops);
+            }
+            else if (shouldExtendSpinningTime) {
+                this.currentColumn = column;
+                column.adaptToSpeed(RainMan.settingsStore.currentSpeed);
+                frame.invokeMysteryFx(column.x, column.y);
+                this.skipScatterDelay = configureSpinAction;
+                await column.speedUpForMysterySpin(100, 1500);
+                if (this.quickReelsStop || this.skipRemainingMysteryFxs) {
+                    await column.changeVelocity(Speed.STOP, 0, frame);
+                }
+                else {
+                    if (!RainMan.settingsStore.isAutoplayEnabled ||
+                        (RainMan.settingsStore.isAutoplayEnabled && !this.quickReelsStop)) {
+                        this.scheduleMysteryDelay(configureSpinAction, RainMan.config.durationOfActions.scatterDelayerTime);
+                    }
+                    await column.changeVelocity(Speed.STOP, RainMan.config.durationOfActions.scatterSpinningTime, frame);
+                }
+                frame.destroyMysteryFx();
+            }
+            else {
+                await configureSpinAction();
+            }
+            await column.getStopPromise();
+            this.clearPendingMysteryDelay();
+            this.mysteryFxGeneration = 0;
+            this.skipRemainingMysteryFxs = false;
+            afterSpinResolver();
+            resolve();
+        });
+    }
     /**
      * This cancels the timeout, removes the stored delayed action and invalidates
      * any older timeout callback that might still try to execute later.
@@ -441,4 +498,20 @@ export class AbstractColumnsContainer extends Container {
             this.currentColumn = null;
         });
     }
+    /**
+     * Function for preparing configuring for single reel
+     * @protected
+     * @param {SymbolReels} finalSymbolReels - final symbol reels
+     * @param {number} columnIndex - column index
+     * @returns {PlayableAction} - playable action
+     */
+    prepareConfiguringReelsEndForIndex(finalSymbolReels, columnIndex) {
+        const column = this.allColumns[columnIndex];
+        return async () => {
+            this.currentColumn = column;
+            column.configBlindSpin(finalSymbolReels[columnIndex]);
+            await column.getTriggersPromise();
+            this.currentColumn = null;
+        };
+    }
 }

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 ||
@@ -322,7 +323,6 @@ export class AbstractController {
         if (RainMan.componentRegistry.has(BUTTONS.take)) {
             this.buttonsEventManager.initTakeButton(() => {
                 RainMan.settingsStore.useTakeAction?.();
-                this.uiController.currentBalance = RainMan.settingsStore.balanceAfterSpin;
                 RainMan.settingsStore.isTakeActionAvailable = false;
                 RainMan.settingsStore.isGambleGameAvailable = false;
                 if (RainMan.componentRegistry.has(BUTTONS.gamble)) {
@@ -842,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
@@ -904,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();
@@ -914,6 +922,7 @@ export class AbstractController {
         if (takeData.status.code === 200) {
             RainMan.settingsStore.isTakeActionAvailable = false;
             logInfo(`💰 Round ${takeData.round_number} ended with balance:`, 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();
@@ -1237,6 +1248,7 @@ export class AbstractController {
         if (this.speedLevelBeforeFreeSpins !== null &&
             !RainMan.settingsStore.isFreeSpinsPlayEnabled &&
             !RainMan.globals.isSuperBonusGameEnabled) {
+            RainMan.settingsStore.setIsTemporarySpeed(false);
             RainMan.componentRegistry.setSpeedLevel(this.speedLevelBeforeFreeSpins);
             this.uiController.updateShownSpeedLevel(this.speedLevelBeforeFreeSpins);
             this.speedLevelBeforeFreeSpins = null;

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.40",
+    "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",