pixi-rainman-game-engine 0.3.35 → 0.3.36

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

@@ -13,7 +13,7 @@ export const CloseModalButton = observer(({ layerId, afterClose }) => {
             settingStore.setSpeedPopupVisibility?.("none");
             settingStore.isSpeedModalShown = false;
         }
-        if (isBetDisabled) {
+        if (!isBetDisabled) {
             settingStore.enableButtons?.();
         }
         afterClose?.();

package/dist/application/SoundManager/SoundManager.js

@@ -186,10 +186,7 @@ export class SoundManagerInstance {
         if (!ambientMusic || ambientMusic.isPlaying) {
             return;
         }
-        if (ambientMusic.paused) {
-            ambientMusic.resume();
-            return;
-        }
+        ambientMusic.stop();
         this.play(ambientTrack);
     }
     /**
@@ -266,6 +263,7 @@ export class SoundManagerInstance {
         if (!this.isAudioContextRunning()) {
             return false;
         }
+        sound.resumeAll();
         this.restoreAmbientPlayback();
         return true;
     }

package/dist/components/AbstractMainContainer/AbstractMainContainer.js

@@ -893,9 +893,6 @@ export class AbstractMainContainer extends Container {
             this.mysteryBonusContainer.resize();
             this.addChild(this.mysteryBonusContainer);
         }
-        if (this.gambleGame) {
-            this.gambleGame.resize();
-        }
         if (this.bottomPanel) {
             this.bottomPanel.scale.set(resizingHelper);
             this.bottomPanel.width = RainMan.app.screen.width;
@@ -915,6 +912,10 @@ export class AbstractMainContainer extends Container {
             this.addChild(this._buyFreeSpinsPlate);
             this._buyFreeSpinsPlate.resize();
         }
+        if (this.gambleGame) {
+            this.gambleGame.resize();
+            this.addChild(this.gambleGame);
+        }
         RainMan.settingsStore.popupPaytableRepositionCallback?.();
     }
     /**

package/dist/components/GambleGame/GambleGame.d.ts

@@ -26,6 +26,11 @@ export declare class GambleGame extends Container {
     private readonly previousGamblesContainer;
     private previousGambles;
     constructor(cardSpineName: string, resolver: (newBalance: number) => void, lastWinAmount: number, balanceValue: number);
+    private configureButtons;
+    private addChildrenOnce;
+    private bindButtonsOnce;
+    private bringButtonsToFront;
+    private restoreButtonEventModes;
     /**
      * Function for showing previous gamble
      * @private
@@ -68,8 +73,13 @@ export declare class GambleGame extends Container {
     resize(): void;
     /**
      * Function for initializing child positions
+     * @param width
+     * @param height
      * @private
      * @returns {void}
      */
     private initChildPositions;
+    private layoutPc;
+    private layoutMobilePortrait;
+    private layoutMobileLandscape;
 }

package/dist/components/GambleGame/GambleGame.js

@@ -3,7 +3,7 @@ import { Container, Sprite, Text, Texture } from "pixi.js";
 import { Spine } from "pixi-spine";
 import { COLOR_BUTTONS_CENTER_OFFSET, COLOR_BUTTONS_SCALE_X, gamblesTextStyle } from "../../constants";
 import { RainMan } from "../../Rainman";
-import { getSpineData, globalMinRatio } from "../../utils";
+import { getDeviceOrientation, getSpineData, globalMinRatio } from "../../utils";
 import { BlackButton, BUTTONS, CollectButton, RedButton } from "../buttons";
 import { GambleUpdatableText } from "../updatable";
 /**
@@ -37,7 +37,10 @@ export class GambleGame extends Container {
         this.resolver = resolver;
         this.lastWinAmount = lastWinAmount;
         this.balanceValue = balanceValue;
+        this.x = 0;
+        this.y = 0;
         this.eventMode = "static";
+        this.interactiveChildren = true;
         this.background = new Sprite(Texture.from("black-bg.png"));
         this.frame = new Sprite(Texture.from("frame-v2.png"));
         this.previousGamblesText = new Text(i18next.t("previousCards"), gamblesTextStyle());
@@ -53,6 +56,33 @@ export class GambleGame extends Container {
         this.card.state.addAnimation(0, "wait2", true, 0);
         this.currentWin = new GambleUpdatableText(GambleGame.gambleCurrentWinRegistryName, i18next.t("currentWinGamble"), this.lastWinAmount, 1);
         this.gambleWin = new GambleUpdatableText(GambleGame.gambleWinRegistryName, i18next.t("gambleToWin"), this.lastWinAmount * 2, 2);
+        this.configureButtons();
+        this.addChildrenOnce();
+        this.bindButtonsOnce();
+        this.resize();
+    }
+    configureButtons() {
+        this.collectButton.eventMode = "static";
+        this.redButton.eventMode = "static";
+        this.blackButton.eventMode = "static";
+        this.collectButton.cursor = "pointer";
+        this.redButton.cursor = "pointer";
+        this.blackButton.cursor = "pointer";
+    }
+    addChildrenOnce() {
+        this.addChild(this.background);
+        this.addChild(this.frame);
+        this.addChild(this.card);
+        this.addChild(this.previousGamblesText);
+        this.addChild(this.previousGamblesContainer);
+        this.addChild(this.currentWin);
+        this.addChild(this.gambleWin);
+        this.addChild(this.collectText);
+        this.addChild(this.collectButton);
+        this.addChild(this.redButton);
+        this.addChild(this.blackButton);
+    }
+    bindButtonsOnce() {
         this.redButton.setOnClick(() => this.handleGamblePlay("red"));
         this.blackButton.setOnClick(() => this.handleGamblePlay("black"));
         this.collectButton.setOnClick(() => {
@@ -60,7 +90,22 @@ export class GambleGame extends Container {
             RainMan.componentRegistry.get(BUTTONS.gamble).flipDisabledFlag(true);
             this.resolver(this.balanceValue);
         });
-        this.resize();
+    }
+    bringButtonsToFront() {
+        this.addChild(this.collectButton);
+        this.addChild(this.redButton);
+        this.addChild(this.blackButton);
+    }
+    restoreButtonEventModes() {
+        if (!this.collectButton.disabled) {
+            this.collectButton.eventMode = "static";
+        }
+        if (!this.redButton.disabled) {
+            this.redButton.eventMode = "static";
+        }
+        if (!this.blackButton.disabled) {
+            this.blackButton.eventMode = "static";
+        }
     }
     /**
      * Function for showing previous gamble
@@ -70,11 +115,15 @@ export class GambleGame extends Container {
      */
     showPreviousGambles(previousGambles) {
         const { width } = RainMan.app.screen;
-        this.previousGambles.forEach((gambleCard) => this.previousGamblesContainer.removeChild(gambleCard));
+        this.previousGambles.forEach((gambleCard) => {
+            this.previousGamblesContainer.removeChild(gambleCard);
+            gambleCard.destroy();
+        });
         this.previousGambles = previousGambles.map((gambleCard, index) => {
             const card = new Sprite(Texture.from(`${gambleCard}-small.png`));
-            card.scale.set(0.45);
+            getDeviceOrientation() === "mobile-landscape" ? card.scale.set(0.3) : card.scale.set(0.45);
             card.x = index * (card.width + 10);
+            card.y = 0;
             this.previousGamblesContainer.addChild(card);
             return card;
         });
@@ -125,7 +174,6 @@ export class GambleGame extends Container {
         this.blackButton.flipDisabledFlag(true);
         this.card.state.addAnimation(0, "wait", true, 0);
         const gambleData = await window.connectionWrapper.fetchGambleData(RainMan.settingsStore.roundNumber, this.lastWinAmount, choice);
-        this.balanceValue = gambleData.balance + gambleData.win_amount;
         this.balanceValue = gambleData.balanceAfterSpin;
         await new Promise((resolve) => {
             this.card.state.clearTracks();
@@ -137,20 +185,21 @@ export class GambleGame extends Container {
             await this.updateDoubleAndWinFields(Math.max(gambleData.win_amount, 0));
             this.redButton.flipDisabledFlag(false);
             this.blackButton.flipDisabledFlag(false);
+            this.redButton.eventMode = "static";
+            this.blackButton.eventMode = "static";
         }
         this.card.state.addAnimation(0, "wait2", true, 0);
         this.lastWinAmount = gambleData.win_amount;
         this.showPreviousGambles(gambleData.previous_gambles);
+        this.bringButtonsToFront();
         if (gambleData.win_amount === 0) {
             this.redButton.flipDisabledFlag(true);
             this.blackButton.flipDisabledFlag(true);
             this.card.state.addAnimation(0, "idle", true, 0);
-            Promise.all([
-                this.loseDoubleAndWinFields(),
-                setTimeout(() => {
-                    this.closeGame();
-                }, 2000)
-            ]);
+            await this.loseDoubleAndWinFields();
+            window.setTimeout(() => {
+                this.closeGame();
+            }, 2000);
         }
     }
     /**
@@ -162,68 +211,123 @@ export class GambleGame extends Container {
         const { width, height } = RainMan.app.screen;
         this.x = 0;
         this.y = 0;
-        this.width = width;
-        this.height = height;
-        this.initChildPositions();
+        this.scale.set(1);
+        this.initChildPositions(width, height);
+        this.restoreButtonEventModes();
+        this.bringButtonsToFront();
     }
     /**
      * Function for initializing child positions
+     * @param width
+     * @param height
      * @private
      * @returns {void}
      */
-    initChildPositions() {
-        this.removeChild(this.background);
-        this.removeChild(this.frame);
-        this.removeChild(this.previousGamblesText);
-        this.removeChild(this.collectButton);
-        this.removeChild(this.collectText);
-        this.removeChild(this.redButton);
-        this.removeChild(this.blackButton);
-        this.removeChild(this.card);
-        this.removeChild(this.currentWin);
-        this.removeChild(this.gambleWin);
-        this.removeChild(this.previousGamblesContainer);
-        const { width, height } = RainMan.app.screen;
+    initChildPositions(width, height) {
+        const ratio = globalMinRatio();
+        const deviceOrientation = getDeviceOrientation();
+        const centerX = width / 2;
+        this.background.x = 0;
+        this.background.y = 0;
         this.background.width = width;
         this.background.height = height;
+        this.frame.x = 0;
+        this.frame.y = 0;
         this.frame.width = width;
         this.frame.height = height;
-        const CENTER = RainMan.app.screen.width / 2;
         const previousGambles = window.connectionWrapper.getLastGambleResponse()?.previous_gambles || [];
-        this.previousGamblesText.x = CENTER - this.previousGamblesText.width / 2;
+        this.previousGamblesText.x = centerX - this.previousGamblesText.width / 2;
         this.previousGamblesText.y = 20;
+        if (deviceOrientation === "mobile-landscape") {
+            this.previousGamblesText.scale.set(0.38);
+            this.previousGamblesText.y = 6;
+        }
+        else {
+            this.previousGamblesText.scale.set(1);
+            this.previousGamblesText.y = 20;
+        }
+        this.previousGamblesText.x = centerX - this.previousGamblesText.width / 2;
         this.showPreviousGambles(previousGambles);
-        this.card.scale.set(globalMinRatio() * 0.8);
-        this.card.x = CENTER;
-        this.card.y = height / 2;
-        this.collectText.x = CENTER;
+        if (deviceOrientation === "pc") {
+            this.layoutPc(width, height, ratio);
+            return;
+        }
+        if (deviceOrientation === "mobile-portrait") {
+            this.layoutMobilePortrait(width, height, ratio);
+            return;
+        }
+        this.layoutMobileLandscape(width, height, ratio);
+    }
+    layoutPc(width, height, ratio) {
+        const centerX = width / 2;
+        const centerY = height / 2;
+        this.card.scale.set(ratio * 0.8);
+        this.card.x = centerX;
+        this.card.y = centerY;
+        this.collectText.x = centerX;
         this.collectText.y = height - this.collectText.height;
-        this.collectButton.scale.set(globalMinRatio() * 0.6);
-        this.collectButton.x = CENTER;
+        this.collectButton.scale.set(ratio * 0.6);
+        this.collectButton.x = centerX;
         this.collectButton.y = this.collectText.y - this.collectButton.height - 30;
-        this.redButton.scale.set(globalMinRatio() * COLOR_BUTTONS_SCALE_X);
-        const COLOR_BUTTONS_Y = this.card.y - this.redButton.height / 2;
-        this.redButton.x = CENTER - COLOR_BUTTONS_CENTER_OFFSET - this.redButton.width;
-        this.redButton.y = COLOR_BUTTONS_Y;
-        this.blackButton.scale.set(globalMinRatio() * COLOR_BUTTONS_SCALE_X);
-        this.blackButton.x = CENTER + COLOR_BUTTONS_CENTER_OFFSET;
-        this.blackButton.y = COLOR_BUTTONS_Y;
-        this.currentWin.scale.set(globalMinRatio());
-        this.currentWin.y = height - this.currentWin.height;
+        this.redButton.scale.set(ratio * COLOR_BUTTONS_SCALE_X);
+        this.blackButton.scale.set(ratio * COLOR_BUTTONS_SCALE_X);
+        this.redButton.x = centerX - COLOR_BUTTONS_CENTER_OFFSET - this.redButton.width;
+        this.redButton.y = this.card.y - this.redButton.height / 2;
+        this.blackButton.x = centerX + COLOR_BUTTONS_CENTER_OFFSET;
+        this.blackButton.y = this.card.y - this.redButton.height / 2;
+        this.currentWin.scale.set(ratio);
+        this.gambleWin.scale.set(ratio);
         this.currentWin.x = width / 4;
-        this.gambleWin.scale.set(globalMinRatio());
-        this.gambleWin.y = height - this.gambleWin.height;
+        this.currentWin.y = height - this.currentWin.height;
         this.gambleWin.x = (width * 3) / 4;
-        this.addChild(this.background);
-        this.addChild(this.frame);
-        this.addChild(this.previousGamblesText);
-        this.addChild(this.collectButton);
-        this.addChild(this.collectText);
-        this.addChild(this.redButton);
-        this.addChild(this.blackButton);
-        this.addChild(this.card);
-        this.addChild(this.currentWin);
-        this.addChild(this.gambleWin);
-        this.addChild(this.previousGamblesContainer);
+        this.gambleWin.y = height - this.gambleWin.height;
+    }
+    layoutMobilePortrait(width, height, ratio) {
+        const centerX = width / 2;
+        this.card.scale.set(ratio * 0.65);
+        this.card.x = centerX;
+        this.card.y = height * 0.4;
+        this.collectText.x = centerX;
+        this.collectText.y = height - this.collectText.height;
+        this.collectButton.scale.set(ratio * 0.6);
+        this.collectButton.x = centerX;
+        this.collectButton.y = this.collectText.y - this.collectButton.height - 30;
+        this.redButton.scale.set(ratio * 0.7);
+        this.blackButton.scale.set(ratio * 0.7);
+        this.redButton.x = centerX - this.redButton.width - 20;
+        this.redButton.y = this.card.y + this.card.height / 2 + 30;
+        this.blackButton.x = centerX + 20;
+        this.blackButton.y = this.card.y + this.card.height / 2 + 30;
+        this.currentWin.scale.set(ratio);
+        this.gambleWin.scale.set(ratio);
+        this.currentWin.x = width * 0.25;
+        this.currentWin.y = this.collectButton.y - this.currentWin.height - 20;
+        this.gambleWin.x = width * 0.75;
+        this.gambleWin.y = this.collectButton.y - this.currentWin.height - 20;
+    }
+    layoutMobileLandscape(width, height, ratio) {
+        const centerX = width / 2;
+        const centerY = height / 2;
+        this.card.scale.set(ratio * 0.72);
+        this.card.x = centerX;
+        this.card.y = centerY - 18;
+        this.collectText.scale.set(0.55);
+        this.collectText.x = centerX;
+        this.collectText.y = height - 28;
+        this.collectButton.scale.set(ratio * 0.65);
+        this.collectButton.x = centerX;
+        this.collectButton.y = this.collectText.y - this.collectButton.height - 16;
+        this.redButton.scale.set(ratio * COLOR_BUTTONS_SCALE_X * 1.18);
+        this.blackButton.scale.set(ratio * COLOR_BUTTONS_SCALE_X * 1.18);
+        this.redButton.x = centerX - COLOR_BUTTONS_CENTER_OFFSET * 0.68 - this.redButton.width;
+        this.redButton.y = this.card.y - this.redButton.height / 2;
+        this.blackButton.x = centerX + COLOR_BUTTONS_CENTER_OFFSET * 0.68;
+        this.blackButton.y = this.card.y - this.redButton.height / 2;
+        this.currentWin.scale.set(ratio * 1.45);
+        this.gambleWin.scale.set(ratio * 1.45);
+        this.currentWin.x = width * 0.24;
+        this.currentWin.y = height - this.currentWin.height / 2 - 8;
+        this.gambleWin.x = width * 0.8;
+        this.gambleWin.y = height - this.gambleWin.height / 2 - 8;
     }
 }

package/dist/components/updatable/UpdatableValueComponent.d.ts

@@ -22,6 +22,7 @@ export declare abstract class UpdatableValueComponent extends Container implemen
     protected tween: TWEEN.Tween<{
         value: number;
     }> | null;
+    private readonly animateTick;
     limitValue: number | null;
     protected countingDivider: number;
     readonly speedLevelMapper: SpeedLevelDirectory<number>;

package/dist/components/updatable/UpdatableValueComponent.js

@@ -23,6 +23,7 @@ export class UpdatableValueComponent extends Container {
     valueTextComponent;
     shouldBeUpdated = false;
     tween = null;
+    animateTick = () => this.animate();
     limitValue = null;
     countingDivider;
     speedLevelMapper = {
@@ -68,7 +69,8 @@ export class UpdatableValueComponent extends Container {
     }
     async update(newValue, time = RainMan.config.durationOfActions.updatableTextCountingDuration) {
         this.finalValue = newValue;
-        Ticker.shared.add(() => this.animate());
+        Ticker.shared.remove(this.animateTick);
+        Ticker.shared.add(this.animateTick);
         await this.initAnimation(newValue, time / this.countingDivider);
     }
     /**
@@ -78,7 +80,8 @@ export class UpdatableValueComponent extends Container {
      * @returns {Promise<void>} A promise that resolves when the update is complete.
      */
     async loseUpdate(time = RainMan.config.durationOfActions.updatableTextCountingDuration) {
-        Ticker.shared.add(() => this.animate());
+        Ticker.shared.remove(this.animateTick);
+        Ticker.shared.add(this.animateTick);
         await this.initAnimation(0, time / this.countingDivider, true);
     }
     /**
@@ -162,7 +165,7 @@ export class UpdatableValueComponent extends Container {
                 if (!this.shouldBeUpdated) {
                     this.tween?.stop();
                     this.tween = null;
-                    Ticker.shared.remove(() => this.animate());
+                    Ticker.shared.remove(this.animateTick);
                     return;
                 }
                 this.changeCurrentWin(value);
@@ -188,11 +191,10 @@ export class UpdatableValueComponent extends Container {
      * @returns {void}
      */
     setResultAndClearTween(finalValue) {
-        if (this.shouldBeUpdated)
-            return;
+        this.shouldBeUpdated = false;
         this.tween?.stop();
         this.tween = null;
-        Ticker.shared.remove(() => this.animate());
+        Ticker.shared.remove(this.animateTick);
         this.changeCurrentWin(finalValue);
     }
     /**

package/dist/connectivity/wins.d.ts

@@ -33,6 +33,9 @@ export type EggWin = BaseWin & {
 export type GoldWin = BaseWin & {
     type: typeof PossibleWins.gold;
 };
+export type PearlWin = BaseWin & {
+    type: typeof PossibleWins.pearl;
+};
 export type BigWin = BaseWin & {
     type: typeof PossibleWins.bigWin;
 };
@@ -60,7 +63,7 @@ export type JackpotWin = BaseWin & {
 export type CoinWin = BaseWin & {
     type: typeof PossibleWins.coin;
 };
-export type Win = StreakWin | FreeSpinWin | GambleWin | MysteryWin | EggWin | GoldWin | BigWin | BonusWin | SuperBonusWin | ScatterWin | RouletteWin | JackpotWin | CoinWin | MultiWin | JokerWin;
+export type Win = StreakWin | FreeSpinWin | GambleWin | MysteryWin | EggWin | GoldWin | BigWin | PearlWin | BonusWin | SuperBonusWin | ScatterWin | RouletteWin | JackpotWin | CoinWin | MultiWin | JokerWin;
 /**
  * Type represents data that come from backend
  * @typedef {WinDetails}

package/dist/constants/wins.d.ts

@@ -20,4 +20,5 @@ export declare const PossibleWins: {
     readonly superBonus: "super-bonus";
     readonly joker: "joker";
     readonly multi: "multi";
+    readonly pearl: "pearl";
 };

package/dist/constants/wins.js

@@ -19,5 +19,6 @@ export const PossibleWins = {
     bonus: "bonus",
     superBonus: "super-bonus",
     joker: "joker",
-    multi: "multi"
+    multi: "multi",
+    pearl: "pearl"
 };

package/dist/controllers/AbstractController.js

@@ -387,6 +387,7 @@ export class AbstractController {
         const availableFreeSpins = spinLogic.availableFreeSpins;
         if (availableFreeSpins > 0) {
             this._lastWinAmount = this.initData.round_win_amount;
+            this.uiController.totalFreeSpinWinAmount = ceilToDecimal(this.initData.round_win_amount);
         }
         if (spinLogic.winTotalAmount !== 0 && spinLogic.winTotalAmount !== undefined) {
             this.uiController.recentWin = ceilToDecimal(spinLogic.winTotalAmount);
@@ -836,6 +837,11 @@ export class AbstractController {
         if (!RainMan.settingsStore.isFreeSpinsBought) {
             return;
         }
+        const boughtRoundNumber = RainMan.settingsStore.buyFreeSpinsData?.getRawData().round_number;
+        if (boughtRoundNumber !== undefined) {
+            this.roundNumber = boughtRoundNumber;
+            RainMan.settingsStore.setRoundNumber(boughtRoundNumber);
+        }
         this.uiController.totalNumberOfFreeSpins += this.getBoughtNumberOfFreeSpins();
         RainMan.componentRegistry.getIfExists(FreeSpinButton.registryName)?.setInteractivity(false);
         RainMan.settingsStore.setIsFreeSpinBought(false);
@@ -846,7 +852,8 @@ export class AbstractController {
      * @returns {number} - number of free spins bought
      */
     getBoughtNumberOfFreeSpins() {
-        return RainMan.settingsStore.buyFreeSpinsData?.getRawData().extra_data.available_free_spins || 0;
+        return (RainMan.settingsStore.buyFreeSpinsData?.getRawData()?.extra_data?.available_free_spins ??
+            RainMan.settingsStore.freeSpinNumberBought);
     }
     /**
      * Function for autoplay spin
@@ -1021,10 +1028,14 @@ export class AbstractController {
      */
     gambleGameEnabler(winAmount) {
         if (RainMan.componentRegistry.has(BUTTONS.gamble) && RainMan.settingsStore.isGambleGameAvailable) {
-            RainMan.componentRegistry.get(BUTTONS.gamble).flipDisabledFlag(winAmount === 0);
+            RainMan.componentRegistry
+                .get(BUTTONS.gamble)
+                .flipDisabledFlag(winAmount === 0 || RainMan.settingsStore.isAutoplayEnabled);
         }
         if (RainMan.componentRegistry.has(BUTTONS.take) && RainMan.settingsStore.isTakeActionAvailable) {
-            RainMan.componentRegistry.get(BUTTONS.take).flipDisabledFlag(winAmount === 0);
+            RainMan.componentRegistry
+                .get(BUTTONS.take)
+                .flipDisabledFlag(winAmount === 0 || RainMan.settingsStore.isAutoplayEnabled);
         }
     }
     /**

package/dist/utils/common/sound.js

@@ -2,6 +2,7 @@ import { sound } from "@pixi/sound";
 import { SoundManager } from "../../application";
 import { RainMan } from "../../Rainman";
 let shouldResumeAudioOnInterruption = false;
+let isResumingAudio = false;
 const removeInterruptedAudioResumeListeners = () => {
     window.removeEventListener("pointerdown", resumeAudioOnInterruption);
     window.removeEventListener("touchend", resumeAudioOnInterruption);
@@ -19,6 +20,7 @@ const interruptedAudioResume = () => {
  * @returns {void}
  */
 const pauseAudio = () => {
+    isResumingAudio = false;
     shouldResumeAudioOnInterruption = false;
     removeInterruptedAudioResumeListeners();
     if (RainMan.settingsStore.isSoundEnabled()) {
@@ -33,20 +35,29 @@ const resumeAudio = async () => {
     if (document.hidden || !RainMan.settingsStore.isSoundEnabled()) {
         return;
     }
-    if (RainMan.settingsStore.isSoundEnabled()) {
-        const hasResumedAudioContext = await SoundManager.resumeOnFocus();
-        if (!hasResumedAudioContext) {
-            interruptedAudioResume();
+    if (isResumingAudio) {
+        return;
+    }
+    isResumingAudio = true;
+    try {
+        if (RainMan.settingsStore.isSoundEnabled()) {
+            const hasResumedAudioContext = await SoundManager.resumeOnFocus();
+            if (!hasResumedAudioContext) {
+                interruptedAudioResume();
+                return;
+            }
+            SoundManager.resumeAll();
+        }
+        if (SoundManager.isAudioContextRunning()) {
+            shouldResumeAudioOnInterruption = false;
+            removeInterruptedAudioResumeListeners();
             return;
         }
-        SoundManager.resumeAll();
+        interruptedAudioResume();
     }
-    if (SoundManager.isAudioContextRunning()) {
-        shouldResumeAudioOnInterruption = false;
-        removeInterruptedAudioResumeListeners();
-        return;
+    finally {
+        isResumingAudio = false;
     }
-    interruptedAudioResume();
 };
 /**
  * Restore audio on the next user action if browser blocked it earlier.
@@ -66,7 +77,7 @@ const handleVisibilityChange = () => {
         pauseAudio();
         return;
     }
-    resumeAudio();
+    interruptedAudioResume();
 };
 /**
  * Sets up audio states for tab switches and iOS app interruptions.
@@ -76,5 +87,6 @@ export const loadSoundsOnTabChange = () => {
     sound.disableAutoPause = true;
     document.addEventListener("visibilitychange", handleVisibilityChange);
     window.addEventListener("pagehide", () => pauseAudio());
-    window.addEventListener("pageshow", () => resumeAudio());
+    window.addEventListener("pageshow", () => interruptedAudioResume());
+    window.addEventListener("focus", () => interruptedAudioResume());
 };

package/package.json

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