pixi-rainman-game-engine 0.3.36 → 0.3.38

package/dist/application/ButtonsEventManager/ButtonsEventManager.js

@@ -157,11 +157,7 @@ export class ButtonsEventManager {
         const animatedBackground = RainMan.componentRegistry.get(Background.registryName);
         animatedBackground.eventMode = "static";
         animatedBackground.addListener("pointerdown", () => {
-            if (hideLayerIfPresent() &&
-                !RainMan.settingsStore.isAutoplayEnabled &&
-                !RainMan.settingsStore.isFreeSpinsPlayEnabled) {
-                this.enableButtons();
-            }
+            hideLayerIfPresent();
         });
     }
     /**

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

@@ -112,6 +112,12 @@ export declare class SoundManagerInstance implements SpeedAdapterInterface<Sound
      * @returns {void}
      */
     stop(soundName: SoundTrack): void;
+    /**
+     * Function that resumes sounds and music when game is back in focus.
+     * @public
+     * @returns {void}
+     */
+    resumeAudioContext(): Promise<boolean>;
     /**
      * Function that resumes sounds and music when game is back in focus.
      * @public

package/dist/application/SoundManager/SoundManager.js

@@ -105,6 +105,9 @@ export class SoundManagerInstance {
      * @returns {void}
      */
     play(soundName) {
+        if (!RainMan.settingsStore.isSoundStarted) {
+            return;
+        }
         if (!RainMan.settingsStore.shouldPlayFxSounds &&
             !(soundName === SoundTracks.music || soundName === SoundTracks.freeSpinsMusic)) {
             return;
@@ -152,6 +155,9 @@ export class SoundManagerInstance {
      * @returns {void}
      */
     resumeAll() {
+        if (!RainMan.settingsStore.isSoundStarted) {
+            return;
+        }
         this.musicCatalogue.forEach((sound, soundName) => {
             if (sound.paused && sound.isPlaying && sound) {
                 sound.resume();
@@ -176,7 +182,7 @@ export class SoundManagerInstance {
      * @returns {void}
      */
     restoreAmbientPlayback() {
-        if (!RainMan.settingsStore.shouldPlayAmbientMusic) {
+        if (!RainMan.settingsStore.isSoundStarted || !RainMan.settingsStore.shouldPlayAmbientMusic) {
             return;
         }
         const ambientTrack = RainMan.settingsStore.isFreeSpinsPlayEnabled
@@ -248,7 +254,7 @@ export class SoundManagerInstance {
      * @public
      * @returns {void}
      */
-    async resumeOnFocus() {
+    async resumeAudioContext() {
         const pixiSoundContext = sound.context;
         const audioContext = pixiSoundContext.audioContext;
         const state = audioContext.state;
@@ -260,7 +266,19 @@ export class SoundManagerInstance {
                 console.error("Could not resume audio", error);
             }
         }
-        if (!this.isAudioContextRunning()) {
+        return this.isAudioContextRunning();
+    }
+    /**
+     * Function that resumes sounds and music when game is back in focus.
+     * @public
+     * @returns {void}
+     */
+    async resumeOnFocus() {
+        if (!RainMan.settingsStore.isSoundStarted) {
+            return false;
+        }
+        const isAudioContextRunning = await this.resumeAudioContext();
+        if (!isAudioContextRunning) {
             return false;
         }
         sound.resumeAll();

package/dist/components/AbstractBuyFreeSpins/AbstractBuyFreeSpinsPlate.d.ts

@@ -7,8 +7,8 @@ export type BuyFreeSpinConfig = {
 };
 export type BuyFreeSpinState = "selection" | "confirmation";
 export declare abstract class AbstractBuyFreeSpinsPlate extends Container {
-    private buyType;
-    private state;
+    protected buyType: BuyType;
+    protected state: BuyFreeSpinState;
     protected selectedOption?: BuyFreeSpinOption;
     protected readonly config: BuyFreeSpinConfig;
     protected selectionPlate?: Sprite;
@@ -18,9 +18,9 @@ export declare abstract class AbstractBuyFreeSpinsPlate extends Container {
     protected declineButton?: AcceptDeclineButton;
     protected selectionPlateTexture: string;
     protected confirmationPlateTexture: string;
-    private readonly onContinueCallback;
-    private readonly resizeHandler;
-    private handleClose;
+    protected readonly onContinueCallback: () => void;
+    protected readonly resizeHandler: () => void;
+    protected handleClose: () => void;
     protected constructor(onContinue: () => void, config: BuyFreeSpinConfig, buyType: BuyType);
     init(): void;
     private createElements;
@@ -39,8 +39,8 @@ export declare abstract class AbstractBuyFreeSpinsPlate extends Container {
     protected abstract positionConfirmationScreen(): void;
     protected onCleanup(): void;
     protected onBuyButtonClick(option: BuyFreeSpinOption): void;
-    private onAcceptClick;
+    protected onAcceptClick(option: BuyFreeSpinOption): Promise<void>;
     private renderState;
-    private onDeclineClick;
-    private cleanup;
+    protected onDeclineClick(): void;
+    protected cleanup(): void;
 }

package/dist/components/AbstractIntroScreen/AbstractIntroScreen.js

@@ -242,6 +242,7 @@ export class AbstractIntroScreen extends Container {
             .start();
     }
     handleContinue() {
+        RainMan.settingsStore.startSound();
         if (this.isChecked) {
             setToLocalStorage(LOCAL_STORAGE.introScreenHidden, true);
         }

package/dist/components/AbstractMainContainer/AbstractMainContainer.js

@@ -557,11 +557,11 @@ export class AbstractMainContainer extends Container {
         });
         if (this.gambleGame) {
             this.removeChild(this.gambleGame);
+            this.messageBox.visible = true;
             RainMan.settingsStore.isGambleGameActive = false;
             this._controller.updateGambleValues(RainMan.settingsStore.gambleGameWin);
             this.gambleGame = null;
         }
-        this._controller?.updateBalance();
         this.hideOverlay();
     }
     /**
@@ -913,6 +913,8 @@ export class AbstractMainContainer extends Container {
             this._buyFreeSpinsPlate.resize();
         }
         if (this.gambleGame) {
+            this.gambleGame.parentLayer = UXLayer;
+            this.messageBox.visible = false;
             this.gambleGame.resize();
             this.addChild(this.gambleGame);
         }

package/dist/components/GambleGame/GambleGame.js

@@ -174,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.balanceAfterSpin;
         await new Promise((resolve) => {
             this.card.state.clearTracks();
             this.card.state.clearListeners();

package/dist/components/dictionary/locales/en.json

@@ -65,6 +65,7 @@
         "freeSpinText": "FREE SPINS",
         "buyFreeSpins": "Buy Free Spins",
         "possibleWin": "POSSIBLE WIN: ",
-        "gamePaysText": "GAME PAYS: "
+        "gamePaysText": "GAME PAYS: ",
+        "clickAnywhereToContinue": "Click anywhere to continue"
     }
 }

package/dist/connectivity/spinData.d.ts

@@ -1,5 +1,6 @@
+import { Nullable } from "utils";
 import { ApiConfig } from "../application";
-import { SpinDataInterface } from "./serverData";
+import { ExtraData, SpinDataInterface } from "./serverData";
 /**
  * Class representing the spin data.
  * @class SpinData
@@ -9,6 +10,7 @@ export declare class SpinData {
     private readonly rawData;
     private readonly config;
     balanceAfterSpin: number;
+    extraData: Nullable<ExtraData>;
     constructor(config: ApiConfig, data: SpinDataInterface);
     /**
      * Get the raw spin data from the backend server

package/dist/connectivity/spinData.js

@@ -7,10 +7,12 @@ export class SpinData {
     rawData;
     config;
     balanceAfterSpin;
+    extraData;
     constructor(config, data) {
         this.rawData = data;
         this.config = config;
         this.balance = data.balance;
+        this.extraData = data.extra_data;
         this.balanceAfterSpin = data.future_balance_prediction;
         if (data.action !== "spin" && data.action !== "buy" && data.action !== "mini-game") {
             throw new Error(`Invalid type "${data.action}" provided, "spin" or "buy" expected`);

package/dist/controllers/AbstractController.js

@@ -132,6 +132,9 @@ export class AbstractController {
         });
         SoundManager.setPlayStatus(SoundTracks.music, RainMan.settingsStore.shouldPlayAmbientMusic);
         this.changeGamePhase(gamePhases.IDLE);
+        if (!RainMan.settingsStore.isFreeSpinsPlayEnabled) {
+            RainMan.componentRegistry.getIfExists(FreeSpinButton.registryName)?.setInteractivity(true);
+        }
     }
     /**
      * Function for initializing function after timeout
@@ -312,7 +315,13 @@ export class AbstractController {
             this.buttonsEventManager.initGambleButton(() => {
                 RainMan.settingsStore.isGambleGameAvailable = false;
                 this.mainContainer.invokeGambleGame();
-            }, this.lastWinAmount === 0 || !RainMan.settingsStore.isGambleGameAvailable);
+            }, this.lastWinAmount === 0 ||
+                !RainMan.settingsStore.isGambleGameAvailable ||
+                RainMan.settingsStore.isPlayingAnyAction ||
+                this.gamePhase === gamePhases.HANDLING_ACTIONS ||
+                this.gamePhase === gamePhases.STOPPING_HANDLING_ACTIONS ||
+                this.gamePhase === gamePhases.SPINNING ||
+                this.gamePhase === gamePhases.GAME_SUMMARY);
         }
         if (RainMan.componentRegistry.has(BUTTONS.take)) {
             this.buttonsEventManager.initTakeButton(() => {
@@ -326,7 +335,13 @@ export class AbstractController {
                 RainMan.componentRegistry
                     .get(BUTTONS.take)
                     .flipDisabledFlag(!RainMan.settingsStore.isTakeActionAvailable);
-            }, !RainMan.settingsStore.isTakeActionAvailable);
+            }, this.lastWinAmount === 0 ||
+                !RainMan.settingsStore.isGambleGameAvailable ||
+                RainMan.settingsStore.isPlayingAnyAction ||
+                this.gamePhase === gamePhases.HANDLING_ACTIONS ||
+                this.gamePhase === gamePhases.STOPPING_HANDLING_ACTIONS ||
+                this.gamePhase === gamePhases.SPINNING ||
+                this.gamePhase === gamePhases.GAME_SUMMARY);
         }
         RainMan.componentRegistry.get(SpeedControlButton.registryName).setOnClick(() => {
             this.quickStopController.speedPopupDisabled = true;
@@ -1181,7 +1196,6 @@ export class AbstractController {
         RainMan.settingsStore.reinitData = undefined;
         logGroupEnd();
         await this.onSpinningEnd(spinLogic);
-        this.gambleGameEnabler(this.lastWinAmount);
         this.winActionsQueue = [];
         this.spinning = false;
         this.isSpinThrottled = false;
@@ -1205,7 +1219,9 @@ export class AbstractController {
                 this.uiController.messageBox.hideCurrentWinText();
             this.uiController.messageBox.hideAutoSpinText();
             await this.handleFreeSpinPlateInvocation(freeSpinAward, isAdditionalFreeSpins || additionalFreeSpinsOnLastSpin);
-            if (!isAdditionalFreeSpins && !additionalFreeSpinsOnLastSpin) {
+            if (!RainMan.settingsStore.isFreeSpinsPlayEnabled &&
+                !isAdditionalFreeSpins &&
+                !additionalFreeSpinsOnLastSpin) {
                 this.uiController.currentBalance = RainMan.settingsStore.balanceAfterSpin;
             }
             this.uiController.triggerUiElementsUpdate();
@@ -1219,6 +1235,7 @@ export class AbstractController {
             await this.handleFreeSpinSummaryPlateInvocation();
         }
         await this.performActionsAfterSpin();
+        this.gambleGameEnabler(this.lastWinAmount);
         if (RainMan.settingsStore.isAutoplayEnabled ||
             (RainMan.settingsStore.howManyFreeSpinsLeft !== 0 && this.shouldAutoplayFreeSpins)) {
             this.handleAutoplayLogic();

package/dist/loading/AbstractLoadingContainer.d.ts

@@ -48,6 +48,7 @@ export declare abstract class AbstractLoadingContainer extends Container {
      */
     protected setupInitAnimations(): void;
     waitForPresentationToFinish(): Promise<void>;
+    showContinueAfterLoading(label?: string): void;
     scaleInitSpineToScreenWidth(): void;
     private tryResolvePresentationFinished;
 }

package/dist/loading/AbstractLoadingContainer.js

@@ -24,11 +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", {
-            fill: ["#FCD784", "#AE6119", "#FEE391"],
-            stroke: "#4a1850",
-            dropShadowColor: "#000000"
-        });
+        this.loaderContainer = new SpriteLoadingContainer("./assets/images/materials/texture.png");
         this.presentationFinishedPromise = new Promise((resolve) => {
             this.resolvePresentationFinished = resolve;
         });
@@ -102,6 +98,9 @@ export class AbstractLoadingContainer extends Container {
     waitForPresentationToFinish() {
         return this.presentationFinishedPromise;
     }
+    showContinueAfterLoading(label) {
+        this.loaderContainer.showContinue(label);
+    }
     scaleInitSpineToScreenWidth() {
         if (getDeviceOrientation() === "mobile-portrait") {
             this.initAnimation?.scale.set(0.5 * globalMinRatio());

package/dist/loading/SpriteLoadingContainer.d.ts

@@ -1,4 +1,4 @@
-import { Container, ITextStyle, Sprite } from "pixi.js";
+import { Container, Sprite } from "pixi.js";
 import { ProgressiveLoader } from "./ProgressiveLoader";
 /**
  * This class contains the loading process to pixi application
@@ -16,6 +16,10 @@ export declare class SpriteLoadingContainer extends Container implements Progres
     progressBorder: Sprite;
     private progress;
     private targetProgress;
+    private continueText;
+    private shouldShowContinue;
+    private wasContinueClicked;
+    private isContinueVisible;
     private completionPromiseResolver;
     private completionPromise;
     private readonly loadingStatusContainerHeight;
@@ -28,7 +32,7 @@ export declare class SpriteLoadingContainer extends Container implements Progres
      * @param {Partial<ITextStyle>} textOptions contains the options for text color blur
      * @returns {void}
      */
-    constructor(texture: string, textOptions: Partial<ITextStyle>);
+    constructor(texture: string);
     waitForCompletion(): Promise<void>;
     /**
      * Function for updating loading progress
@@ -37,6 +41,7 @@ export declare class SpriteLoadingContainer extends Container implements Progres
      * @returns {void}
      */
     updateProgress(progress: number): void;
+    showContinue(label?: string): void;
     /**
      * Function for setting error text
      * @public
@@ -63,5 +68,8 @@ export declare class SpriteLoadingContainer extends Container implements Progres
     private updateProgressMask;
     private animateProgress;
     private isComplete;
+    private canResolveCompletion;
+    private showContinueIfReady;
+    private handleContinueClick;
     private resolveCompletionIfReady;
 }

package/dist/loading/SpriteLoadingContainer.js

@@ -1,4 +1,5 @@
-import { Container, Graphics, Sprite, Text, TextStyle, Texture } from "pixi.js";
+import i18next from "i18next";
+import { Container, Graphics, Rectangle, Sprite, Text, TextStyle, Texture } from "pixi.js";
 import { RainMan } from "../Rainman";
 import { getDeviceOrientation } from "../utils/common/deviceOrientation";
 /**
@@ -17,6 +18,10 @@ export class SpriteLoadingContainer extends Container {
     progressBorder;
     progress = 0;
     targetProgress = 0;
+    continueText = i18next.t("clickAnywhereToContinue");
+    shouldShowContinue = false;
+    wasContinueClicked = false;
+    isContinueVisible = false;
     completionPromiseResolver = null;
     completionPromise = null;
     loadingStatusContainerHeight = 10;
@@ -29,7 +34,7 @@ export class SpriteLoadingContainer extends Container {
      * @param {Partial<ITextStyle>} textOptions contains the options for text color blur
      * @returns {void}
      */
-    constructor(texture, textOptions) {
+    constructor(texture) {
         super();
         this.progressBarMask = new Graphics();
         this.progressBorderMask = new Graphics();
@@ -52,12 +57,8 @@ export class SpriteLoadingContainer extends Container {
             fontFamily: RainMan.config.fontFace,
             fontSize: 24,
             strokeThickness: 3,
-            dropShadow: true,
-            dropShadowBlur: 4,
-            dropShadowAngle: Math.PI / 6,
-            dropShadowDistance: 6,
             align: "center",
-            ...textOptions
+            fill: "#ffffff"
         });
         this.text = new Text("", loaderTextStyle);
         this.text.anchor.set(0.5, 0.5);
@@ -71,7 +72,7 @@ export class SpriteLoadingContainer extends Container {
         RainMan.app.ticker.add(this.animateProgress, this);
     }
     waitForCompletion() {
-        if (this.isComplete()) {
+        if (this.canResolveCompletion()) {
             return Promise.resolve();
         }
         if (!this.completionPromise) {
@@ -94,6 +95,13 @@ export class SpriteLoadingContainer extends Container {
         }
         this.targetProgress = normalizedProgress;
         this.updateProgressMask();
+        this.showContinueIfReady();
+    }
+    showContinue(label = i18next.t("clickAnywhereToContinue")) {
+        this.shouldShowContinue = true;
+        this.continueText = label;
+        this.text.visible = false;
+        this.showContinueIfReady();
     }
     /**
      * Function for setting error text
@@ -164,7 +172,12 @@ export class SpriteLoadingContainer extends Container {
         this.progressBorder.y = startY;
         this.progressBorderMask.x = this.progressBorder.x;
         this.progressBorderMask.y = this.progressBorder.y;
-        if (this.text.text !== "") {
+        if (this.isContinueVisible) {
+            this.hitArea = new Rectangle(0, 0, RainMan.app.screen.width, RainMan.app.screen.height);
+            this.text.x = RainMan.app.screen.width / 2;
+            this.text.y = startY + this.loadingStatusContainerHeight / 2;
+        }
+        else if (this.text.text !== "") {
             this.text.x = RainMan.app.screen.width / 2;
             this.text.y = RainMan.app.screen.height / 2;
         }
@@ -198,13 +211,43 @@ export class SpriteLoadingContainer extends Container {
         const maxStep = RainMan.app.ticker.deltaMS / this.minimumFullProgressDuration;
         this.progress = Math.min(this.progress + maxStep, this.targetProgress);
         this.updateProgressMask();
+        this.showContinueIfReady();
         this.resolveCompletionIfReady();
     }
     isComplete() {
         return this.targetProgress === 1 && this.progress >= this.targetProgress;
     }
+    canResolveCompletion() {
+        return this.isComplete() && (!this.shouldShowContinue || this.wasContinueClicked);
+    }
+    showContinueIfReady() {
+        if (!this.shouldShowContinue || !this.isComplete() || this.isContinueVisible) {
+            return;
+        }
+        this.isContinueVisible = true;
+        this.removeChild(this.progressBorderShadow);
+        this.removeChild(this.progressBorderMask);
+        this.removeChild(this.progressBorder);
+        this.removeChild(this.progressBarMask);
+        this.removeChild(this.progressBar);
+        this.text.text = this.continueText;
+        this.text.visible = true;
+        this.eventMode = "static";
+        this.cursor = "pointer";
+        this.on("pointertap", this.handleContinueClick, this);
+        this.reposition();
+    }
+    handleContinueClick() {
+        RainMan.settingsStore.startSound();
+        this.wasContinueClicked = true;
+        this.eventMode = "passive";
+        this.cursor = "default";
+        this.hitArea = null;
+        this.off("pointertap", this.handleContinueClick, this);
+        this.resolveCompletionIfReady();
+    }
     resolveCompletionIfReady() {
-        if (!this.isComplete() || !this.completionPromiseResolver) {
+        if (!this.canResolveCompletion() || !this.completionPromiseResolver) {
             return;
         }
         this.completionPromiseResolver();

package/dist/stores/SettingsStore.d.ts

@@ -15,6 +15,7 @@ export declare class SettingsStore {
     isQuickSpinsActive: boolean;
     bet: number;
     betText: string;
+    isSoundStarted: boolean;
     shouldPlayAmbientMusic: boolean;
     shouldPlayFxSounds: boolean;
     fullScreenFlag: boolean;
@@ -191,6 +192,7 @@ export declare class SettingsStore {
      * @returns {void}
      */
     setShouldPlayAmbientMusic(flag: boolean, saveToLocalStorage?: boolean): void;
+    startSound(): void;
     /**
      * Sets flag for effect sounds
      * @public

package/dist/stores/SettingsStore.js

@@ -19,6 +19,7 @@ export class SettingsStore {
     isQuickSpinsActive = false;
     bet = 0;
     betText = "";
+    isSoundStarted = false;
     shouldPlayAmbientMusic = true;
     shouldPlayFxSounds = true;
     fullScreenFlag = false;
@@ -95,6 +96,7 @@ export class SettingsStore {
         makeAutoObservable(this, {
             setBatteryFlag: action.bound,
             setBalanceAfterSpin: action.bound,
+            startSound: action.bound,
             setShouldPlayAmbientMusic: action.bound,
             setShouldPlayFxSounds: action.bound,
             setFullScreenFlag: action.bound,
@@ -297,6 +299,10 @@ export class SettingsStore {
             removeFromLocalStorage(LOCAL_STORAGE.isSoundEnabled);
         }
     }
+    startSound() {
+        this.isSoundStarted = true;
+        void SoundManager.resumeAudioContext();
+    }
     /**
      * Sets flag for effect sounds
      * @public

package/package.json

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