pixi-rainman-game-engine 0.2.24 → 0.2.26

package/dist/ComponentRegistry/ComponentRegistry.js

@@ -9,10 +9,9 @@ import { openFullscreen } from "../utils";
 export class ComponentRegistry {
     registry = new Map();
     speedAdaptableComponents = new Set();
-    incentiveJobsManager;
+    incentiveJobsManager = new TimedIncentiveController();
     speedLevelHandler = SpeedLevelHandler.initWithDefaultSpeedLevels();
     constructor(app) {
-        this.incentiveJobsManager = new TimedIncentiveController();
         app.renderer.addListener("pointerdown", () => {
             this.setUserActivityTime();
             openFullscreen();

package/dist/ComponentRegistry/types.js

@@ -1 +1 @@
-import { AbstractColumnsContainer, AbstractFrame, AbstractInnerFrame, AutoplayButton, Background, BUTTONS, COMPONENTS, FreeSpinButton, InfoButton, MessageBox, MoreButton, NegButton, PlusButton, RefreshButton, SpeedControlButton, VolumeButton, } from "../components";
+import { AbstractColumnsContainer, AbstractFrame, AbstractInnerFrame, AutoplayButton, Background, BUTTONS, COMPONENTS, FreeSpinButton, InfoButton, MessageBox, MoreButton, NegButton, PlusButton, RefreshButton, SpeedControlButton, VolumeButton } from "../components";

package/dist/Rainman/Rainman.js

@@ -28,8 +28,8 @@ export class RainMan {
         RainMan.settingsStore = settingStore;
         RainMan.componentRegistry = new ComponentRegistry(app);
         RainMan.globals = {
-            shouldShowModals: false,
-            currency: Currencies["USD"]
+            currency: Currencies["USD"],
+            shouldShowModals: false
         };
     }
 }

package/dist/Rainman/appConfig.js

@@ -47,10 +47,10 @@ export const defaultAppConfig = {
         superBonusWinMinimumTime: 2000,
         superBonusWinPhaseTimeout: 2600,
         speedPopupVisibleTime: 2000,
-        minAnimationTime: 1000,
+        minAnimationTime: 1000
     },
     constants: {
         bigWinMultiplier: 30,
-        bigWinTextOffset: 0,
-    },
+        bigWinTextOffset: 0
+    }
 };

package/dist/Rainman/types.d.ts

@@ -68,8 +68,10 @@ export type AppConfig = RequiredAppConfig & DeepPartial<OptionalAppConfig>;
 export interface Globals {
     currency: Currency;
     shouldShowModals: boolean;
+    getWebSocketConnection?: () => WebSocket;
     actionsAfterClosureWebSocket?: () => void;
     disableSpeedPopup?: (value: boolean) => void;
     handleDisablingButtons?: (value?: boolean) => void;
     throttledSpin?: () => void;
+    updateFreeSpinShown?: (value: number) => void;
 }

package/dist/SettingsUI/components/AutoplaySettings/index.jsx

@@ -25,7 +25,7 @@ export const AutoplaySettings = observer(() => {
         }
         return {
             bottomLimitIndex,
-            topLimitIndex,
+            topLimitIndex
         };
     };
     const updateLimitsBounds = (newLimit) => {
@@ -49,7 +49,7 @@ export const AutoplaySettings = observer(() => {
     useEffect(() => {
         updateLimitsBounds(initialAutoSpinCount);
     }, []);
-    const { singleWinExceeds, balancedIncreased, balancedDecreased, howManyAutoSpinsLeft, infinitySpinsEnabled, setSingleWinExceeds, setBalancedIncreased, setBalancedDecreased, setAutoSpinsCount, flipInfinitySpinsFlag, resetAutoplaySettings, } = settingStore;
+    const { singleWinExceeds, balancedIncreased, balancedDecreased, howManyAutoSpinsLeft, infinitySpinsEnabled, setSingleWinExceeds, setBalancedIncreased, setBalancedDecreased, setAutoSpinsCount, flipInfinitySpinsFlag, resetAutoplaySettings } = settingStore;
     return (<div className="autoplay-settings">
             <CloseModalButton layerId={UI_ITEMS.autoplay}/>
             <div className="autoplay-settings__title">

package/dist/SettingsUI/components/BuyFreeSpins/index.jsx

@@ -1,4 +1,5 @@
 import "./buyFreeSpin.css";
+import i18next from "i18next";
 import React, { useState } from "react";
 import { Currencies } from "ts-money";
 import { UI_ITEMS } from "../../../utils";
@@ -13,7 +14,7 @@ export const BuyFreeSpinModal = () => {
     return (<div className="buyFreeSpins__container">
             <CloseModalButton layerId={UI_ITEMS.freeSpin} afterClose={clearErrorMessage}/>
             <div className="buyFreeSpins__title-container">
-                <h1>Buy Free Spins</h1>
+                <h1>{i18next.t("buyFreeSpins")}</h1>
             </div>
             <div className="buyFreeSpins__buttons-container">
                 {freeSpinOptions.map((option) => (<OptionButton key={option.amount} setMessage={setErrorMessage} option={option} currency={currency}/>))}

package/dist/SettingsUI/components/OptionButton/index.jsx

@@ -20,10 +20,11 @@ export const OptionButton = ({ option, currency, setMessage }) => {
                 return;
             }
             settingStore.setIsFreeSpinBought(true, data);
-            settingStore.setRoundNumber(data.getRawData().round_number);
             settingStore.setFreeSpinNumberBought(option.amount);
-            RainMan.globals.throttledSpin?.();
             settingStore.handleModalInvocation?.(UI_ITEMS.freeSpin);
+            settingStore.handleInvokeFreeSpinPlate?.(option.amount, false);
+            RainMan.globals.updateFreeSpinShown?.(option.amount);
+            settingStore.setRoundNumber(roundNumber);
         }
         catch (err) {
             setMessage(err.message);

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

@@ -1,12 +1,16 @@
+import { autorun } from "mobx";
+import { useEffect, useState } from "react";
+import { RainMan } from "../../../Rainman";
 export const useBuyFreeSpinOptions = () => {
-    return [
-        {
-            amount: 10,
-            price: 35,
-        },
-        {
-            amount: 30,
-            price: 100,
-        },
-    ];
+    const [options, setOptions] = useState([]);
+    useEffect(() => {
+        const disposer = autorun(() => {
+            setOptions(Object.entries(RainMan.settingsStore.freeSpinBuyTable).map(([amount, multiplier]) => ({
+                amount: parseInt(amount, 10),
+                price: multiplier
+            })));
+        });
+        return () => disposer();
+    }, []);
+    return options;
 };

package/dist/application/ApiConfig/WinTypeId.d.ts

@@ -5,7 +5,7 @@
  * ```
  * interface WinTypeIds {
  *  streak: "streak";
- *   }
+ * }
  * ```
  * @interface WinTypeIds
  * @typedef {WinTypeIds}

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

@@ -57,7 +57,11 @@ export interface SoundTracks {
     specialSymbolOnReel: "specialSymbolOnReel";
     start: "start";
     symbol: "symbol";
+    rouletteStart: "rouletteStart";
+    rouletteLoop: "rouletteLoop";
+    rouletteStop: "rouletteStop";
     mysterySymbol: "mysterySymbol";
+    jackpotWin: "jackpotWin";
 }
 export type SoundTrack = SoundTracks[keyof SoundTracks];
 /**
@@ -82,6 +86,13 @@ export type SoundTrack = SoundTracks[keyof SoundTracks];
  * @property {string} specialSymbolOnReel - single reel stopping with special symbol like bonus or mystery
  * @property {string} start - on start spinning
  * @property {string} symbol - on symbol click and show payTable popup
+ * @property {string} lowWin - on low win - this sound is played when win of all streaks is less than x1 * bet
+ * @property {string} mediumWin - on medium win - this sound is played when win
+ * @property {string} highWin - on high win - this sound is played when win of all streaks is more than x5.1 * bet and less than x15 * bet
+ * @property {string} veryHighWin - on very high win - this sound is played when win of all streaks is more than x15.1 * bet
+ * @property {string} mysterySymbol - on mystery symbol appearance on the screen
+ * @property {string} jackpotWin - on start roulette
+ * @typedef {GameSoundAssets}
  */
 export type GameSoundAssets = Record<SoundTrack, string>;
 /**

package/dist/application/SoundManager/types.js

@@ -56,4 +56,8 @@ export const SoundTracks = {
     start: "start",
     symbol: "symbol",
     mysterySymbol: "mysterySymbol",
+    rouletteStart: "rouletteStart",
+    rouletteLoop: "rouletteLoop",
+    rouletteStop: "rouletteStop",
+    jackpotWin: "jackpotWin"
 };

package/dist/application/SpinLogic/util.js

@@ -14,7 +14,7 @@ const getWinFromRawResponse = (rawWin, winIndex) => {
         symbolId: rawWin.symbol_id,
         typeId: rawWin.type_id,
         amount: rawWin.amount,
-        winIndex,
+        winIndex
     };
 };
 /**
@@ -50,7 +50,7 @@ const joinTransformationsIntoDropTransformation = (destroyTransformations, symbo
             preparedDropTransformations.push({
                 type: transformationTypes.drop,
                 coordinates: destroyPlace,
-                symbolId: gameConfig.getSymbolId(symbolsToDrop[index]),
+                symbolId: gameConfig.getSymbolId(symbolsToDrop[index])
             });
         });
     });
@@ -91,7 +91,7 @@ export const getFreezeTransformationFromRawResponse = (transformations) => {
     return transformations.map((freezeTransformation) => {
         return {
             type: transformationTypes.freeze,
-            coordinates: freezeTransformation.coordinates,
+            coordinates: freezeTransformation.coordinates
         };
     });
 };
@@ -106,7 +106,7 @@ export const concatenateFreezeAndSpinTransformations = (freezeTransformations, o
     return {
         type: transformationTypes.spinAndFreeze,
         coordinates: allCoordinatesToFreeze,
-        symbolsOnReels: onStopBlindsConfiguration,
+        symbolsOnReels: onStopBlindsConfiguration
     };
 };
 /**
@@ -136,6 +136,6 @@ export const collectWinDetailsWithTransformation = (winsDetails, transformations
     const wins = winsDetails ? [getWinFromRawResponse(winsDetails, winIndex ?? "")] : [];
     return {
         wins,
-        transformations,
+        transformations
     };
 };

package/dist/application/setup.js

@@ -1,7 +1,7 @@
 import { createRoot } from "react-dom/client";
 import { RainMan } from "../Rainman";
 import { SettingsUI } from "../SettingsUI";
-import { changeResolution, disableMagnifyingGlassOnIOS, getDeviceOrientation, invokeStatsBoard, loadSoundsOnTabChange, resizeCanvas, setupFullscreenForIOS, } from "../utils";
+import { changeResolution, disableMagnifyingGlassOnIOS, getDeviceOrientation, invokeStatsBoard, loadSoundsOnTabChange, resizeCanvas, setupFullscreenForIOS } from "../utils";
 /**
  * This function is for setup the whole games
  *

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

@@ -1,8 +1,8 @@
 import { Container, Graphics, Sprite } from "pixi.js";
-import { ButtonsEventManager } from "../../application";
+import { ButtonsEventManager, WinTypeId } from "../../application";
 import { AbstractController } from "../../controllers";
 import { RainMan } from "../../Rainman";
-import { Nullable } from "../../utils";
+import { Nullable, PromiseResolverType } from "../../utils";
 import { BigWinContainer, MysteryWinContainer, UpdatableSpineContainer } from "../../winComponents";
 import { AbstractFreeSpinContainer } from "../AbstractFreeSpinContainer";
 import { LeftButtons, LeftButtonsLandscape, LeftButtonsMobile, MiddleButtons, RightButtons, RightButtonsLandscape, RightButtonsMobile } from "../buttons";
@@ -26,7 +26,6 @@ import { MessageBox } from "../messageBox";
  * - {@link overlay} - overlay, used when modal is shown
  * - {@link gambleGame} - gamble game
  * @abstract
- * @class AbstractMainContainer
  * @augments {Container}
  */
 export declare abstract class AbstractMainContainer extends Container {
@@ -48,8 +47,11 @@ export declare abstract class AbstractMainContainer extends Container {
     protected abstract leftButtons: ResponsiveContainer;
     protected abstract rightButtons: ResponsiveContainer;
     protected bottomPanel: Nullable<Sprite>;
-    private gambleGame;
     protected gambleGameSpineName: Nullable<string>;
+    private gambleGame;
+    protected rouletteWinContainer: Nullable<UpdatableSpineContainer>;
+    protected mysteryBonusContainer: Nullable<UpdatableSpineContainer>;
+    protected resolveMysteryBonusContainer?: PromiseResolverType;
     protected _freeSpinPlate: Nullable<AbstractFreeSpinContainer>;
     protected _freeSpinSummary: Nullable<AbstractFreeSpinContainer>;
     private _bigWinInvokedAt;
@@ -59,12 +61,30 @@ export declare abstract class AbstractMainContainer extends Container {
     protected abstract _frame: AbstractFrame;
     protected _controller: Nullable<AbstractController<unknown>>;
     protected constructor();
+    /**
+     * 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.
+     */
+    invokeMysteryWinPlate(_animationName: string, _popupAnimation: string, _winType: WinTypeId, _amount: number, _isAdditionalFreeSpins: boolean): Promise<void>;
     /**
      * 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
      */
     protected triggerStoreInitState(...containersWithSpines: typeof RainMan.settingsStore.containersWithSpines): void;
+    /**
+     * Function for getting free spin plate
+     * @returns {Nullable<AbstractFreeSpinContainer>} The container for the free spin plate, or null if not set.
+     */
     get freeSpinPlate(): Nullable<AbstractFreeSpinContainer>;
+    /**
+     * Function for getting free spin summary
+     * @returns {Nullable<AbstractFreeSpinContainer>} The container for the free spin summary, or null if not set.
+     */
     get freeSpinSummary(): Nullable<AbstractFreeSpinContainer>;
     /**
      * Function for creating free spin container
@@ -89,6 +109,12 @@ export declare abstract class AbstractMainContainer extends Container {
      * @returns {Nullable<UpdatableSpineContainer>} The container for the mystery win animation, or null.
      */
     protected createMysteryWinContainer(): Nullable<UpdatableSpineContainer> | MysteryWinContainer;
+    /**
+     * 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.
+     */
+    protected createMysteryBonusContainer(_animationName: string): Nullable<UpdatableSpineContainer>;
     /**
      * Function for specifying the container for the free spin summary
      * This needs to be implemented in each game
@@ -100,6 +126,24 @@ export declare abstract class AbstractMainContainer extends Container {
      * This needs to be implemented in each game
      */
     protected changeContainerForBaseGame(): void;
+    /**
+     * 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.
+     */
+    protected createRouletteContainer(_animationName: string): Nullable<UpdatableSpineContainer>;
+    /**
+     * Function for destroying the roulette win container
+     * @param {WinTypeId} winType win type of jackpot roulette win
+     * @returns {void}
+     */
+    private destroyRouletteWin;
+    /**
+     * Function for invoking mystery bonus container
+     * @param {string} animationName animation name for the mystery bonus container
+     * @returns {Promise<void>}
+     */
+    protected invokeMysteryBonusContainer(animationName: string): Promise<void>;
     /**
      * Function for invoking free spin plate
      * If game draw an additional free spin, you can set isAdditionalFreeSpin to true
@@ -122,51 +166,207 @@ export declare abstract class AbstractMainContainer extends Container {
      * @param {number} winAmount - win amount during free spins
      */
     invokeFreeSpinSummary(freeSpinCount: number, winAmount: number): Promise<void>;
+    /**
+     * Function for hiding free spin summary
+     * @returns {void}
+     */
     hideFreeSpinSummary(): void;
+    /**
+     * 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.
+     */
     protected showOverlay(): void;
+    /**
+     * Function for hiding the overlay
+     * This function removes the overlay from the main container and sets it to null.
+     */
     protected hideOverlay(): void;
+    /**
+     * 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(): number;
+    /**
+     * Function for getting the free spin button.
+     * @returns {typeof this.freeSpinButton} The free spin button instance.
+     */
     getFreeSpinButton(): typeof 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(): number;
+    /**
+     * 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(): number;
+    /**
+     * 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(): number;
+    /**
+     * Abstract function for creating the big win container.
+     * This function should be implemented in each game to create a specific big win container.
+     */
     protected abstract createBigWinContainer(): UpdatableSpineContainer | MysteryWinContainer;
     /**
      * Function for invoking big win animation, using `this.createBigWinContainer()` abstract function.
-     *
      */
     invokeBigWin(): void;
     /**
      * Function for invoking big win animation, using `this.createSuperBonusWinContainer()` abstract function.
-     *
      */
     invokeSuperBonusWin(): void;
     /**
      * Function for invoking big win animation, using `this.createBonusWinContainer()` abstract function.
      */
     invokeBonusWin(): void;
+    /**
+     * Function for invoking mystery win animation, using `this.createMysteryWinContainer()` abstract function.
+     */
     invokeMysteryWin(): void;
+    /**
+     * 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(): void;
+    /**
+     * Function for destroying the mystery win container
+     */
     destroyMysteryWin(): void;
+    /**
+     * Function for destroying the bonus win container
+     */
     destroyBonusWin(): void;
+    /**
+     * Function for destroying the super bonus win container
+     */
     destroySuperBonusWin(): void;
+    destroyMysteryBonus(): void;
+    /**
+     * Function for invoking gamble game
+     * @returns {Promise<void>} - A promise that resolves when the gamble game is finished.
+     */
     invokeGambleGame(): Promise<void>;
+    /**
+     * 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.
+     */
     protected createUnderFramePanel(): Graphics | Sprite;
+    /**
+     * Function for enabling mobile portrait mode.
+     * It creates the under frame panel, portrait play buttons, and adds them to the container.
+     * @returns {void}
+     */
     enableForMobile(): void;
+    /**
+     * Function for enabling landscape mode.
+     * @returns {void}
+     */
     enableForLandscape(): void;
+    /**
+     * Function for positioning the round win container.
+     * @returns {void}
+     */
+    private positionRoundWinContainer;
+    /**
+     * 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".
+     */
+    invokeRouletteWinPlate(winAnimationName: string, winType: WinTypeId, startAnimationName?: string): Promise<void>;
+    /**
+     * Function for disabling components for mobile portrait orientation.
+     */
     disableForMobile(): void;
+    /**
+     * Function for disabling components for landscape orientation.
+     */
     disableForLandscape(): void;
+    /**
+     * Function for repositioning components for screen ratio.
+     * This function should be implemented in each game.
+     * @protected
+     * @abstract
+     */
     protected abstract repositionComponentsForScreenRatio(): void;
+    /**
+     * 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(): void;
+    /**
+     * Function for creating the left buttons
+     * @returns {LeftButtons} - Returns a new instance of LeftButtons.
+     */
     protected createLeftButtons(): LeftButtons;
+    /**
+     * Function for creating the right buttons
+     * @returns {RightButtons} - Returns a new instance of RightButtons.
+     */
     protected createRightButtons(): RightButtons;
+    /**
+     * Function for creating the left buttons for mobile portrait orientation
+     * @returns {LeftButtonsMobile} - Returns a new instance of LeftButtonsMobile for mobile portrait orientation.
+     */
     protected createLeftButtonsMobile(): LeftButtonsMobile;
+    /**
+     * Function for creating the right buttons for mobile portrait orientation
+     * @returns {RightButtonsMobile} - Returns a new instance of RightButtonsMobile for mobile portrait orientation.
+     */
     protected createRightButtonsMobile(): RightButtonsMobile;
+    /**
+     * Function for creating the left buttons for landscape orientation
+     * @protected
+     * @returns {LeftButtonsLandscape} - Returns a new instance of LeftButtonsLandscape for landscape orientation.
+     */
     protected createLeftButtonsLandscape(): LeftButtonsLandscape;
+    /**
+     * Function for creating the right buttons for landscape orientation
+     * @protected
+     * @returns {RightButtonsLandscape} - Returns a new instance of RightButtonsLandscape for landscape orientation.
+     */
     protected createRightButtonsLandscape(): RightButtonsLandscape;
+    /**
+     * Function for creating the portrait play buttons
+     * @protected
+     * @returns {MiddleButtons} - Returns a new instance of MiddleButtons for portrait orientation.
+     */
     protected createPortraitPlayButtons(): MiddleButtons;
+    /**
+     * Function for creating the landscape play buttons
+     * @protected
+     * @returns {MiddleButtons} - Returns a new instance of MiddleButtons for landscape orientation.
+     */
     protected createLandscapePlayButtons(): MiddleButtons;
+    /**
+     * 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
+     */
     private initComponentsForScreenRatio;
+    /**
+     * 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.
+     */
     private resizeDependentComponents;
+    /**
+     * 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.
+     */
     protected refreshLayers(): void;
 }