pixi-rainman-game-engine 0.2.24 → 0.2.26

package/dist/components/AbstractMainContainer/AbstractMainContainer.js

@@ -22,7 +22,6 @@ import { MessageBox } from "../messageBox";
  * - {@link overlay} - overlay, used when modal is shown
  * - {@link gambleGame} - gamble game
  * @abstract
- * @class AbstractMainContainer
  * @augments {Container}
  */
 export class AbstractMainContainer extends Container {
@@ -41,8 +40,11 @@ export class AbstractMainContainer extends Container {
     portraitPlayButtons = null;
     landscapePlayButtons = null;
     bottomPanel = null;
-    gambleGame = null;
     gambleGameSpineName = null;
+    gambleGame = null;
+    rouletteWinContainer = null;
+    mysteryBonusContainer = null;
+    resolveMysteryBonusContainer = undefined;
     _freeSpinPlate = null;
     _freeSpinSummary = null;
     _bigWinInvokedAt = null;
@@ -61,8 +63,19 @@ export class AbstractMainContainer extends Container {
                 SoundManager.setPlayStatus(SoundTracks.music, RainMan.settingsStore.shouldPlayAmbientMusic);
             }
         }
+        RainMan.settingsStore.setHandleInvokeFreeSpinPlate(this.invokeFreeSpinPlate.bind(this));
         RainMan.app.renderer.on("resize", () => this.resize());
     }
+    /**
+     * Function for invoking mystery win plate
+     * @param {string} _animationName - The name of the animation to play.
+     * @param {string} _popupAnimation - The name of the popup animation to play.
+     * @param {WinTypeId} _winType - The type of win to display.
+     * @param {number} _amount - The amount of the win.
+     * @param {boolean} _isAdditionalFreeSpins - Flag indicating if this is for additional free spins.
+     * @returns {Promise<void>} - A promise that resolves when the animation is complete.
+     */
+    async invokeMysteryWinPlate(_animationName, _popupAnimation, _winType, _amount, _isAdditionalFreeSpins) { }
     /**
      * This function initializes the spines that should be paused when the battery saver is on
      * @param {typeof RainMan.settingsStore.containersWithSpines} containersWithSpines - array of containers with spines
@@ -71,9 +84,17 @@ export class AbstractMainContainer extends Container {
         RainMan.settingsStore.containersWithSpines.push(...containersWithSpines);
         RainMan.settingsStore.refreshBatterySaver();
     }
+    /**
+     * Function for getting free spin plate
+     * @returns {Nullable<AbstractFreeSpinContainer>} The container for the free spin plate, or null if not set.
+     */
     get freeSpinPlate() {
         return this._freeSpinPlate;
     }
+    /**
+     * Function for getting free spin summary
+     * @returns {Nullable<AbstractFreeSpinContainer>} The container for the free spin summary, or null if not set.
+     */
     get freeSpinSummary() {
         return this._freeSpinSummary;
     }
@@ -108,6 +129,14 @@ export class AbstractMainContainer extends Container {
     createMysteryWinContainer() {
         return null;
     }
+    /**
+     * Function for creating mystery bonus container
+     * @param {string} _animationName - animation name for the mystery bonus container
+     * @returns {Nullable<UpdatableSpineContainer>} The container for the mystery bonus animation, or null.
+     */
+    createMysteryBonusContainer(_animationName) {
+        return null;
+    }
     /**
      * Function for specifying the container for the free spin summary
      * This needs to be implemented in each game
@@ -119,6 +148,50 @@ export class AbstractMainContainer extends Container {
      * This needs to be implemented in each game
      */
     changeContainerForBaseGame() { }
+    /**
+     * Function for creating roulette win container
+     * @param {string} _animationName animation name for the roulette container
+     * @returns {Nullable<UpdatableSpineContainer>} The container for the roulette win animation, or null.
+     */
+    createRouletteContainer(_animationName) {
+        return null;
+    }
+    /**
+     * Function for destroying the roulette win container
+     * @param {WinTypeId} winType win type of jackpot roulette win
+     * @returns {void}
+     */
+    destroyRouletteWin(winType) {
+        if (!this.rouletteWinContainer)
+            return;
+        this.removeChild(this.rouletteWinContainer);
+        this.rouletteWinContainer.destroyAnimations();
+        this.rouletteWinContainer.destroy({ children: true });
+        this.rouletteWinContainer = null;
+        this._frame.playJackpotAnimation(winType);
+        this.hideOverlay();
+    }
+    /**
+     * Function for invoking mystery bonus container
+     * @param {string} animationName animation name for the mystery bonus container
+     * @returns {Promise<void>}
+     */
+    async invokeMysteryBonusContainer(animationName) {
+        return new Promise((resolve) => {
+            this.resolveMysteryBonusContainer = resolve;
+            this.mysteryBonusContainer = this.createMysteryBonusContainer(animationName);
+            if (!this.mysteryBonusContainer)
+                return;
+            this.mysteryBonusContainer.text.visible = false;
+            this.mysteryBonusContainer.x = RainMan.app.screen.width / 2;
+            this.mysteryBonusContainer.y = RainMan.app.screen.height / 2;
+            this.mysteryBonusContainer.resize();
+            this.addChild(this.mysteryBonusContainer);
+            this.mysteryBonusContainer.spine.state.addListener({
+                complete: () => resolve()
+            });
+        });
+    }
     /**
      * Function for invoking free spin plate
      * If game draw an additional free spin, you can set isAdditionalFreeSpin to true
@@ -178,6 +251,10 @@ export class AbstractMainContainer extends Container {
         this.hideOverlay();
         refreshButton.flipDisabledFlag(false);
     }
+    /**
+     * Function for hiding free spin summary
+     * @returns {void}
+     */
     hideFreeSpinSummary() {
         if (!this.freeSpinSummary)
             return;
@@ -186,6 +263,11 @@ export class AbstractMainContainer extends Container {
         this._freeSpinSummary = null;
         this.hideOverlay();
     }
+    /**
+     * Function for showing the overlay
+     * This function creates a semi-transparent overlay that covers the entire screen.
+     * It is used to block interactions with the game while a modal is displayed.
+     */
     showOverlay() {
         const { width, height } = RainMan.app.screen;
         this.overlay = new Graphics();
@@ -197,29 +279,53 @@ export class AbstractMainContainer extends Container {
         this.overlay.interactive = true;
         this.addChild(this.overlay);
     }
+    /**
+     * Function for hiding the overlay
+     * This function removes the overlay from the main container and sets it to null.
+     */
     hideOverlay() {
-        if (this.overlay)
+        if (this.overlay) {
             this.removeChild(this.overlay);
+        }
         this.overlay = null;
     }
+    /**
+     * Function for getting the time since the big win was invoked.
+     * @returns {number} The time in milliseconds since the big win was invoked, or 0 if it has not been invoked.
+     */
     get bigWinVisibleFor() {
         return this._bigWinInvokedAt == null ? 0 : performance.now() - this._bigWinInvokedAt;
     }
+    /**
+     * Function for getting the free spin button.
+     * @returns {typeof this.freeSpinButton} The free spin button instance.
+     */
     getFreeSpinButton() {
         return this.freeSpinButton;
     }
+    /**
+     * Function for getting the time since the mystery win was invoked.
+     * @returns {number} The time in milliseconds since the mystery win was invoked, or 0 if it has not been invoked.
+     */
     get mysteryWinVisibleFor() {
         return this._mysteryWinInvokedAt == null ? 0 : performance.now() - this._mysteryWinInvokedAt;
     }
+    /**
+     * Function for getting the time since the bonus win was invoked.
+     * @returns {number} The time in milliseconds since the bonus win was invoked, or 0 if it has not been invoked.
+     */
     get bonusWinVisibleFor() {
         return this._bonusWinInvokedAt == null ? 0 : performance.now() - this._bonusWinInvokedAt;
     }
+    /**
+     * Function for getting the time since the super bonus win was invoked.
+     * @returns {number} The time in milliseconds since the super bonus win was invoked, or 0 if it has not been invoked.
+     */
     get superBonusWinVisibleFor() {
         return this._superBonusWinInvokedAt == null ? 0 : performance.now() - this._superBonusWinInvokedAt;
     }
     /**
      * Function for invoking big win animation, using `this.createBigWinContainer()` abstract function.
-     *
      */
     invokeBigWin() {
         if (this.bigWinContainer !== null) {
@@ -237,7 +343,6 @@ export class AbstractMainContainer extends Container {
     }
     /**
      * Function for invoking big win animation, using `this.createSuperBonusWinContainer()` abstract function.
-     *
      */
     invokeSuperBonusWin() {
         if (this.superBonusWinContainer !== null) {
@@ -269,6 +374,9 @@ export class AbstractMainContainer extends Container {
         this.addChild(this.bonusWinContainer);
         this._bonusWinInvokedAt = performance.now();
     }
+    /**
+     * Function for invoking mystery win animation, using `this.createMysteryWinContainer()` abstract function.
+     */
     invokeMysteryWin() {
         if (this.mysteryWinContainer !== null) {
             throw new Error("😡 Mystery Win is already declared");
@@ -284,6 +392,11 @@ export class AbstractMainContainer extends Container {
         this.addChild(this.mysteryWinContainer);
         this._mysteryWinInvokedAt = performance.now();
     }
+    /**
+     * Function for destroying the big win container
+     * This function removes the big win container from the main container,
+     * destroys its animations, and sets it to null.
+     */
     destroyBigWin() {
         if (this.bigWinContainer === null)
             return;
@@ -293,6 +406,9 @@ export class AbstractMainContainer extends Container {
         this.bigWinContainer = null;
         this._bigWinInvokedAt = null;
     }
+    /**
+     * Function for destroying the mystery win container
+     */
     destroyMysteryWin() {
         if (this.mysteryWinContainer === null)
             return;
@@ -302,6 +418,9 @@ export class AbstractMainContainer extends Container {
         this.mysteryWinContainer = null;
         this._mysteryWinInvokedAt = null;
     }
+    /**
+     * Function for destroying the bonus win container
+     */
     destroyBonusWin() {
         if (this.bonusWinContainer === null)
             return;
@@ -311,6 +430,9 @@ export class AbstractMainContainer extends Container {
         this.bonusWinContainer = null;
         this._bonusWinInvokedAt = null;
     }
+    /**
+     * Function for destroying the super bonus win container
+     */
     destroySuperBonusWin() {
         if (this.superBonusWinContainer === null)
             return;
@@ -320,6 +442,18 @@ export class AbstractMainContainer extends Container {
         this.superBonusWinContainer = null;
         this._superBonusWinInvokedAt = null;
     }
+    destroyMysteryBonus() {
+        if (!this.mysteryBonusContainer)
+            return;
+        this.removeChild(this.mysteryBonusContainer);
+        this.mysteryBonusContainer.destroyAnimations();
+        this.mysteryBonusContainer.destroy({ children: true });
+        this.mysteryBonusContainer = null;
+    }
+    /**
+     * Function for invoking gamble game
+     * @returns {Promise<void>} - A promise that resolves when the gamble game is finished.
+     */
     async invokeGambleGame() {
         if (!this.gambleGameSpineName)
             return;
@@ -338,12 +472,22 @@ export class AbstractMainContainer extends Container {
         this._controller.balance = newBalance;
         this.hideOverlay();
     }
+    /**
+     * Function for creating the under frame panel.
+     * This panel is used in mobile portrait mode to display additional information.
+     * @returns {Graphics | Sprite} The under frame panel as a Graphics or Sprite object.
+     */
     createUnderFramePanel() {
         const underFramePanel = new Graphics();
         underFramePanel.beginFill(0x0, 0.75);
         underFramePanel.drawRect(0, 0, 800, 100);
         return underFramePanel;
     }
+    /**
+     * Function for enabling mobile portrait mode.
+     * It creates the under frame panel, portrait play buttons, and adds them to the container.
+     * @returns {void}
+     */
     enableForMobile() {
         if (this.logo)
             this.logo.renderable = true;
@@ -356,14 +500,74 @@ export class AbstractMainContainer extends Container {
         this.portraitPlayButtons.parentLayer = UXLayer;
         this.addChild(this.portraitPlayButtons);
     }
+    /**
+     * Function for enabling landscape mode.
+     * @returns {void}
+     */
     enableForLandscape() {
         this.landscapePlayButtons = this.createLandscapePlayButtons();
         this.landscapePlayButtons.parentLayer = UXLayer;
         this.addChild(this.landscapePlayButtons);
     }
+    /**
+     * Function for positioning the round win container.
+     * @returns {void}
+     */
+    positionRoundWinContainer() {
+        if (!this.rouletteWinContainer)
+            return;
+        const { width, height } = RainMan.app.screen;
+        this.rouletteWinContainer.text.visible = false;
+        this.rouletteWinContainer.x = width / 2;
+        this.rouletteWinContainer.y = height / 2;
+        this.rouletteWinContainer.resize();
+        this.addChild(this.rouletteWinContainer);
+    }
+    /**
+     * Function for invoking the roulette win plate.
+     * @param {string} winAnimationName The name of the win animation.
+     * @param {WinTypeId} winType The type of win.
+     * @param {string} startAnimationName The name of the start animation defaulting to "start".
+     */
+    async invokeRouletteWinPlate(winAnimationName, winType, startAnimationName = "start") {
+        this.rouletteWinContainer = this.createRouletteContainer(startAnimationName);
+        this.positionRoundWinContainer();
+        SoundManager.play(SoundTracks.jackpotWin);
+        await new Promise((resolve) => {
+            let idleCount = 0;
+            if (!this.rouletteWinContainer) {
+                resolve();
+                return;
+            }
+            this.addChild(this.rouletteWinContainer);
+            this.rouletteWinContainer.spine.state.setAnimation(0, startAnimationName, false);
+            this.rouletteWinContainer.spine.state.addListener({
+                complete: () => {
+                    this.rouletteWinContainer?.spine.state.setAnimation(0, "idle", true);
+                    this.rouletteWinContainer?.spine.state.setAnimation(0, winAnimationName, false);
+                    this.rouletteWinContainer?.spine.state.addListener({
+                        complete: () => {
+                            idleCount++;
+                            if (idleCount > 1) {
+                                this.rouletteWinContainer?.spine.state.addListener({
+                                    complete: () => resolve()
+                                });
+                            }
+                        }
+                    });
+                }
+            });
+        });
+        this.destroyRouletteWin(winType);
+        this._frame.resetBonusIndicators("roulette");
+    }
+    /**
+     * Function for disabling components for mobile portrait orientation.
+     */
     disableForMobile() {
-        if (this.logo)
+        if (this.logo) {
             this.logo.renderable = false;
+        }
         if (this.underFramePanel !== null) {
             this.removeChild(this.underFramePanel);
             this.underFramePanel = null;
@@ -374,6 +578,9 @@ export class AbstractMainContainer extends Container {
             this.portraitPlayButtons = null;
         }
     }
+    /**
+     * Function for disabling components for landscape orientation.
+     */
     disableForLandscape() {
         if (this.landscapePlayButtons !== null) {
             this.removeChild(this.landscapePlayButtons);
@@ -381,6 +588,11 @@ export class AbstractMainContainer extends Container {
             this.landscapePlayButtons = null;
         }
     }
+    /**
+     * Function for resizing the main container and its components.
+     * This function removes the current frame and any win containers,
+     * resizes the message box, background, animated front,
+     */
     resize() {
         this.removeChild(this._frame);
         if (this.bigWinContainer) {
@@ -395,11 +607,15 @@ export class AbstractMainContainer extends Container {
         if (this.bonusWinContainer) {
             this.removeChild(this.bonusWinContainer);
         }
+        if (this.mysteryBonusContainer) {
+            this.removeChild(this.mysteryBonusContainer);
+        }
         this.messageBox.resize();
         this.background.resize();
         this.animatedFront?.resize();
-        if (this.freeSpinButton)
+        if (this.freeSpinButton) {
             this.freeSpinButton.resize();
+        }
         this.addChild(this._frame);
         this._frame.resize();
         this.initComponentsForScreenRatio();
@@ -410,30 +626,75 @@ export class AbstractMainContainer extends Container {
             RainMan.componentRegistry.get(BUTTONS.neg).flipDisabledFlag(true);
         }
     }
+    /**
+     * Function for creating the left buttons
+     * @returns {LeftButtons} - Returns a new instance of LeftButtons.
+     */
     createLeftButtons() {
         return new LeftButtons();
     }
+    /**
+     * Function for creating the right buttons
+     * @returns {RightButtons} - Returns a new instance of RightButtons.
+     */
     createRightButtons() {
         return new RightButtons();
     }
+    /**
+     * Function for creating the left buttons for mobile portrait orientation
+     * @returns {LeftButtonsMobile} - Returns a new instance of LeftButtonsMobile for mobile portrait orientation.
+     */
     createLeftButtonsMobile() {
         return new LeftButtonsMobile();
     }
+    /**
+     * Function for creating the right buttons for mobile portrait orientation
+     * @returns {RightButtonsMobile} - Returns a new instance of RightButtonsMobile for mobile portrait orientation.
+     */
     createRightButtonsMobile() {
         return new RightButtonsMobile();
     }
+    /**
+     * Function for creating the left buttons for landscape orientation
+     * @protected
+     * @returns {LeftButtonsLandscape} - Returns a new instance of LeftButtonsLandscape for landscape orientation.
+     */
     createLeftButtonsLandscape() {
         return new LeftButtonsLandscape();
     }
+    /**
+     * Function for creating the right buttons for landscape orientation
+     * @protected
+     * @returns {RightButtonsLandscape} - Returns a new instance of RightButtonsLandscape for landscape orientation.
+     */
     createRightButtonsLandscape() {
         return new RightButtonsLandscape();
     }
+    /**
+     * Function for creating the portrait play buttons
+     * @protected
+     * @returns {MiddleButtons} - Returns a new instance of MiddleButtons for portrait orientation.
+     */
     createPortraitPlayButtons() {
         return new MiddleButtons();
     }
+    /**
+     * Function for creating the landscape play buttons
+     * @protected
+     * @returns {MiddleButtons} - Returns a new instance of MiddleButtons for landscape orientation.
+     */
     createLandscapePlayButtons() {
         return new MiddleButtons(true);
     }
+    /**
+     * This method initializes the components for the current screen ratio.
+     * It checks the current device orientation and creates the appropriate left and right buttons.
+     * It also removes the previous left and right buttons from the container.
+     * It resizes the right buttons if the current orientation is "mobile-portrait".
+     * @protected
+     * @returns {void}
+     * @memberof AbstractMainContainer
+     */
     initComponentsForScreenRatio() {
         const currentOrientation = getDeviceOrientation();
         if (currentOrientation === "mobile-portrait") {
@@ -471,6 +732,13 @@ export class AbstractMainContainer extends Container {
         this.addChild(this.rightButtons);
         this._controller?.reinitializeAllButtons();
     }
+    /**
+     * This method is used to resize all components that depend on the screen size.
+     * It resizes the frame, logo, left and right buttons, message box, play buttons,
+     * under frame panel, overlay, big win container, super bonus win container, bonus win container,
+     * mystery win container, gamble game, bottom panel, free spin plate, and
+     * free spin summary.
+     */
     resizeDependentComponents() {
         const resizingHelper = globalMinRatio();
         this._frame.resize();
@@ -509,6 +777,11 @@ export class AbstractMainContainer extends Container {
             this.addChild(this.mysteryWinContainer);
             this.mysteryWinContainer.resize();
         }
+        if (this.mysteryBonusContainer) {
+            this.removeChild(this.mysteryBonusContainer);
+            this.mysteryBonusContainer.resize();
+            this.addChild(this.mysteryBonusContainer);
+        }
         if (this.gambleGame) {
             this.gambleGame.resize();
         }
@@ -528,6 +801,10 @@ export class AbstractMainContainer extends Container {
         }
         RainMan.settingsStore.popupPaytableRepositionCallback?.();
     }
+    /**
+     * This method is used to refresh the layers in the main container.
+     * It removes the existing layers and adds them back in the correct order.
+     */
     refreshLayers() {
         this.removeChild(BackgroundLayer);
         this.removeChild(FrameLayer);

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

@@ -15,5 +15,5 @@ export const ButtonStates = {
     CLICKED: "CLICKED",
     ACTIVE: "ACTIVE",
     ACTIVE_OVER: "ACTIVE_OVER",
-    ACTIVE_CLICKED: "ACTIVE_CLICKED",
+    ACTIVE_CLICKED: "ACTIVE_CLICKED"
 };

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

@@ -32,4 +32,5 @@ export declare const COMPONENTS: {
     readonly bonusWin: "bonusWinText";
     readonly superBonusWin: "superBonusWinText";
     readonly autoSpinConfirm: "autoSpin-confirm";
+    readonly mysteryWheelWin: "mysteryWheelWin";
 };

package/dist/components/buttons/registrynames.js

@@ -9,7 +9,7 @@ export const BUTTONS = {
     info: "infoButton",
     more: "moreButton",
     gamble: "gambleButton",
-    volume: "volumeButton",
+    volume: "volumeButton"
 };
 /**
  *  Button groups in Rainman Registry
@@ -18,7 +18,7 @@ export const BUTTONS = {
 export const REGISTRY = {
     leftButtons: "leftButtons",
     middleButtons: "middleButtons",
-    rightButtons: "rightButtons",
+    rightButtons: "rightButtons"
 };
 /**
  *  Components names in Rainman Registry
@@ -32,4 +32,5 @@ export const COMPONENTS = {
     bonusWin: "bonusWinText",
     superBonusWin: "superBonusWinText",
     autoSpinConfirm: "autoSpin-confirm",
+    mysteryWheelWin: "mysteryWheelWin"
 };

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

@@ -1,9 +1,10 @@
 import { Spine } from "pixi-spine";
-import { SpeedAdapterInterface, SpeedLevel, SpeedLevelDirectory } from "../../application";
+import { SpeedAdapterInterface, SpeedLevel, SpeedLevelDirectory, WinTypeId } from "../../application";
 import { Nullable } from "../../utils";
 import { ResumableContainer } from "../common";
 import { AbstractColumnsContainer } from "./AbstractColumnsContainer";
 import { AbstractInnerFrame } from "./AbstractInnerFrame";
+import { BonusIndicatorTypes } from "./constants";
 import { MysteryFxCoordinates } from "./types";
 import { WinLineAnimation } from "./WinLineAnimation";
 /**
@@ -41,9 +42,11 @@ export declare abstract class AbstractFrame extends ResumableContainer implement
      */
     invokeMysteryFx(x: number, y: number): void;
     protected repositionMysteryFx(_x: number, _y: number): void;
+    playJackpotAnimation(_type: WinTypeId): void;
     hideMysteryFx(): void;
     private resetMysteryFxCoordinates;
     destroyMysteryFx(): void;
+    resetBonusIndicators(_type: BonusIndicatorTypes): void;
     /**
      * Create win line animation, individual for each game, based on {@link WinLineAnimation}
      */

package/dist/components/frame/AbstractFrame.js

@@ -60,6 +60,7 @@ export class AbstractFrame extends ResumableContainer {
         this.addChild(this.mysteryFxHighlight);
     }
     repositionMysteryFx(_x, _y) { }
+    playJackpotAnimation(_type) { }
     hideMysteryFx() {
         if (!this.mysteryFxConfig)
             return;
@@ -86,6 +87,7 @@ export class AbstractFrame extends ResumableContainer {
             this.mysteryFxHighlight = null;
         }
     }
+    resetBonusIndicators(_type) { }
     /**
      * Create win line animation, individual for each game, based on {@link WinLineAnimation}
      */

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

@@ -9,8 +9,16 @@ export declare const WIN_MULTIPLIER_VALUES: {
     readonly HIGH_WIN_MAX: 15;
     readonly VERY_HIGH_WIN: 15.1;
 };
+export declare const BONUS_INDICATORS: {
+    readonly joker: "joker";
+    readonly freeSpins: "freeSpins";
+    readonly mystery: "mystery";
+    readonly roulette: "roulette";
+    readonly multi: "multi";
+};
 /**
  * Type for the win multiplier values.
  * @typedef {WinMultiplierValues}
  */
 export type WinMultiplierValues = (typeof WIN_MULTIPLIER_VALUES)[keyof typeof WIN_MULTIPLIER_VALUES];
+export type BonusIndicatorTypes = (typeof BONUS_INDICATORS)[keyof typeof BONUS_INDICATORS];

package/dist/components/frame/constants.js

@@ -7,5 +7,12 @@ export const WIN_MULTIPLIER_VALUES = {
     MEDIUM_WIN_MAX: 5,
     HIGH_WIN_MIN: 5.1,
     HIGH_WIN_MAX: 15,
-    VERY_HIGH_WIN: 15.1,
+    VERY_HIGH_WIN: 15.1
+};
+export const BONUS_INDICATORS = {
+    joker: "joker",
+    freeSpins: "freeSpins",
+    mystery: "mystery",
+    roulette: "roulette",
+    multi: "multi"
 };

package/dist/components/symbols/AbstractSymbolsColumn.d.ts

@@ -1,7 +1,7 @@
 import { Container } from "pixi.js";
 import { SpeedAdapterInterface, SpeedLevel, SymbolId } from "../../application";
 import { DropTransformationDetails, SymbolReel } from "../../connectivity";
-import { Nullable, VoidPromiseResolver } from "../../utils";
+import { Nullable, PromiseResolverType } from "../../utils";
 import { AbstractColumnsContainer, AbstractFrame } from "../frame";
 import { AbstractSymbolBase } from "./AbstractSymbolBase";
 import { AnimationTimeSettings, Phase } from "./types";
@@ -28,7 +28,7 @@ export declare abstract class AbstractSymbolsColumn extends Container implements
     private lastEnding;
     private tween;
     private wiggleTween;
-    resolveMysterySpeedUp: Nullable<VoidPromiseResolver>;
+    resolveMysterySpeedUp: Nullable<PromiseResolverType<void>>;
     private resolver;
     private shouldMoveToTop;
     private droppingTweens;