pixi-rainman-game-engine 0.1.31 → 0.1.32

package/dist/ComponentRegistry/types.d.ts

@@ -9,6 +9,7 @@ export interface RegistryMap {
     [MessageBox.autoSpinTextRegistryName]: UpdatableValueComponent;
     [MessageBox.currentWinTextRegistryName]: UpdatableTextComponent;
     [MessageBox.freeSpinTextRegistryName]: UpdatableTextComponent;
+    [MessageBox.possibleWinTextRegistryName]: UpdatableTextComponent;
     [MessageBox.registryName]: MessageBox;
     [SpeedControlButton.registryName]: SpeedControlButton;
     [Background.registryName]: Background;
@@ -28,4 +29,6 @@ export interface RegistryMap {
     [COMPONENTS.creditText]: UpdatableTextComponent;
     [COMPONENTS.bigWin]: StylefulUpdatableText;
     [COMPONENTS.mysteryWin]: StylefulUpdatableText;
+    [COMPONENTS.bonusWin]: StylefulUpdatableText;
+    [COMPONENTS.superBonusWin]: StylefulUpdatableText;
 }

package/dist/Rainman/appConfig.js

@@ -17,6 +17,7 @@ export const defaultAppConfig = {
     fontFace: ["HelveticaNeueLTStd"],
     disableFreeSpinText: false,
     winLineIndicatorSymbolScale: 0.75,
+    disableBigWinOnBonus: false,
     durationOfActions: {
         eachColumnsSpinDelay: [0, 200, 700, 1200, 1800],
         spinBaseTime: 800,
@@ -40,6 +41,10 @@ export const defaultAppConfig = {
         mysteryWinMinimumTime: 2000,
         bigWinMinimumTime: 2000,
         bigWinPhaseTimeout: 2800,
+        bonusWinPhaseTimeout: 2800,
+        bonusWinMinimumTime: 2000,
+        superBonusWinMinimumTime: 2000,
+        superBonusWinPhaseTimeout: 2600,
         speedPopupVisibleTime: 2000,
         minAnimationTime: 1000,
     },

package/dist/Rainman/types.d.ts

@@ -23,6 +23,7 @@ export type OptionalAppConfig = {
     autoplayGlowColor: number;
     winLineIndicatorSymbolScale: number;
     disableFreeSpinText: boolean;
+    disableBigWinOnBonus?: boolean;
     durationOfActions: {
         eachColumnsSpinDelay: number[];
         spinBaseTime: number;
@@ -46,6 +47,10 @@ export type OptionalAppConfig = {
         mysteryWinMinimumTime: number;
         bigWinMinimumTime: number;
         bigWinPhaseTimeout: number;
+        bonusWinPhaseTimeout: number;
+        bonusWinMinimumTime: number;
+        superBonusWinPhaseTimeout: number;
+        superBonusWinMinimumTime: number;
         speedPopupVisibleTime: number;
         minAnimationTime: number;
     };

package/dist/application/ButtonsEventManager/ButtonsEventManager.js

@@ -1,5 +1,6 @@
 import i18n from "i18next";
 import { sample } from "lodash";
+import { pixiSoundContext } from "../../application";
 import { AutoplayButton, Background, BUTTONS, COMPONENTS, FreeSpinButton, MessageBox, SpeedControlButton, VolumeButton, } from "../../components";
 import { RainMan } from "../../Rainman";
 import { allUiItems, hideLayerIfPresent, UI_ITEMS } from "../../utils";
@@ -185,6 +186,7 @@ export class ButtonsEventManager {
         RainMan.settingsStore.setUpdateVolumeButtonTexture(() => RainMan.componentRegistry.get(VolumeButton.registryName).changeTextureDependOnVolume());
         RainMan.componentRegistry.get(VolumeButton.registryName).setOnClick(() => {
             RainMan.settingsStore.flipSoundsEnabled();
+            pixiSoundContext.refresh();
             RainMan.componentRegistry.get(VolumeButton.registryName).changeTextureDependOnVolume();
             this.handleModalInvocation(UI_ITEMS.volume);
         });

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

@@ -1,5 +1,7 @@
+import { sound } from "@pixi/sound";
 import { SpeedAdapterInterface, SpeedLevel, SpeedLevelDirectory } from "../SpeedState";
 import { SoundOverrides, SoundTrack } from "./types";
+export declare const pixiSoundContext: typeof sound.context;
 /**
  * Class for managing sound in game, uses the pixi sound library
  * The class uses SoundTrack enum to access specified sounds

package/dist/application/SoundManager/SoundManager.js

@@ -1,7 +1,8 @@
-import { Sound } from "@pixi/sound";
+import { Sound, sound } from "@pixi/sound";
 import { RainMan } from "../../Rainman";
 import { SoundTracks } from "./types";
 const soundsToLoop = [SoundTracks.mysteryFxLoop, SoundTracks.music];
+export const pixiSoundContext = sound.context;
 /**
  * Class for managing sound in game, uses the pixi sound library
  * The class uses SoundTrack enum to access specified sounds
@@ -42,13 +43,12 @@ export class SoundManagerInstance {
                     url,
                     autoPlay: false,
                     preload: true,
-                    loop: soundsToLoop.includes(soundName),
                     loaded: () => resolve(),
                 });
                 this.musicCatalogue.set(soundName, sound);
             }));
         }
-        await Promise.all(loadingSoundsPromises);
+        await Promise.allSettled(loadingSoundsPromises);
     }
     /**
      * Function for setting volume level for each sound in game
@@ -76,6 +76,7 @@ export class SoundManagerInstance {
      */
     setPlayStatus(soundName, flag) {
         flag ? this.play(soundName) : this.pause(soundName);
+        pixiSoundContext.refresh();
     }
     /**
      * Function for playing sound with given name

package/dist/components/AbstractMainContainer/AbstractMainContainer.d.ts

@@ -18,10 +18,12 @@ import { MessageBox } from "../messageBox";
  */
 export declare abstract class AbstractMainContainer extends Container {
     static readonly registryName = "mainContainer";
+    messageBox: MessageBox;
     protected bigWinContainer: Nullable<UpdatableSpineContainer>;
     protected mysteryWinContainer: Nullable<UpdatableSpineContainer>;
+    protected bonusWinContainer: Nullable<UpdatableSpineContainer>;
+    protected superBonusWinContainer: Nullable<UpdatableSpineContainer>;
     protected overlay: Nullable<Graphics>;
-    messageBox: MessageBox;
     protected readonly buttonsEventManager: ButtonsEventManager;
     protected logo: Nullable<Logo>;
     protected abstract background: IResizableContainer;
@@ -39,6 +41,8 @@ export declare abstract class AbstractMainContainer extends Container {
     protected _freeSpinSummary: Nullable<AbstractFreeSpinContainer>;
     private _bigWinInvokedAt;
     private _mysteryWinInvokedAt;
+    private _bonusWinInvokedAt;
+    private _superBonusWinInvokedAt;
     protected abstract _frame: AbstractFrame;
     protected _controller: Nullable<AbstractController<unknown>>;
     protected constructor();
@@ -51,6 +55,24 @@ export declare abstract class AbstractMainContainer extends Container {
     get freeSpinPlate(): Nullable<AbstractFreeSpinContainer>;
     get freeSpinSummary(): Nullable<AbstractFreeSpinContainer>;
     protected createFreeSpinPlate(_resolver: () => void, _freeSpinCount: number, _isAdditionalFreeSpin: boolean): AbstractFreeSpinContainer | null;
+    /**
+     * Function for creating bonus win container
+     *
+     * @returns {Nullable<UpdatableSpineContainer>}
+     */
+    protected createBonusWinContainer(): Nullable<UpdatableSpineContainer>;
+    /**
+     * Function for creating super bonus win container
+     *
+     * @returns {Nullable<UpdatableSpineContainer>}
+     */
+    protected createSuperBonusWinContainer(): Nullable<UpdatableSpineContainer>;
+    /**
+     * Function for creating mystery win container
+     *
+     * @returns {Nullable<UpdatableSpineContainer>}
+     */
+    protected createMysteryWinContainer(): Nullable<UpdatableSpineContainer>;
     /**
      * Function for invoking free spin plate
      * If game draw an additional free spin, you can set isAdditionalFreeSpin to true
@@ -73,12 +95,17 @@ export declare abstract class AbstractMainContainer extends Container {
     protected hideOverlay(): void;
     get bigWinVisibleFor(): number;
     get mysteryWinVisibleFor(): number;
+    get bonusWinVisibleFor(): number;
+    get superBonusWinVisibleFor(): number;
     protected abstract createBigWinContainer(): UpdatableSpineContainer;
     invokeBigWin(): void;
-    protected createMysteryWinContainer(): UpdatableSpineContainer | null;
+    invokeSuperBonusWin(): void;
+    invokeBonusWin(): void;
     invokeMysteryWin(): void;
     destroyBigWin(): void;
     destroyMysteryWin(): void;
+    destroyBonusWin(): void;
+    destroySuperBonusWin(): void;
     invokeGambleGame(): Promise<void>;
     protected createUnderFramePanel(): Graphics | Sprite;
     enableForMobile(): void;

package/dist/components/AbstractMainContainer/AbstractMainContainer.js

@@ -15,10 +15,12 @@ import { MessageBox } from "../messageBox";
  */
 export class AbstractMainContainer extends Container {
     static registryName = "mainContainer";
+    messageBox;
     bigWinContainer = null;
     mysteryWinContainer = null;
+    bonusWinContainer = null;
+    superBonusWinContainer = null;
     overlay = null;
-    messageBox;
     buttonsEventManager;
     logo = null;
     animatedFront = null;
@@ -33,6 +35,8 @@ export class AbstractMainContainer extends Container {
     _freeSpinSummary = null;
     _bigWinInvokedAt = null;
     _mysteryWinInvokedAt = null;
+    _bonusWinInvokedAt = null;
+    _superBonusWinInvokedAt = null;
     _controller = null;
     constructor() {
         super();
@@ -61,6 +65,30 @@ export class AbstractMainContainer extends Container {
     createFreeSpinPlate(_resolver, _freeSpinCount, _isAdditionalFreeSpin) {
         return null;
     }
+    /**
+     * Function for creating bonus win container
+     *
+     * @returns {Nullable<UpdatableSpineContainer>}
+     */
+    createBonusWinContainer() {
+        return null;
+    }
+    /**
+     * Function for creating super bonus win container
+     *
+     * @returns {Nullable<UpdatableSpineContainer>}
+     */
+    createSuperBonusWinContainer() {
+        return null;
+    }
+    /**
+     * Function for creating mystery win container
+     *
+     * @returns {Nullable<UpdatableSpineContainer>}
+     */
+    createMysteryWinContainer() {
+        return null;
+    }
     /**
      * Function for invoking free spin plate
      * If game draw an additional free spin, you can set isAdditionalFreeSpin to true
@@ -144,6 +172,12 @@ export class AbstractMainContainer extends Container {
     get mysteryWinVisibleFor() {
         return this._mysteryWinInvokedAt == null ? 0 : performance.now() - this._mysteryWinInvokedAt;
     }
+    get bonusWinVisibleFor() {
+        return this._bonusWinInvokedAt == null ? 0 : performance.now() - this._bonusWinInvokedAt;
+    }
+    get superBonusWinVisibleFor() {
+        return this._superBonusWinInvokedAt == null ? 0 : performance.now() - this._superBonusWinInvokedAt;
+    }
     invokeBigWin() {
         if (this.bigWinContainer !== null) {
             throw new Error("😡 Big Win is already declared");
@@ -158,8 +192,32 @@ export class AbstractMainContainer extends Container {
         SoundManager.play(SoundTracks.bigWin);
         this._bigWinInvokedAt = performance.now();
     }
-    createMysteryWinContainer() {
-        return null;
+    invokeSuperBonusWin() {
+        if (this.superBonusWinContainer !== null) {
+            throw new Error("😡 Super Bonus Win is already declared");
+        }
+        const { width, height } = RainMan.app.screen;
+        this.superBonusWinContainer = this.createSuperBonusWinContainer();
+        if (!this.superBonusWinContainer)
+            return;
+        this.superBonusWinContainer.x = width / 2;
+        this.superBonusWinContainer.y = height / 2;
+        this.superBonusWinContainer.resize();
+        this.superBonusWinContainer.parentLayer = UXLayer;
+        this.addChild(this.superBonusWinContainer);
+        this._superBonusWinInvokedAt = performance.now();
+    }
+    invokeBonusWin() {
+        if (this.bonusWinContainer !== null) {
+            throw new Error("😡 Bonus Win is already declared");
+        }
+        this.bonusWinContainer = this.createBonusWinContainer();
+        if (!this.bonusWinContainer)
+            return;
+        this.bonusWinContainer.resize();
+        this.bonusWinContainer.parentLayer = UXLayer;
+        this.addChild(this.bonusWinContainer);
+        this._bonusWinInvokedAt = performance.now();
     }
     invokeMysteryWin() {
         if (this.mysteryWinContainer !== null) {
@@ -194,6 +252,24 @@ export class AbstractMainContainer extends Container {
         this.mysteryWinContainer = null;
         this._mysteryWinInvokedAt = null;
     }
+    destroyBonusWin() {
+        if (this.bonusWinContainer === null)
+            return;
+        this.removeChild(this.bonusWinContainer);
+        this.bonusWinContainer.destroyAnimations();
+        this.bonusWinContainer.destroy({ children: true });
+        this.bonusWinContainer = null;
+        this._bonusWinInvokedAt = null;
+    }
+    destroySuperBonusWin() {
+        if (this.superBonusWinContainer === null)
+            return;
+        this.removeChild(this.superBonusWinContainer);
+        this.superBonusWinContainer.destroyAnimations();
+        this.superBonusWinContainer.destroy({ children: true });
+        this.superBonusWinContainer = null;
+        this._superBonusWinInvokedAt = null;
+    }
     async invokeGambleGame() {
         if (!this.gambleGameSpineName)
             return;
@@ -257,6 +333,15 @@ export class AbstractMainContainer extends Container {
         if (this.bigWinContainer) {
             this.removeChild(this.bigWinContainer);
         }
+        if (this.mysteryWinContainer) {
+            this.removeChild(this.mysteryWinContainer);
+        }
+        if (this.superBonusWinContainer) {
+            this.removeChild(this.superBonusWinContainer);
+        }
+        if (this.bonusWinContainer) {
+            this.removeChild(this.bonusWinContainer);
+        }
         this.messageBox.resize();
         this.background.resize();
         this.animatedFront?.resize();
@@ -352,6 +437,16 @@ export class AbstractMainContainer extends Container {
             this.addChild(this.bigWinContainer);
             this.bigWinContainer.resize();
         }
+        if (this.superBonusWinContainer) {
+            this.removeChild(this.superBonusWinContainer);
+            this.addChild(this.superBonusWinContainer);
+            this.superBonusWinContainer.resize();
+        }
+        if (this.bonusWinContainer) {
+            this.removeChild(this.bonusWinContainer);
+            this.addChild(this.bonusWinContainer);
+            this.bonusWinContainer.resize();
+        }
         if (this.mysteryWinContainer) {
             this.removeChild(this.mysteryWinContainer);
             this.addChild(this.mysteryWinContainer);

package/dist/components/buttons/registrynames.d.ts

@@ -17,5 +17,7 @@ export declare const COMPONENTS: {
     readonly creditText: "creditText";
     readonly bigWin: "bigWinText";
     readonly mysteryWin: "mysteryWinText";
+    readonly bonusWin: "bonusWinText";
+    readonly superBonusWin: "superBonusWinText";
     readonly autoSpinConfirm: "autoSpin-confirm";
 };

package/dist/components/buttons/registrynames.js

@@ -17,5 +17,7 @@ export const COMPONENTS = {
     creditText: "creditText",
     bigWin: "bigWinText",
     mysteryWin: "mysteryWinText",
+    bonusWin: "bonusWinText",
+    superBonusWin: "superBonusWinText",
     autoSpinConfirm: "autoSpin-confirm",
 };

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

@@ -60,6 +60,7 @@
         "doubleTo": "DOUBLE TO",
         "collect": "COLLECT",
         "totalBet": "Bet",
-        "buyFreeSpins": "Buy Free Spins"
+        "buyFreeSpins": "Buy Free Spins",
+        "possibleWin": "POSSIBLE WIN: "
     }
 }

package/dist/components/messageBox/MessageBox.d.ts

@@ -19,26 +19,31 @@ export declare class MessageBox extends Container {
     static readonly freeSpinTextRegistryName = "freeSpinAmount";
     static readonly autoSpinTextRegistryName = "autoSpinAmount";
     static readonly currentWinTextRegistryName = "winAmount";
+    static readonly possibleWinTextRegistryName = "possibleWinAmount";
     private readonly positioningFrame;
-    private readonly currentWinText;
     private readonly autoSpinText;
     private readonly freeSpinText;
     private readonly incentiveText;
+    private readonly currentWinText;
+    private readonly possibleWinText;
     private winLineIndicator?;
     private currentWinShown;
     private autoSpinShown;
     private freeSpinShown;
+    private possibleWinShown;
     private incentiveMessageShown;
     private winLineIndicatorShown;
     constructor();
     updateIncentiveText(newText: string): void;
     hideCurrentWinText(): void;
+    hidePossibleWinText(): void;
     hideFreeSpinText(): void;
     hideAutoSpinText(): void;
     hideIncentiveText(): void;
     hideWinLineIndicator(): void;
     resize(): void;
     showCurrentWinText(): void;
+    showPossibleWinText(): void;
     showAutoSpinText(): void;
     showFreeSpinText(): void;
     showIncentiveText(): void;

package/dist/components/messageBox/MessageBox.js

@@ -24,15 +24,18 @@ export class MessageBox extends Container {
     static freeSpinTextRegistryName = "freeSpinAmount";
     static autoSpinTextRegistryName = "autoSpinAmount";
     static currentWinTextRegistryName = "winAmount";
+    static possibleWinTextRegistryName = "possibleWinAmount";
     positioningFrame;
-    currentWinText;
     autoSpinText;
     freeSpinText;
     incentiveText;
+    currentWinText;
+    possibleWinText;
     winLineIndicator = undefined;
     currentWinShown = false;
     autoSpinShown = false;
     freeSpinShown = false;
+    possibleWinShown = false;
     incentiveMessageShown = false;
     winLineIndicatorShown = false;
     constructor() {
@@ -49,6 +52,7 @@ export class MessageBox extends Container {
         this.freeSpinText = new UpdatableTextComponent(MessageBox.freeSpinTextRegistryName, i18n.t("currentFreeSpins"), UPDATABLE_MODES.int, fontSize, new Color(0xffffff).toHex(), () => this.centerTextOnX(this.freeSpinText));
         this.autoSpinText = new UpdatableTextComponent(MessageBox.autoSpinTextRegistryName, i18n.t("autoSpinsLeft"), UPDATABLE_MODES.int, fontSize, new Color(0xffffff).toHex(), () => this.centerTextOnX(this.autoSpinText));
         this.currentWinText = new UpdatableTextComponent(MessageBox.currentWinTextRegistryName, i18n.t("currentWin"), UPDATABLE_MODES.money, fontSize, undefined, () => this.centerTextOnX(this.currentWinText));
+        this.possibleWinText = new UpdatableTextComponent(MessageBox.possibleWinTextRegistryName, i18n.t("possibleWin"), UPDATABLE_MODES.money, fontSize, undefined, () => this.centerTextOnX(this.possibleWinText));
         this.incentiveText = new Text(sample(i18n.t("idleMessages", { returnObjects: true })[RainMan.componentRegistry.getSpeedLevel()]), {
             fontFamily: RainMan.config.fontFace,
             fontSize,
@@ -58,9 +62,15 @@ export class MessageBox extends Container {
         });
         this.incentiveText.y = -25;
         this.currentWinText.y = -25;
+        this.possibleWinText.y = -25;
         this.freeSpinText.y = this.currentWinText.y + this.currentWinText.height / 2 + this.freeSpinText.height / 2;
         this.autoSpinText.y = this.currentWinText.y + this.currentWinText.height / 2 + this.autoSpinText.height / 2;
-        RainMan.componentRegistry.addMany([this.currentWinText, this.autoSpinText, this.freeSpinText]);
+        RainMan.componentRegistry.addMany([
+            this.currentWinText,
+            this.autoSpinText,
+            this.freeSpinText,
+            this.possibleWinText,
+        ]);
     }
     updateIncentiveText(newText) {
         this.incentiveText.text = newText;
@@ -72,6 +82,12 @@ export class MessageBox extends Container {
             this.removeChild(this.currentWinText);
         }
     }
+    hidePossibleWinText() {
+        if (this.possibleWinShown) {
+            this.possibleWinShown = false;
+            this.removeChild(this.possibleWinText);
+        }
+    }
     hideFreeSpinText() {
         if (this.freeSpinShown) {
             this.freeSpinShown = false;
@@ -115,6 +131,14 @@ export class MessageBox extends Container {
         this.centerTextOnX(this.currentWinText);
         this.addChild(this.currentWinText);
     }
+    showPossibleWinText() {
+        this.hideIncentiveText();
+        if (this.possibleWinShown)
+            return;
+        this.possibleWinShown = true;
+        this.centerTextOnX(this.possibleWinText);
+        this.addChild(this.possibleWinText);
+    }
     showAutoSpinText() {
         this.hideIncentiveText();
         this.hideWinLineIndicator();
@@ -138,6 +162,7 @@ export class MessageBox extends Container {
     }
     showIncentiveText() {
         this.hideCurrentWinText();
+        this.hidePossibleWinText();
         this.hideFreeSpinText();
         this.hideAutoSpinText();
         this.hideWinLineIndicator();

package/dist/controllers/AbstractController.d.ts

@@ -41,6 +41,8 @@ export declare abstract class AbstractController<T> {
     protected uiController: UiController;
     protected resolveBigWin?: () => void;
     protected resolveMysteryWin?: () => void;
+    protected resolveBonusWin?: () => void;
+    protected resolveSuperBonusWin?: () => void;
     protected mysteryFxSymbol: SymbolId | null;
     protected mysteryFxSymbolMustFormWinningLine: boolean;
     protected mysteryWinSymbol: Nullable<SymbolId>;
@@ -88,7 +90,6 @@ export declare abstract class AbstractController<T> {
     private setRefreshButtonBasedOnPhase;
     private setMessageBoxBasedOnPhase;
     protected getReelIndexesToShowMysteryFx(spinLogic: SpinLogic): number[];
-    protected showSuperBonusWin(removeBonusWin: Promise<void>): void;
     /**
      * Function is responsible for initializing the spin process
      * This also is handler for refresh button and space functionalities
@@ -151,7 +152,9 @@ export declare abstract class AbstractController<T> {
     private lockLogicWhileSpinning;
     private unlockLogicAfterSpinning;
     protected stopPlayingSymbolsStreak(): void;
-    protected countWinBigWin(customAmount?: number): Promise<void>;
+    protected countBigWin(customAmount?: number): Promise<void>;
+    protected countBonusWin(winAmount?: number): Promise<void>;
+    protected countSuperBonusWin(winAmount?: number): Promise<void>;
     protected countMysteryWin(winAmount?: number, quantity?: number): Promise<void>;
     /**
      * Parser for streaks and reels quantity

package/dist/controllers/AbstractController.js

@@ -40,6 +40,8 @@ export class AbstractController {
     uiController;
     resolveBigWin;
     resolveMysteryWin;
+    resolveBonusWin;
+    resolveSuperBonusWin;
     mysteryFxSymbol = null;
     mysteryFxSymbolMustFormWinningLine = false;
     mysteryWinSymbol = null;
@@ -56,7 +58,6 @@ export class AbstractController {
         this.uiController = new UiController(this.config);
         this.componentRegistry = RainMan.componentRegistry;
         this.setupSpaceOrEnterListener();
-        RainMan.settingsStore.showSuperBonusWin = this.showSuperBonusWin.bind(this);
         RainMan.settingsStore.increaseBet = () => this.uiController.updateBet("increase");
         RainMan.settingsStore.decreaseBet = () => this.uiController.updateBet("decrease");
     }
@@ -299,17 +300,6 @@ export class AbstractController {
         }
         return reelsIndexesWithScatter;
     }
-    showSuperBonusWin(removeBonusWin) {
-        this.changeGamePhase(gamePhases.BIG_WIN_INVOKED);
-        const winAmount = RainMan.settingsStore.cumulativeWinAmount > 0
-            ? RainMan.settingsStore.cumulativeWinAmount
-            : this.uiController.recentWin;
-        this.countWinBigWin(winAmount).then(async () => {
-            await removeBonusWin;
-            this.changeGamePhase(gamePhases.IDLE);
-        });
-        RainMan.settingsStore.resetCumulativeWinAmount();
-    }
     /**
      * Function is responsible for initializing the spin process
      * This also is handler for refresh button and space functionalities
@@ -349,6 +339,22 @@ export class AbstractController {
             this.resolveBigWin?.();
             this.resolveBigWin = undefined;
         }
+        if (this.mainContainer.bonusWinVisibleFor) {
+            RainMan.componentRegistry.get(COMPONENTS.bonusWin).set(this.uiController.recentWin);
+        }
+        if (this.mainContainer.bonusWinVisibleFor > RainMan.config.durationOfActions.bonusWinMinimumTime) {
+            this.mainContainer.destroyBonusWin();
+            this.resolveBonusWin?.();
+            this.resolveBonusWin = undefined;
+        }
+        if (this.mainContainer.superBonusWinVisibleFor) {
+            RainMan.componentRegistry.get(COMPONENTS.superBonusWin).set(this.uiController.recentWin);
+        }
+        if (this.mainContainer.superBonusWinVisibleFor > RainMan.config.durationOfActions.superBonusWinMinimumTime) {
+            this.mainContainer.destroySuperBonusWin();
+            this.resolveSuperBonusWin?.();
+            this.resolveSuperBonusWin = undefined;
+        }
         this.throttledSpin();
     }
     /**
@@ -570,7 +576,7 @@ export class AbstractController {
         }
         this.composeWinActionsQueue(spinLogic);
         await this.playWinActionQueue();
-        await this.countWinBigWin();
+        await this.countBigWin();
         await this.handleLoopingWinActionQueue();
         this.clearAndDestroyActions();
         debugSymbolsMatchConfiguration(spinLogic.finalBlindsConfiguration);
@@ -673,9 +679,10 @@ export class AbstractController {
         this.columnsContainer.stopPlayingSymbolsInColumns();
         this.frame.stopPlayingWinLineAnimations();
     }
-    async countWinBigWin(customAmount) {
+    async countBigWin(customAmount) {
         if (this.uiController.recentWin <= RainMan.config.constants.bigWinMultiplier * RainMan.settingsStore.bet &&
-            !customAmount)
+            !customAmount &&
+            RainMan.config.disableBigWinOnBonus)
             return;
         const amount = customAmount || this.uiController.recentWin;
         this.mainContainer.invokeBigWin();
@@ -694,6 +701,47 @@ export class AbstractController {
             }, RainMan.config.durationOfActions.bigWinPhaseTimeout / animationTimeDivider);
         });
     }
+    async countBonusWin(winAmount) {
+        if (!winAmount)
+            return;
+        const amount = winAmount || this.uiController.recentWin;
+        this.mainContainer.invokeBonusWin();
+        this.changeGamePhase(gamePhases.BIG_WIN_INVOKED);
+        const animationTimeDivider = RainMan.settingsStore.currentSpeed === SPEED_LEVELS.fast ? 3 : 1;
+        await RainMan.componentRegistry
+            .get(COMPONENTS.bonusWin)
+            .update(amount, RainMan.config.durationOfActions.updatableTextCountingDuration / animationTimeDivider);
+        await new Promise((resolve) => {
+            this.resolveBonusWin = resolve;
+            setTimeout(() => {
+                if (this.resolveBonusWin === undefined)
+                    return;
+                this.mainContainer.destroyBonusWin();
+                this.resolveBonusWin();
+                this.resolveBonusWin = undefined;
+            }, RainMan.config.durationOfActions.bonusWinPhaseTimeout / animationTimeDivider);
+        });
+    }
+    async countSuperBonusWin(winAmount) {
+        if (!winAmount)
+            return;
+        const amount = winAmount || RainMan.settingsStore.cumulativeWinAmount;
+        this.mainContainer.invokeSuperBonusWin();
+        const animationTimeDivider = RainMan.settingsStore.currentSpeed === SPEED_LEVELS.fast ? 3 : 1;
+        await RainMan.componentRegistry
+            .get(COMPONENTS.superBonusWin)
+            .update(amount, RainMan.config.durationOfActions.updatableTextCountingDuration / animationTimeDivider);
+        await new Promise((resolve) => {
+            this.resolveSuperBonusWin = resolve;
+            setTimeout(() => {
+                if (this.resolveSuperBonusWin === undefined)
+                    return;
+                this.mainContainer.destroySuperBonusWin();
+                this.resolveSuperBonusWin();
+                this.resolveSuperBonusWin = undefined;
+            }, RainMan.config.durationOfActions.superBonusWinPhaseTimeout / animationTimeDivider);
+        });
+    }
     async countMysteryWin(winAmount, quantity = 3) {
         if (!winAmount || !this.mysteryWinSymbol)
             return;

package/dist/controllers/UiController.d.ts

@@ -39,6 +39,7 @@ export declare class UiController {
     updateShownSpeedLevel(currentSpeed: SpeedLevel): void;
     updateShownBalance(): void;
     updateShownCurrentWin(): void;
+    updateShownPossibleWin(): void;
     updateShownFreeSpinAmount(amount: number, isAdditionalFreeSpins?: boolean): void;
     delegateUpdatingWinAndBalance(amount: Nullable<number>): void;
     updateDisplayedWin(amount: Nullable<number>): Promise<void>;

package/dist/controllers/UiController.js

@@ -105,6 +105,10 @@ export class UiController {
         }
         RainMan.componentRegistry.get(MessageBox.currentWinTextRegistryName).set(this.recentWin);
     }
+    updateShownPossibleWin() {
+        this.messageBox.showPossibleWinText();
+        RainMan.componentRegistry.get(MessageBox.possibleWinTextRegistryName).set(this.recentWin);
+    }
     updateShownFreeSpinAmount(amount, isAdditionalFreeSpins = false) {
         if (isAdditionalFreeSpins)
             RainMan.componentRegistry.get(MessageBox.freeSpinTextRegistryName).update(amount);

package/dist/stores/SettingsStore.d.ts

@@ -43,7 +43,6 @@ export declare class SettingsStore {
     popupPaytableRepositionCallback?: () => void;
     updateVolumeButtonTexture?: () => void;
     handleModalInvocation?: (layerId: string) => void;
-    showSuperBonusWin?: (callback: Promise<void>) => void;
     increaseBet?: () => void;
     decreaseBet?: () => void;
     private readonly initialAutoplaySettingsState;
@@ -73,7 +72,6 @@ export declare class SettingsStore {
     setBalancedDecreased(newValue: number): void;
     getMinimumPaytableValue(multipliers: RangeQuantityValue[keyof RangeQuantityValue]): number;
     getMaximumPaytableValue(multipliers: RangeQuantityValue[keyof RangeQuantityValue]): number;
-    forceSuperBigWin(removeBonusWin: Promise<void>): void;
     setDataForSymbolPaytablePopup(symbolId: SymbolId, repositionCallback: () => void): void;
     resetDataForSymbolPaytablePopup(): void;
     setUpdateVolumeButtonTexture(fn: () => void): void;

package/dist/stores/SettingsStore.js

@@ -49,7 +49,6 @@ export class SettingsStore {
     popupPaytableRepositionCallback;
     updateVolumeButtonTexture;
     handleModalInvocation;
-    showSuperBonusWin;
     increaseBet;
     decreaseBet;
     initialAutoplaySettingsState = {
@@ -224,9 +223,6 @@ export class SettingsStore {
             return last(multipliers) || 0;
         return 0;
     }
-    forceSuperBigWin(removeBonusWin) {
-        this.showSuperBonusWin?.(removeBonusWin);
-    }
     setDataForSymbolPaytablePopup(symbolId, repositionCallback) {
         this.popupPaytableRepositionCallback = repositionCallback;
         this.popupPaytableRepositionCallback();

package/package.json

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