pixi-rainman-game-engine 0.3.42 → 0.3.43

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

@@ -16,8 +16,11 @@ export declare class SoundManagerInstance implements SpeedAdapterInterface<Sound
     readonly speedLevelMapper: SpeedLevelDirectory<SoundOverrides>;
     private musicCatalogue;
     private currentAmbientTrack;
-    private pausedSoundsForPageHide;
+    private currentAmbientOffset;
+    private loadedSoundAssets;
+    private audioContextRecoveryPromise;
     constructor();
+    private loadSound;
     /**
      * Function for loading sounds into pixi
      * @public
@@ -62,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
@@ -78,11 +93,18 @@ export declare class SoundManagerInstance implements SpeedAdapterInterface<Sound
      */
     restoreAmbientPlayback(): void;
     /**
-     * Restores sounds paused because of page visibility change.
-     * @public
+     * 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}
      */
-    restorePlaybackAfterPageHide(): 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
@@ -128,13 +150,13 @@ export declare class SoundManagerInstance implements SpeedAdapterInterface<Sound
     /**
      * Function that resumes sounds and music when game is back in focus.
      * @public
-     * @returns {void}
+     * @returns {Promise<boolean>} True when audio context is running.
      */
     resumeAudioContext(): Promise<boolean>;
     /**
      * Function that resumes sounds and music when game is back in focus.
      * @public
-     * @returns {void}
+     * @returns {Promise<boolean>} True when audio context and ambient recovery are ready.
      */
     resumeOnFocus(): Promise<boolean>;
     /**

package/dist/application/SoundManager/SoundManager.js

@@ -31,10 +31,25 @@ export class SoundManagerInstance {
     };
     musicCatalogue = new Map();
     currentAmbientTrack = null;
-    pausedSoundsForPageHide = new Set();
+    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
@@ -42,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);
     }
@@ -96,7 +102,6 @@ export class SoundManagerInstance {
         }
     }
     pauseSoundsForPageHide() {
-        this.pausedSoundsForPageHide.clear();
         this.musicCatalogue.forEach((sound, soundName) => {
             if (!sound.isPlaying || sound.paused) {
                 return;
@@ -104,9 +109,8 @@ export class SoundManagerInstance {
             if (soundName === SoundTracks.freeSpinsMusic || soundName === SoundTracks.music) {
                 this.currentAmbientTrack = soundName;
             }
-            this.pausedSoundsForPageHide.add(soundName);
-            sound.pause();
         });
+        sound.pauseAll();
     }
     /**
      * Function for resuming and pausing sound in game
@@ -150,12 +154,15 @@ export class SoundManagerInstance {
                 return;
             }
         }
-        sound.play({
+        const instance = sound.play({
             singleInstance: true,
             loop: soundsToLoop.includes(soundName),
             volume: this.getVolumeLevel(soundName),
             speed: soundName === "cardDrawing" ? 0.8 : 1
         });
+        if (this.isAmbientTrack(soundName) && !(instance instanceof Promise)) {
+            this.trackAmbientPlaybackProgress(soundName, sound, instance);
+        }
     }
     /**
      * Returns the volume level for a given sound track.
@@ -178,10 +185,86 @@ export class SoundManagerInstance {
     getOppositeAmbientTrack(soundName) {
         return soundName === SoundTracks.freeSpinsMusic ? SoundTracks.music : SoundTracks.freeSpinsMusic;
     }
+    getCurrentAmbientTrack() {
+        return (this.currentAmbientTrack ??
+            (RainMan.settingsStore.isFreeSpinsStarted ? SoundTracks.freeSpinsMusic : SoundTracks.music));
+    }
     getSound(soundName) {
         const overrideSoundName = this.overrides[soundName];
         return this.musicCatalogue.get(overrideSoundName ?? soundName);
     }
+    getAmbientPlaybackOffset(sound) {
+        if (!sound.isPlayable || !Number.isFinite(sound.duration) || sound.duration <= 0) {
+            return 0;
+        }
+        return this.currentAmbientOffset % sound.duration;
+    }
+    trackAmbientPlaybackProgress(soundName, sound, instance) {
+        if (!sound.isPlayable || sound.duration <= 0) {
+            return;
+        }
+        instance.on("progress", (progress) => {
+            if (this.currentAmbientTrack !== soundName || !Number.isFinite(progress)) {
+                return;
+            }
+            this.currentAmbientOffset = (progress * sound.duration) % sound.duration;
+        });
+    }
+    /**
+     * Saves active ambient position before the browser interrupts WebAudio playback.
+     * @public
+     * @returns {void}
+     */
+    captureAmbientPlaybackPositionForPageHide() {
+        if (!RainMan.settingsStore.isSoundStarted || !RainMan.settingsStore.shouldPlayAmbientMusic) {
+            return;
+        }
+        const ambientTrack = this.getCurrentAmbientTrack();
+        const ambientSound = this.getSound(ambientTrack);
+        const ambientInstance = ambientSound?.instances.find((instance) => Number.isFinite(instance.progress) && instance.progress > 0);
+        if (!ambientSound || !ambientInstance || !ambientSound.isPlayable || ambientSound.duration <= 0) {
+            return;
+        }
+        this.currentAmbientTrack = ambientTrack;
+        this.currentAmbientOffset = (ambientInstance.progress * ambientSound.duration) % ambientSound.duration;
+    }
+    isIOSWebAudioRuntime() {
+        const userAgent = navigator.userAgent;
+        const platform = navigator.platform;
+        return /iPad|iPhone|iPod/.test(userAgent) || (platform === "MacIntel" && navigator.maxTouchPoints > 1);
+    }
+    async recreatePixiSoundContext() {
+        if (this.audioContextRecoveryPromise) {
+            return this.audioContextRecoveryPromise;
+        }
+        this.audioContextRecoveryPromise = this.recreatePixiSoundContextOnce().finally(() => {
+            this.audioContextRecoveryPromise = null;
+        });
+        return this.audioContextRecoveryPromise;
+    }
+    async recreatePixiSoundContextOnce() {
+        if (!Object.keys(this.loadedSoundAssets).length) {
+            return;
+        }
+        this.musicCatalogue.forEach((sound) => sound.destroy());
+        this.musicCatalogue.clear();
+        try {
+            sound.context.destroy();
+        }
+        catch (error) {
+            console.error("Could not destroy Pixi sound context", error);
+        }
+        sound.init();
+        sound.disableAutoPause = false;
+        const loadingSoundsPromises = [];
+        for (const [soundName, url] of Object.entries(this.loadedSoundAssets)) {
+            if (!url) {
+                continue;
+            }
+            loadingSoundsPromises.push(this.loadSound(soundName, url));
+        }
+        await Promise.allSettled(loadingSoundsPromises);
+    }
     stopAmbientMusic() {
         this.stop(SoundTracks.music);
         this.stop(SoundTracks.freeSpinsMusic);
@@ -196,23 +279,8 @@ export class SoundManagerInstance {
         if (!RainMan.settingsStore.isSoundStarted) {
             return;
         }
-        this.musicCatalogue.forEach((sound, soundName) => {
-            if (sound.paused && sound.isPlaying && sound) {
-                sound.resume();
-            }
-            if (RainMan.settingsStore.shouldPlayAmbientMusic &&
-                !RainMan.settingsStore.isFreeSpinsPlayEnabled &&
-                soundName === SoundTracks.music &&
-                sound.paused) {
-                sound.resume();
-            }
-            if (RainMan.settingsStore.shouldPlayAmbientMusic &&
-                RainMan.settingsStore.isFreeSpinsPlayEnabled &&
-                soundName === SoundTracks.freeSpinsMusic &&
-                sound.paused) {
-                sound.resume();
-            }
-        });
+        sound.resumeAll();
+        this.restoreAmbientPlayback();
     }
     /**
      * Restores currently active ambient loop if browser dropped it while page was inactive.
@@ -227,35 +295,61 @@ export class SoundManagerInstance {
             this.stopAmbientMusic();
             return;
         }
-        const ambientTrack = this.currentAmbientTrack ??
-            (RainMan.settingsStore.isFreeSpinsStarted ? SoundTracks.freeSpinsMusic : SoundTracks.music);
+        const ambientTrack = this.getCurrentAmbientTrack();
         this.play(ambientTrack);
     }
     /**
-     * Restores sounds paused because of page visibility change.
-     * @public
+     * 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}
      */
-    restorePlaybackAfterPageHide() {
+    restartAmbientPlaybackAfterInterruption() {
         if (!RainMan.settingsStore.isSoundStarted) {
-            this.pausedSoundsForPageHide.clear();
             return;
         }
-        if (!this.pausedSoundsForPageHide.size) {
-            this.restoreAmbientPlayback();
+        if (!RainMan.settingsStore.shouldPlayAmbientMusic) {
+            this.stopAmbientMusic();
             return;
         }
-        const pausedSounds = [...this.pausedSoundsForPageHide];
-        this.pausedSoundsForPageHide.clear();
-        pausedSounds.forEach((soundName) => {
-            if (this.isAmbientTrack(soundName) && !RainMan.settingsStore.shouldPlayAmbientMusic) {
-                return;
-            }
-            if (!this.isAmbientTrack(soundName) && !RainMan.settingsStore.shouldPlayFxSounds) {
-                return;
-            }
-            this.resume(soundName);
+        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
@@ -264,7 +358,7 @@ export class SoundManagerInstance {
      * @returns {void}
      */
     pauseAll() {
-        this.musicCatalogue.forEach((sound) => sound.pause());
+        sound.pauseAll();
     }
     /**
      * Function for stopping all sounds in game
@@ -314,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;
@@ -333,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) {
@@ -343,8 +437,7 @@ export class SoundManagerInstance {
         if (!isAudioContextRunning) {
             return false;
         }
-        this.restorePlaybackAfterPageHide();
-        return true;
+        return this.restorePlaybackAfterPageHide();
     }
     /**
      * Returns information if audio context is ready to play sounds.

package/dist/connectivity/ConnectionWrapper.d.ts

@@ -11,6 +11,7 @@ export declare class ConnectionWrapper implements SubscribableConnectionWrapper
     private fetchInProgress;
     private lastFetchResponse;
     private lastGambleResponse;
+    private pendingSpinEndPromise;
     private subscribers;
     /**
      * Mapper function for data that comes from the server

package/dist/connectivity/ConnectionWrapper.js

@@ -17,6 +17,7 @@ export class ConnectionWrapper {
     fetchInProgress = false;
     lastFetchResponse = new Map();
     lastGambleResponse = null;
+    pendingSpinEndPromise = null;
     subscribers = [];
     /**
      * Mapper function for data that comes from the server
@@ -83,6 +84,7 @@ export class ConnectionWrapper {
      * @memberof ConnectionWrapper
      */
     async fetchInitData() {
+        this.pendingSpinEndPromise = null;
         this._initData = (await this.fetch({
             action: "init",
             reference: RainMan.config.gameInitReference,
@@ -177,6 +179,9 @@ export class ConnectionWrapper {
         if (typeof this.config?.token === "undefined") {
             throw new Error("Token was not defined");
         }
+        if (this.pendingSpinEndPromise !== null) {
+            await this.pendingSpinEndPromise;
+        }
         const data = await this.fetch({
             action: "spin",
             reference: RainMan.config.gameInitReference,
@@ -186,7 +191,14 @@ export class ConnectionWrapper {
             extra_data
         });
         this._messageHistory.push(data);
-        this.sendEndOfRoundData(data.round_number);
+        const endPromise = this.sendEndOfRoundData(data.round_number);
+        let trackedEndPromise = null;
+        trackedEndPromise = endPromise.finally(() => {
+            if (this.pendingSpinEndPromise === trackedEndPromise) {
+                this.pendingSpinEndPromise = null;
+            }
+        });
+        this.pendingSpinEndPromise = trackedEndPromise;
         return new SpinData(this.config, data);
     }
     /**

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.pauseSoundsForPageHide();
+        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("pagehide", () => prepareAudioForPageHide());
     window.addEventListener("pageshow", () => resumeAudio());
     window.addEventListener("focus", () => resumeAudio());
 };

package/package.json

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