pixi-rainman-game-engine 0.3.31-b → 0.3.32

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

@@ -2,87 +2,30 @@ import "react-custom-scroll/dist/customScroll.css";
 import "./autoplaySettings.css";
 import i18next from "i18next";
 import { observer } from "mobx-react-lite";
-import React, { useEffect, useState } from "react";
+import React from "react";
 import { COMPONENTS } from "../../../components";
 import { UI_ITEMS } from "../../../utils";
 import { useStores } from "../../hooks";
 import { CloseModalButton } from "../CloseModalButton";
 import { RichLimitingSlider } from "../RichLimitingSlider";
 import { SpeedButtonWithHeader, SwitchWithHeader } from "../SwitchWithHeader";
+const initialAutoSpinCount = 10;
+const availableAutoSpinLimits = [10, 20, 50, 70, 100];
 export const AutoplaySettings = observer(() => {
-    const [limitNumbers, setLimitNumbers] = useState([0]);
-    const initialAutoSpinCount = 50;
-    const availableAutoSpinLimits = [10, 20, 50, 100, 150, 200, 250, 300, 350, 400, 500, 600, 700, 800, 900, 1000];
     const { settingStore } = useStores();
-    const calculateLimitBounds = (indexOfSelectedLimit) => {
-        let bottomLimitIndex = indexOfSelectedLimit - 2;
-        let topLimitIndex = indexOfSelectedLimit + 1;
-        if (bottomLimitIndex < 0) {
-            bottomLimitIndex = availableAutoSpinLimits.length - -bottomLimitIndex;
-        }
-        if (topLimitIndex === availableAutoSpinLimits.length) {
-            topLimitIndex = 0;
-        }
-        return {
-            bottomLimitIndex,
-            topLimitIndex
-        };
-    };
     const updateLimitsBounds = (newLimit) => {
         setAutoSpinsCount(newLimit);
-        const indexOfSelectedSpinsLimit = availableAutoSpinLimits.findIndex((limitCount) => limitCount === newLimit);
-        if (indexOfSelectedSpinsLimit === -1) {
-        }
-        const { bottomLimitIndex, topLimitIndex } = calculateLimitBounds(indexOfSelectedSpinsLimit);
-        const limitNumbersIndexes = [];
-        for (let index = bottomLimitIndex; index !== topLimitIndex + 1; index++) {
-            if (index === availableAutoSpinLimits.length) {
-                index = 0;
-            }
-            limitNumbersIndexes.push(availableAutoSpinLimits[index]);
-            if (limitNumbersIndexes.length === 4) {
-                break;
-            }
-        }
-        setLimitNumbers(limitNumbersIndexes);
     };
-    useEffect(() => {
-        updateLimitsBounds(initialAutoSpinCount);
-    }, []);
-    const { singleWinExceeds, balancedIncreased, balancedDecreased, howManyAutoSpinsLeft, infinitySpinsEnabled, setSingleWinExceeds, setBalancedIncreased, setBalancedDecreased, setAutoSpinsCount, flipInfinitySpinsFlag, resetAutoplaySettings } = settingStore;
+    const { singleWinExceeds, balancedIncreased, balancedDecreased, howManyAutoSpinsLeft, infinitySpinsEnabled, setSingleWinExceeds, setBalancedIncreased, setBalancedDecreased, setAutoSpinsCount, resetAutoplaySettings } = settingStore;
     return (<div className="autoplay-settings">
             <CloseModalButton layerId={UI_ITEMS.autoplay}/>
             <div className="autoplay-settings__title">
                 <h2>{i18next.t("autoPlay")}</h2>
             </div>
             <div className="autoplay-settings__stop-limits">
-                <button className={`autoplay-settings__limit left ${infinitySpinsEnabled ? "autoplay-settings__limit--infinity" : ""}`} onClick={() => {
-            let indexOfSelectedSpinsLimit = availableAutoSpinLimits.findIndex((limitCount) => limitCount === howManyAutoSpinsLeft);
-            indexOfSelectedSpinsLimit -= 1;
-            if (indexOfSelectedSpinsLimit === -1) {
-                indexOfSelectedSpinsLimit = availableAutoSpinLimits.length - 1;
-            }
-            updateLimitsBounds(availableAutoSpinLimits[indexOfSelectedSpinsLimit]);
-        }}>
-                    <p>-</p>
-                </button>
-                {limitNumbers.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 ${limiter === howManyAutoSpinsLeft ? "autoplay-settings__limit--active" : ""} middle ${infinitySpinsEnabled ? "autoplay-settings__limit--infinity" : ""}`} disabled={settingStore.infinitySpinsEnabled} onClick={(event) => updateLimitsBounds(Number(event.currentTarget.value))}>
                         <p>{limiter}</p>
                     </button>))}
-                <button className={`autoplay-settings__limit right ${infinitySpinsEnabled ? "autoplay-settings__limit--infinity" : ""}`} onClick={() => {
-            let indexOfSelectedSpinsLimit = availableAutoSpinLimits.findIndex((limitCount) => limitCount === howManyAutoSpinsLeft);
-            indexOfSelectedSpinsLimit += 1;
-            if (indexOfSelectedSpinsLimit === availableAutoSpinLimits.length) {
-                indexOfSelectedSpinsLimit = 0;
-            }
-            const newAutoSpinsLimitNumber = availableAutoSpinLimits[indexOfSelectedSpinsLimit];
-            updateLimitsBounds(newAutoSpinsLimitNumber);
-        }}>
-                    <p>+</p>
-                </button>
-                <button className={`autoplay-settings__limit circle ${infinitySpinsEnabled ? "autoplay-settings__limit--active" : ""}`} onClick={() => flipInfinitySpinsFlag()}>
-                    <p>∞</p>
-                </button>
             </div>
             <div className="separator"/>
             <div className="autoplay-settings__title">

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

@@ -64,6 +64,12 @@ export declare class SoundManagerInstance implements SpeedAdapterInterface<Sound
      * @returns {void}
      */
     resumeAll(): void;
+    /**
+     * Restores currently active ambient loop if browser dropped it while page was inactive.
+     * @public
+     * @returns {void}
+     */
+    restoreAmbientPlayback(): void;
     /**
      * Function for pausing all sounds in game
      * If sound is not playing, it will be skipped
@@ -112,5 +118,11 @@ export declare class SoundManagerInstance implements SpeedAdapterInterface<Sound
      * @returns {void}
      */
     resumeOnFocus(): Promise<void>;
+    /**
+     * Returns information if audio context is ready to play sounds.
+     * @public
+     * @returns {boolean} True when audio context is in running state.
+     */
+    isAudioContextRunning(): boolean;
 }
 export declare const SoundManager: SoundManagerInstance;

package/dist/application/SoundManager/SoundManager.js

@@ -170,6 +170,28 @@ export class SoundManagerInstance {
             }
         });
     }
+    /**
+     * Restores currently active ambient loop if browser dropped it while page was inactive.
+     * @public
+     * @returns {void}
+     */
+    restoreAmbientPlayback() {
+        if (!RainMan.settingsStore.shouldPlayAmbientMusic) {
+            return;
+        }
+        const ambientTrack = RainMan.settingsStore.isFreeSpinsPlayEnabled
+            ? SoundTracks.freeSpinsMusic
+            : SoundTracks.music;
+        const ambientMusic = this.musicCatalogue.get(ambientTrack);
+        if (!ambientMusic || ambientMusic.isPlaying) {
+            return;
+        }
+        if (ambientMusic.paused) {
+            ambientMusic.resume();
+            return;
+        }
+        this.play(ambientTrack);
+    }
     /**
      * Function for pausing all sounds in game
      * If sound is not playing, it will be skipped
@@ -240,13 +262,16 @@ export class SoundManagerInstance {
             catch (error) {
                 console.error("Could not resume audio");
             }
-            const ambientMusic = this.musicCatalogue.get(RainMan.settingsStore.isFreeSpinsPlayEnabled ? "freeSpinsMusic" : "music");
-            if (ambientMusic !== undefined &&
-                ambientMusic.isPlaying !== true &&
-                RainMan.settingsStore.shouldPlayAmbientMusic) {
-                ambientMusic.resume();
-            }
         }
+        this.restoreAmbientPlayback();
+    }
+    /**
+     * Returns information if audio context is ready to play sounds.
+     * @public
+     * @returns {boolean} True when audio context is in running state.
+     */
+    isAudioContextRunning() {
+        return sound.context.audioContext.state === "running";
     }
 }
 export const SoundManager = SoundManagerInstance.getInstance();

package/dist/controllers/AbstractController.d.ts

@@ -58,6 +58,7 @@ export declare abstract class AbstractController<T> {
     protected buttonHeldSince: number;
     shouldStopMobileSpin: boolean;
     disableMessageBoxChange: boolean;
+    shouldClearQuickReelsStopAfterSpin: boolean;
     protected resolveBigWin?: () => void;
     protected resolveMysteryWin?: () => void;
     protected resolveBonusWin?: () => void;
@@ -384,6 +385,7 @@ export declare abstract class AbstractController<T> {
      * @returns {Promise<void>}
      */
     private spin;
+    private cleanupDeferredQuickStop;
     /**
      *  Function for invoking free spin plate, invoked in mainContainer
      *  ```ts

package/dist/controllers/AbstractController.js

@@ -58,6 +58,7 @@ export class AbstractController {
     buttonHeldSince = 0;
     shouldStopMobileSpin = false;
     disableMessageBoxChange = false;
+    shouldClearQuickReelsStopAfterSpin = false;
     resolveBigWin;
     resolveMysteryWin;
     resolveBonusWin;
@@ -191,6 +192,10 @@ export class AbstractController {
                 keyboardEvent.preventDefault();
                 this.buttonHeldSince = 0;
                 this.columnsContainer.clearQuickReelsStop();
+                if (this.gamePhase === gamePhases.HANDLING_ACTIONS ||
+                    this.gamePhase === gamePhases.STOPPING_HANDLING_ACTIONS) {
+                    this.shouldPlayNextSpin = false;
+                }
             }
         });
         window.addEventListener("blur", () => {
@@ -430,25 +435,26 @@ export class AbstractController {
     initSpinButton() {
         const refreshButton = RainMan.componentRegistry.get(RefreshButton.registryName);
         this.clearMobileSpinTimeout = () => {
-            this.buttonHeldSince = 0;
             const isSpinning = this.gamePhase === gamePhases.SPINNING ||
                 this.gamePhase === gamePhases.CONFIGURING_SPIN ||
                 this.gamePhase === gamePhases.DATA_FETCH;
-            if (!isSpinning) {
-                this.columnsContainer.clearQuickReelsStop();
-            }
+            this.buttonHeldSince = 0;
             if (this.mobileSpinTimeout) {
                 clearInterval(this.mobileSpinTimeout);
-                this.quickStopController.setQuickStopCounterLock(false);
                 this.mobileSpinTimeout = null;
-                if (!isSpinning) {
-                    this.columnsContainer.clearQuickReelsStop();
-                }
             }
             if (this.mobileSpinDelay) {
                 clearTimeout(this.mobileSpinDelay);
                 this.mobileSpinDelay = null;
             }
+            if (isSpinning) {
+                this.shouldClearQuickReelsStopAfterSpin = true;
+            }
+            else {
+                this.columnsContainer.clearQuickReelsStop();
+                this.quickStopController.setQuickStopCounterLock(false);
+                this.shouldClearQuickReelsStopAfterSpin = false;
+            }
         };
         refreshButton.setOnClick(() => {
             this.handleSpinLogic();
@@ -726,10 +732,10 @@ export class AbstractController {
         this.handleDisablingButtons(true);
         RainMan.globals.shouldShowModals = false;
         RainMan.settingsStore.closeCurrentlyOpenModal?.();
-        const realTime = Date.now() - this.buttonHeldSince;
-        if (realTime <= 500) {
-            this.columnsContainer.clearQuickReelsStop();
-        }
+        // const realTime = Date.now() - this.buttonHeldSince;
+        // if (realTime <= 500) {
+        //     this.columnsContainer.clearQuickReelsStop();
+        // }
         if (this.mainContainer.freeSpinPlate) {
             if (this.mainContainer.freeSpinPlate.shownAt === null ||
                 performance.now() - this.mainContainer.freeSpinPlate.shownAt <
@@ -810,6 +816,7 @@ export class AbstractController {
         }
         this.prepareBoughtFreeSpins();
         if (RainMan.settingsStore.isAutoplayEnabled && !this.spinning) {
+            this.cleanupDeferredQuickStop();
             this.changeGamePhase(gamePhases.IDLE);
             this.spin();
             return;
@@ -819,6 +826,7 @@ export class AbstractController {
             this.changeGamePhase(gamePhases.IDLE);
         }
         if (this.gamePhase === gamePhases.IDLE || this.gamePhase === gamePhases.HANDLING_ACTIONS) {
+            this.cleanupDeferredQuickStop();
             this.spin();
         }
         this.spinThrottlerTimeout = setTimeout(() => (this.spinThrottlerTimeout = null), 100);
@@ -1252,6 +1260,14 @@ export class AbstractController {
             }, 0);
         }
     }
+    cleanupDeferredQuickStop() {
+        if (!this.shouldClearQuickReelsStopAfterSpin) {
+            return;
+        }
+        this.columnsContainer.clearQuickReelsStop();
+        this.quickStopController.setQuickStopCounterLock(false);
+        this.shouldClearQuickReelsStopAfterSpin = false;
+    }
     /**
      *  Function for invoking free spin plate, invoked in mainContainer
      *  ```ts

package/dist/stores/SettingsStore.d.ts

@@ -327,12 +327,6 @@ export declare class SettingsStore {
      * @returns {void}
      */
     setAutoSpinsCount(count: number): void;
-    /**
-     * Flip the infinity spins flag
-     * @public
-     * @returns {void}
-     */
-    flipInfinitySpinsFlag(): void;
     /**
      * Setter for the autoplay enabled flag
      * @public

package/dist/stores/SettingsStore.js

@@ -72,7 +72,6 @@ export class SettingsStore {
     enableButtons;
     useTakeAction;
     initialAutoplaySettingsState = {
-        infinitySpinsEnabled: false,
         onAnyWin: false,
         howManyAutoSpinsLeft: INITIAL_AUTO_SPIN_COUNT,
         singleWinExceeds: 0,
@@ -108,7 +107,6 @@ export class SettingsStore {
             resetDataForSymbolPaytablePopup: action.bound,
             decreaseAutoSpinsCount: action.bound,
             setAutoSpinsCount: action.bound,
-            flipInfinitySpinsFlag: action.bound,
             resetAutoplaySettings: action.bound,
             setAutoPlayEnabledFlag: action.bound,
             setNumberOfFreeSpin: action.bound,
@@ -541,7 +539,7 @@ export class SettingsStore {
      * @returns {void}
      */
     decreaseAutoSpinsCount() {
-        if (this.infinitySpinsEnabled || this.isFreeSpinsPlayEnabled) {
+        if (this.isFreeSpinsPlayEnabled) {
             return;
         }
         this.howManyAutoSpinsLeft -= 1;
@@ -553,20 +551,8 @@ export class SettingsStore {
      * @returns {void}
      */
     setAutoSpinsCount(count) {
-        if (this.infinitySpinsEnabled) {
-            this.setAutoSpinsCount(-1);
-            this.flipInfinitySpinsFlag();
-        }
         this.howManyAutoSpinsLeft = count;
     }
-    /**
-     * Flip the infinity spins flag
-     * @public
-     * @returns {void}
-     */
-    flipInfinitySpinsFlag() {
-        this.infinitySpinsEnabled = !this.infinitySpinsEnabled;
-    }
     /**
      * Setter for the autoplay enabled flag
      * @public
@@ -702,7 +688,6 @@ export class SettingsStore {
      * @returns {void}
      */
     resetAutoplaySettings() {
-        this.infinitySpinsEnabled = this.initialAutoplaySettingsState.infinitySpinsEnabled;
         this.onAnyWin = this.initialAutoplaySettingsState.onAnyWin;
         this.howManyAutoSpinsLeft = this.initialAutoplaySettingsState.howManyAutoSpinsLeft;
         this.singleWinExceeds = this.initialAutoplaySettingsState.singleWinExceeds;

package/dist/utils/common/sound.d.ts

@@ -1,6 +1,5 @@
 /**
- * This function is required for setting up the sound while changing the tab
- * This is using the visibilitychange event
+ * Sets up audio states for tab switches and iOS app interruptions.
  * @returns {void}
  */
 export declare const loadSoundsOnTabChange: () => void;

package/dist/utils/common/sound.js

@@ -1,26 +1,76 @@
 import { SoundManager } from "../../application";
 import { RainMan } from "../../Rainman";
+let shouldResumeAudioOnInterruption = false;
+const removeInterruptedAudioResumeListeners = () => {
+    window.removeEventListener("pointerdown", resumeAudioOnInterruption);
+    window.removeEventListener("touchend", resumeAudioOnInterruption);
+};
+const interruptedAudioResume = () => {
+    if (shouldResumeAudioOnInterruption) {
+        return;
+    }
+    shouldResumeAudioOnInterruption = true;
+    window.addEventListener("pointerdown", resumeAudioOnInterruption, { once: true });
+    window.addEventListener("touchend", resumeAudioOnInterruption, { once: true, passive: true });
+};
 /**
- * This function using the visibilitychange event to resume sounds
- * If any time the sounds was enable than this will be resumed
- * If the sounds was disabled than this will be not triggered
+ * Pauses audio when the page goes to the background.
  * @returns {void}
  */
-const resumeAudioContext = () => {
-    if (RainMan.settingsStore.isSoundEnabled() && document.hidden) {
-        SoundManager.stopAll();
+const pauseAudio = () => {
+    shouldResumeAudioOnInterruption = false;
+    removeInterruptedAudioResumeListeners();
+    if (RainMan.settingsStore.isSoundEnabled()) {
+        SoundManager.pauseAll();
+    }
+};
+/**
+ * Restores audio when the page becomes active again.
+ * @returns {Promise<void>}
+ */
+const resumeAudio = async () => {
+    if (document.hidden || !RainMan.settingsStore.isSoundEnabled()) {
         return;
     }
-    if (RainMan.settingsStore.isSoundEnabled() && !document.hidden) {
+    if (RainMan.settingsStore.isSoundEnabled()) {
+        await SoundManager.resumeOnFocus();
         SoundManager.resumeAll();
+    }
+    if (SoundManager.isAudioContextRunning()) {
+        shouldResumeAudioOnInterruption = false;
+        removeInterruptedAudioResumeListeners();
+        return;
+    }
+    interruptedAudioResume();
+};
+/**
+ * Restore audio on the next user action if browser blocked it earlier.
+ * @returns {void}
+ */
+function resumeAudioOnInterruption() {
+    shouldResumeAudioOnInterruption = false;
+    removeInterruptedAudioResumeListeners();
+    resumeAudio();
+}
+/**
+ * Check if visibility is changed to pause or restore audio.
+ * @returns {void}
+ */
+const handleVisibilityChange = () => {
+    if (document.hidden) {
+        pauseAudio();
         return;
     }
+    resumeAudio();
 };
 /**
- * This function is required for setting up the sound while changing the tab
- * This is using the visibilitychange event
+ * Sets up audio states for tab switches and iOS app interruptions.
  * @returns {void}
  */
 export const loadSoundsOnTabChange = () => {
-    document.addEventListener("visibilitychange", resumeAudioContext);
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    window.addEventListener("pagehide", pauseAudio);
+    window.addEventListener("blur", pauseAudio);
+    window.addEventListener("pageshow", () => resumeAudio());
+    window.addEventListener("focus", () => resumeAudio());
 };

package/package.json

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