pixi-rainman-game-engine 0.2.27 → 0.2.29

package/dist/ComponentRegistry/ComponentRegistry.js

@@ -24,7 +24,7 @@ export class ComponentRegistry {
      */
     setTemporarySpeedLevel(newSpeedLevel) {
         this.speedLevelHandler.setSpeed(newSpeedLevel);
-        this.updateAllSpeedAdaptable(this.speedLevelHandler.currentSpeed);
+        this.updateAllSpeedAdaptable(newSpeedLevel);
     }
     /**
      * Method for reverting speed level for turbo spin
@@ -32,7 +32,7 @@ export class ComponentRegistry {
      */
     revertTemporarySpeedLevel() {
         this.speedLevelHandler.setSpeed(RainMan.settingsStore.currentSpeed);
-        this.updateAllSpeedAdaptable(this.speedLevelHandler.currentSpeed);
+        this.updateAllSpeedAdaptable(RainMan.settingsStore.currentSpeed);
     }
     /**
      * Setter fo speed level

package/dist/SettingsUI/hooks/useBuyFreeSpins/useBuyFreeSpins.js

@@ -5,7 +5,7 @@ export const useBuyFreeSpinOptions = () => {
     const [options, setOptions] = useState([]);
     useEffect(() => {
         const disposer = autorun(() => {
-            setOptions(Object.entries(RainMan.settingsStore.freeSpinBuyTable).map(([amount, multiplier]) => ({
+            setOptions(Object.entries(RainMan.settingsStore.freeSpinBuyTable ?? {}).map(([amount, multiplier]) => ({
                 amount: parseInt(amount, 10),
                 price: multiplier
             })));

package/dist/application/ButtonsEventManager/ButtonsEventManager.d.ts

@@ -131,5 +131,15 @@ export declare class ButtonsEventManager {
      * @param {string} layerName - name of layer
      */
     private handleModalInvocation;
+    /**
+     * Function for closing all other modals except the one with given name
+     * @param {string} activeLayerName - name of the layer that should remain open
+     */
+    private closeOtherModals;
+    /**
+     * Function for checking if any layer is present except the one with given name
+     * @param {string} layerName - name of layer to check
+     * @returns {boolean} - true if any other layer is present, false otherwise
+     */
     private checkAnyLayerIsPresent;
 }

package/dist/application/ButtonsEventManager/ButtonsEventManager.js

@@ -1,6 +1,6 @@
 import i18n from "i18next";
 import { sample } from "lodash";
-import { SoundManager } from "../../application";
+import { SoundManager, SoundTracks } from "../../application";
 import { AutoplayButton, Background, BUTTONS, COMPONENTS, FreeSpinButton, MessageBox, SpeedControlButton, VolumeButton } from "../../components";
 import { RainMan } from "../../Rainman";
 import { allUiItems, hideLayerIfPresent, UI_ITEMS, wait } from "../../utils";
@@ -199,7 +199,7 @@ export class ButtonsEventManager {
             if (RainMan.settingsStore.isSoundEnabled()) {
                 SoundManager.resumeAll();
                 if (RainMan.settingsStore.shouldPlayAmbientMusic) {
-                    SoundManager.setPlayStatus("music", RainMan.settingsStore.shouldPlayAmbientMusic);
+                    SoundManager.setPlayStatus(RainMan.settingsStore.isFreeSpinsPlayEnabled ? SoundTracks.freeSpinsMusic : SoundTracks.music, RainMan.settingsStore.shouldPlayAmbientMusic);
                 }
             }
             RainMan.componentRegistry.get(VolumeButton.registryName).changeTextureDependOnVolume();
@@ -327,6 +327,9 @@ export class ButtonsEventManager {
     handleModalInvocation(layerName) {
         if (this.checkAnyLayerIsPresent(layerName) && RainMan.globals.shouldShowModals)
             return;
+        if (this.checkAnyLayerIsPresent(layerName)) {
+            this.closeOtherModals(layerName);
+        }
         const layer = window.document.getElementById(layerName);
         if (layer !== null) {
             if (layer.style.display !== "flex") {
@@ -339,6 +342,26 @@ export class ButtonsEventManager {
             }
         }
     }
+    /**
+     * Function for closing all other modals except the one with given name
+     * @param {string} activeLayerName - name of the layer that should remain open
+     */
+    closeOtherModals(activeLayerName) {
+        for (const itemId of allUiItems) {
+            if (itemId === activeLayerName) {
+                continue;
+            }
+            const layer = window.document.getElementById(itemId);
+            if (layer !== null && layer.style.display === "flex") {
+                layer.style.display = "none";
+            }
+        }
+    }
+    /**
+     * Function for checking if any layer is present except the one with given name
+     * @param {string} layerName - name of layer to check
+     * @returns {boolean} - true if any other layer is present, false otherwise
+     */
     checkAnyLayerIsPresent(layerName) {
         return Object.values(UI_ITEMS).some((item) => {
             if (item === layerName)

package/dist/application/SoundManager/SoundManager.js

@@ -1,7 +1,7 @@
 import { Sound, sound } from "@pixi/sound";
 import { RainMan } from "../../Rainman";
 import { SoundTracks } from "./types";
-const soundsToLoop = [SoundTracks.mysteryFxLoop, SoundTracks.music];
+const soundsToLoop = [SoundTracks.mysteryFxLoop, SoundTracks.music, SoundTracks.freeSpinsMusic];
 export const pixiSoundContext = sound.context;
 /**
  * Class for managing sound in game, uses the pixi sound library
@@ -86,20 +86,26 @@ export class SoundManagerInstance {
      * @param {SoundTrack} soundName - name of the sound
      */
     play(soundName) {
-        if (!RainMan.settingsStore.shouldPlayFxSounds)
+        if (!RainMan.settingsStore.shouldPlayFxSounds) {
             return;
+        }
         const overrideSoundName = this.overrides[soundName];
         const sound = overrideSoundName
             ? this.musicCatalogue.get(overrideSoundName)
             : this.musicCatalogue.get(soundName);
-        if (!sound)
+        if (!sound) {
             return;
-        if (soundName === "music" && sound.isPlaying && !RainMan.settingsStore.shouldPlayAmbientMusic)
+        }
+        if (soundName === "music" &&
+            sound.isPlaying &&
+            !RainMan.settingsStore.isFreeSpinsPlayEnabled &&
+            !RainMan.settingsStore.shouldPlayAmbientMusic) {
             return;
+        }
         sound.play({
             loop: soundsToLoop.includes(soundName),
             singleInstance: true,
-            volume: soundName === "music" ? 0.5 : 1
+            volume: soundName === SoundTracks.music || soundName === SoundTracks.freeSpinsMusic ? 0.5 : 1
         });
     }
     /**
@@ -108,9 +114,19 @@ export class SoundManagerInstance {
      */
     resumeAll() {
         this.musicCatalogue.forEach((sound, soundName) => {
-            if (sound.paused && sound.isPlaying)
+            if (sound.paused && sound.isPlaying) {
                 sound.resume();
-            if (RainMan.settingsStore.shouldPlayAmbientMusic && soundName === SoundTracks.music && sound.paused) {
+            }
+            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();
             }
         });

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

@@ -6,6 +6,7 @@ import { Sound } from "@pixi/sound";
  * @property {string} deactivationAutostart - click on autostart button
  * @property {string} increaseRate - click on plus button
  * @property {string} music - ambient music in loop
+ * @property {string} freeSpinsMusic - ambient music in free spins
  * @property {string} reductionRate - click on neg button
  * @property {string} allRollStops - skipping rolling reels, on end
  * @property {string} bigWin - on show big win popup
@@ -36,6 +37,7 @@ export interface SoundTracks {
     deactivationAutostart: "deactivationAutostart";
     increaseRate: "increaseRate";
     music: "music";
+    freeSpinsMusic: "freeSpinsMusic";
     reductionRate: "reductionRate";
     allRollStops: "allRollStops";
     bigWin: "bigWin";

package/dist/application/SoundManager/types.js

@@ -5,6 +5,7 @@
  * @property {string} deactivationAutostart - click on autostart button
  * @property {string} increaseRate - click on plus button
  * @property {string} music - ambient music in loop
+ * @property {string} freeSpinsMusic - ambient music in free spins
  * @property {string} reductionRate - click on neg button
  * @property {string} allRollStops - skipping rolling reels, on end
  * @property {string} bigWin - on show big win popup
@@ -34,6 +35,7 @@ export const SoundTracks = {
     deactivationAutostart: "deactivationAutostart",
     increaseRate: "increaseRate",
     music: "music",
+    freeSpinsMusic: "freeSpinsMusic",
     reductionRate: "reductionRate",
     allRollStops: "allRollStops",
     bigWin: "bigWin",

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

@@ -137,7 +137,7 @@ export declare abstract class AbstractMainContainer extends Container {
      * @param {WinTypeId} winType win type of jackpot roulette win
      * @returns {void}
      */
-    private destroyRouletteWin;
+    protected destroyRouletteWin(winType: WinTypeId): void;
     /**
      * Function for invoking mystery bonus container
      * @param {string} animationName animation name for the mystery bonus container
@@ -273,7 +273,7 @@ export declare abstract class AbstractMainContainer extends Container {
      * Function for positioning the round win container.
      * @returns {void}
      */
-    private positionRoundWinContainer;
+    protected positionRoundWinContainer(): void;
     /**
      * Function for invoking the roulette win plate.
      * @param {string} winAnimationName The name of the win animation.

package/dist/components/buttons/BaseButton/BaseButton.js

@@ -1,6 +1,7 @@
 import { Sprite } from "pixi.js";
 import { SoundManager, SoundTracks } from "../../../application";
 import { TINT_DISABLED, TINT_ENABLED } from "../../../constants";
+import { hidePaytable } from "../../../utils";
 /**
  * Class for basic button with states and textures
  * @class BaseButton
@@ -23,6 +24,7 @@ export class BaseButton extends Sprite {
         }
         this._customClickHandler();
         this._manageStateOver();
+        hidePaytable();
     };
     _customClickHandler = () => { };
     constructor(name, textureMap, stateful = false, clickSound = SoundTracks.button) {

package/dist/components/frame/AbstractColumnsContainer.d.ts

@@ -31,11 +31,38 @@ export declare abstract class AbstractColumnsContainer extends Container impleme
         right: number;
     };
     protected constructor();
+    /**
+     * Function for initializing columns container
+     * @protected
+     * @returns {void}
+     */
     protected init(): void;
+    /**
+     * Function for resolving changing symbols in columns
+     * This is used in games i.e. BoW and MB
+     */
     resolveMysterySpeedUp(): void;
+    /**
+     * Method for adapting to speed level
+     * @param {SpeedLevel} speedLevel new speed level
+     * @public
+     */
     adaptToSpeed(speedLevel: SpeedLevel): void;
+    /**
+     * Function for enabling quick reels stop
+     * @public
+     * @returns {void}
+     */
     enableQuickReelsStop(): void;
+    /**
+     * Function for clearing quick reels stop
+     * @public
+     */
     clearQuickReelsStop(): void;
+    /**
+     * Function for blind spinning all columns
+     * @public
+     */
     blindSpin(): void;
     /**
      * This function is responsible for setting symbols in columns
@@ -46,8 +73,28 @@ export declare abstract class AbstractColumnsContainer extends Container impleme
      * @returns {Promise<void>}
      */
     configBlindSpin(finalSymbolReels: SymbolReels, afterSpinResolver: (value: void | PromiseLike<void>) => void, indexesOfReelsToExtendSpinningTime: number[]): Promise<void>;
+    /**
+     * Function for playing all streaks
+     * @param {StreakReelsIndexes[]} streaks - The streaks to play
+     * @param {number} amount - The amount to play
+     * @param {SymbolId[]} allSymbols - All symbols to consider
+     * @returns {Promise<void>} - A promise that resolves when all streaks are played
+     * @public
+     */
     playAllStreaks(streaks: StreakReelsIndexes[], amount: number, allSymbols?: SymbolId[]): Promise<void>;
+    /**
+     * Function for resetting played sounds
+     * @public
+     * @returns {void}
+     */
     resetPlayedSounds(): void;
+    /**
+     * Function for playing sound depending on the amount
+     * @public
+     * @param {number} amount - The amount to check
+     * @param {SymbolId[]} _allSymbols - All symbols to consider
+     * @returns {void}
+     */
     protected playSoundDependingOnAmount(amount: number, _allSymbols?: SymbolId[]): void;
     protected playStreakSound(symbols: SymbolId[]): void;
     /**
@@ -60,14 +107,71 @@ export declare abstract class AbstractColumnsContainer extends Container impleme
      * @returns {Promise<void>}
      */
     playStreak(streak: StreakReelsIndexes, reelsQuantity: number, multiplier?: number, suffix?: string): Promise<void>;
+    /**
+     * Method for resizing columns container
+     * @public
+     * @abstract
+     * @returns {void}
+     */
     abstract doResize(): void;
+    /**
+     * Function for animating columns
+     * @public
+     * @param {number} delta - delta time for animation
+     * @returns {void}
+     */
     animate(delta: number): void;
+    /**
+     * Function for getting column at specific position
+     * @param {number} column index of column
+     * @returns {AbstractSymbolsColumn} column at specific position
+     * @public
+     * @abstract
+     */
     abstract getColumnAtPosition(column: number): AbstractSymbolsColumn;
+    /**
+     * Function for stopping all playing symbols in columns
+     * @public
+     * @returns {void}
+     */
     stopPlayingSymbolsInColumns(): void;
+    /**
+     * Function for stopping all transformations playing symbols in columns
+     * @public
+     * @returns {void}
+     */
     stopPlayingSymbolsTransformationInColumns(): void;
+    /**
+     * Function for setting interactivity for all symbols in columns
+     * @param {boolean} flag - flag for setting interactivity
+     * @public
+     * @returns {void}
+     */
     setInteractivityForSymbols(flag: boolean): void;
+    /**
+     * Function for handling multiple symbol transformations
+     * @param {DropTransformationDetails} transformations - array of transformations to apply
+     * @param {boolean} skipAnimations - flag for skipping animations
+     * @param {boolean} isStandalone - flag for standalone mode
+     * @param {boolean} allowSoundInSymbolsColumn - flag for allowing sound in symbols column
+     * @returns {Promise<void>}
+     */
     handleDestroyTransformations(transformations: DropTransformationDetails[], skipAnimations?: boolean, isStandalone?: boolean, allowSoundInSymbolsColumn?: boolean): Promise<void>;
+    /**
+     * Function for creating mask for columns container
+     * @protected
+     * @returns {Graphics} mask for columns container
+     */
     protected createMask(): Graphics;
+    /**
+     * Function for fixing symbols columns position
+     * @public
+     */
     fixSymbolsColumnsPosition(): void;
+    /**
+     * Function for preparing configuring reels end
+     * @param {SymbolReels} finalSymbolReels - final symbol reels
+     * @returns {PlayableAction[]} - array of playable actions
+     */
     protected prepareConfiguringReelsEnd(finalSymbolReels: SymbolReels): PlayableAction[];
 }

package/dist/components/frame/AbstractColumnsContainer.js

@@ -32,6 +32,11 @@ export class AbstractColumnsContainer extends Container {
         this.name = AbstractColumnsContainer.registryName;
         this.parentLayer = FrameLayer;
     }
+    /**
+     * Function for initializing columns container
+     * @protected
+     * @returns {void}
+     */
     init() {
         this.allColumns.forEach((column) => {
             RainMan.componentRegistry.add(column);
@@ -40,6 +45,10 @@ export class AbstractColumnsContainer extends Container {
         Ticker.shared.add((delta) => this.animate(delta));
         this.doResize();
     }
+    /**
+     * Function for resolving changing symbols in columns
+     * This is used in games i.e. BoW and MB
+     */
     resolveMysterySpeedUp() {
         this.allColumns.forEach((column) => {
             if (column.resolveMysterySpeedUp === null)
@@ -47,22 +56,41 @@ export class AbstractColumnsContainer extends Container {
             column.resolveMysterySpeedUp();
         });
     }
+    /**
+     * Method for adapting to speed level
+     * @param {SpeedLevel} speedLevel new speed level
+     * @public
+     */
     adaptToSpeed(speedLevel) {
         this.velocityMultiplier = this.speedLevelMapper[speedLevel];
     }
+    /**
+     * Function for enabling quick reels stop
+     * @public
+     * @returns {void}
+     */
     enableQuickReelsStop() {
-        RainMan.componentRegistry.setTemporarySpeedLevel(SPEED_LEVELS.fast);
         this.quickReelsStop = true;
+        RainMan.componentRegistry.setTemporarySpeedLevel(SPEED_LEVELS.fast);
         this.skipScatterDelay?.();
         this.resolveMysterySpeedUp();
         this.skipScatterDelay = null;
-        if (this.currentColumn)
+        if (this.currentColumn) {
             this.currentColumn.skipHidingMysteryFx = true;
+        }
     }
+    /**
+     * Function for clearing quick reels stop
+     * @public
+     */
     clearQuickReelsStop() {
         this.quickReelsStop = false;
         RainMan.componentRegistry.revertTemporarySpeedLevel();
     }
+    /**
+     * Function for blind spinning all columns
+     * @public
+     */
     blindSpin() {
         this.allColumns.forEach((column) => column.blindSpin());
     }
@@ -77,14 +105,15 @@ export class AbstractColumnsContainer extends Container {
     async configBlindSpin(finalSymbolReels, afterSpinResolver, indexesOfReelsToExtendSpinningTime) {
         // spin
         return new Promise(async (resolve) => {
-            const configuredBlindSpinsActions = this.prepareConfiguringReelsEnd(finalSymbolReels);
             let index = 0;
+            const configuredBlindSpinsActions = this.prepareConfiguringReelsEnd(finalSymbolReels);
             const frame = RainMan.componentRegistry.get(AbstractFrame.registryName);
             while (configuredBlindSpinsActions.length !== 0) {
                 if (this.quickReelsStop || RainMan.settingsStore.currentSpeed === SPEED_LEVELS.fast) {
                     await Promise.all(configuredBlindSpinsActions.map(async (action) => await action()));
                     configuredBlindSpinsActions.length = 0;
                     SoundManager.play(SoundTracks.allRollStops);
+                    this.clearQuickReelsStop();
                     break;
                 }
                 const configureSpinAction = configuredBlindSpinsActions.shift();
@@ -101,8 +130,9 @@ export class AbstractColumnsContainer extends Container {
                         }, RainMan.config.durationOfActions.scatterDelayerTime);
                         await this.currentColumn.changeVelocity(Speed.STOP, RainMan.config.durationOfActions.scatterSpinningTime, frame);
                     }
-                    if (!indexesOfReelsToExtendSpinningTime.includes(index))
+                    if (!indexesOfReelsToExtendSpinningTime.includes(index)) {
                         await configureSpinAction();
+                    }
                 }
                 index++;
                 this.currentColumn = null;
@@ -112,6 +142,14 @@ export class AbstractColumnsContainer extends Container {
             resolve();
         });
     }
+    /**
+     * Function for playing all streaks
+     * @param {StreakReelsIndexes[]} streaks - The streaks to play
+     * @param {number} amount - The amount to play
+     * @param {SymbolId[]} allSymbols - All symbols to consider
+     * @returns {Promise<void>} - A promise that resolves when all streaks are played
+     * @public
+     */
     async playAllStreaks(streaks, amount, allSymbols = []) {
         const columnsToPlay = [];
         streaks.forEach((streak) => {
@@ -131,9 +169,21 @@ export class AbstractColumnsContainer extends Container {
         this.playSoundDependingOnAmount(amount, allSymbols);
         await Promise.allSettled(promises);
     }
+    /**
+     * Function for resetting played sounds
+     * @public
+     * @returns {void}
+     */
     resetPlayedSounds() {
         this.playedSounds = [];
     }
+    /**
+     * Function for playing sound depending on the amount
+     * @public
+     * @param {number} amount - The amount to check
+     * @param {SymbolId[]} _allSymbols - All symbols to consider
+     * @returns {void}
+     */
     playSoundDependingOnAmount(amount, _allSymbols = []) {
         const bet = RainMan.settingsStore.bet;
         if (amount < WIN_MULTIPLIER_VALUES.LOW_WIN * bet) {
@@ -198,12 +248,23 @@ export class AbstractColumnsContainer extends Container {
         this.playStreakSound(streakSymbols);
         await Promise.allSettled(promises);
     }
+    /**
+     * Function for animating columns
+     * @public
+     * @param {number} delta - delta time for animation
+     * @returns {void}
+     */
     animate(delta) {
         const { lastTime } = Ticker.shared;
         for (const column of this.allColumns) {
             column.animate(delta, lastTime);
         }
     }
+    /**
+     * Function for stopping all playing symbols in columns
+     * @public
+     * @returns {void}
+     */
     stopPlayingSymbolsInColumns() {
         this.allColumns.forEach((column) => column.stopAllPlayingSymbols());
         if (this.currentPlayingSoundName) {
@@ -211,12 +272,31 @@ export class AbstractColumnsContainer extends Container {
             this.currentPlayingSoundName = null;
         }
     }
+    /**
+     * Function for stopping all transformations playing symbols in columns
+     * @public
+     * @returns {void}
+     */
     stopPlayingSymbolsTransformationInColumns() {
         this.allColumns.forEach((column) => column.stopTransformationPlayingSymbols());
     }
+    /**
+     * Function for setting interactivity for all symbols in columns
+     * @param {boolean} flag - flag for setting interactivity
+     * @public
+     * @returns {void}
+     */
     setInteractivityForSymbols(flag) {
         this.allColumns.forEach((column) => column.setAllSymbolsInteractiveFlag(flag));
     }
+    /**
+     * Function for handling multiple symbol transformations
+     * @param {DropTransformationDetails} transformations - array of transformations to apply
+     * @param {boolean} skipAnimations - flag for skipping animations
+     * @param {boolean} isStandalone - flag for standalone mode
+     * @param {boolean} allowSoundInSymbolsColumn - flag for allowing sound in symbols column
+     * @returns {Promise<void>}
+     */
     async handleDestroyTransformations(transformations, skipAnimations = false, isStandalone = false, allowSoundInSymbolsColumn = true) {
         if (transformations.length === 0) {
             return Promise.resolve();
@@ -224,6 +304,11 @@ export class AbstractColumnsContainer extends Container {
         const column = this.getColumnAtPosition(transformations[0].coordinates.x);
         await column.handleMultipleSymbolDropping(transformations, skipAnimations, isStandalone, allowSoundInSymbolsColumn);
     }
+    /**
+     * Function for creating mask for columns container
+     * @protected
+     * @returns {Graphics} mask for columns container
+     */
     createMask() {
         const mask = new Graphics();
         mask.beginFill(0xaaaaaa, 1);
@@ -233,9 +318,18 @@ export class AbstractColumnsContainer extends Container {
         mask.endFill();
         return mask;
     }
+    /**
+     * Function for fixing symbols columns position
+     * @public
+     */
     fixSymbolsColumnsPosition() {
         this.allColumns.forEach((column) => column.fixStationaryPositions());
     }
+    /**
+     * Function for preparing configuring reels end
+     * @param {SymbolReels} finalSymbolReels - final symbol reels
+     * @returns {PlayableAction[]} - array of playable actions
+     */
     prepareConfiguringReelsEnd(finalSymbolReels) {
         return this.allColumns.map((column, index) => async () => {
             column.configBlindSpin(finalSymbolReels[index]);

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

@@ -32,19 +32,81 @@ export declare class MessageBox extends Container {
     private incentiveMessageShown;
     private winLineIndicatorShown;
     constructor();
+    /**
+     * Updates the incentive text displayed in the message box.
+     * @param {string} newText - The new text to display.
+     */
     updateIncentiveText(newText: string): void;
+    /**
+     * Function for hiding current win text
+     */
     hideCurrentWinText(): void;
+    /**
+     * Function fro hiding possible win text
+     */
     hidePossibleWinText(): void;
+    /**
+     * Function for hiding free spin text
+     */
     hideFreeSpinText(): void;
+    /**
+     * Function for hiding auto spin text
+     */
     hideAutoSpinText(): void;
+    /**
+     * Function for hiding incentive text
+     */
     hideIncentiveText(): void;
+    /**
+     * Function for hiding win line indicator
+     */
     hideWinLineIndicator(): void;
+    /**
+     * Function for resizing message box
+     * It sets the scale of the message box to the global minimum ratio.
+     * If the device orientation is mobile and the win line indicator is shown, it repositions
+     * the win line indicator to ensure it is displayed correctly.
+     * @memberof MessageBox
+     */
     resize(): void;
+    /**
+     * Getter for the height of the win line animation.
+     * If the win line indicator is not defined, it returns 0.
+     * @returns {number} The height of the win line animation.
+     */
+    get winLineAnimationHeight(): number;
+    /**
+     * Displays the current win text in the message box.
+     * @returns {void}
+     */
     showCurrentWinText(): void;
     showPossibleWinText(): void;
+    /**
+     * Displays the auto spin text in the message box.
+     * It checks if auto spins are enabled and if the text is already shown.
+     * @returns {void}
+     */
     showAutoSpinText(): void;
+    /**
+     * Displays the free spin text in the message box.
+     * It checks if free spins are enabled and if the text is already shown.
+     * If free spin text is disabled in the configuration, it does nothing.
+     * @returns {void}
+     */
     showFreeSpinText(): void;
     showIncentiveText(): void;
+    /**
+     * Function to center a text component on the X-axis of the message box.
+     * @param {Container | undefined} component container component to center
+     * @returns {void}
+     */
     private centerTextOnX;
+    /**
+     * Displays the win line indicator in the message box.
+     * @param {string} message The message to display.
+     * @param {(symbolId: SymbolId, suffix?: string) => string} getImageForSymbolId Function to get the image for a symbol ID.
+     * @param {SymbolId[]} symbolIds The symbol IDs to display.
+     * @param {Partial<ITextStyle>} winLineTextStyleOverrides Overrides for the text style.
+     */
     showWinLineIndicator(message: string, getImageForSymbolId: (symbolId: SymbolId, suffix?: string) => string, symbolIds?: SymbolId[], winLineTextStyleOverrides?: Partial<ITextStyle>): void;
 }