pixi-rainman-game-engine 0.2.25 → 0.2.27

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/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

@@ -2,7 +2,7 @@ import { Container, Graphics, Sprite } from "pixi.js";
 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";
@@ -49,9 +49,9 @@ export declare abstract class AbstractMainContainer extends Container {
     protected bottomPanel: Nullable<Sprite>;
     protected gambleGameSpineName: Nullable<string>;
     private gambleGame;
-    private rouletteWinContainer;
-    private mysteryBonusContainer;
-    protected resolveMysteryBonusContainer?: (value?: void | PromiseLike<void>) => void;
+    protected rouletteWinContainer: Nullable<UpdatableSpineContainer>;
+    protected mysteryBonusContainer: Nullable<UpdatableSpineContainer>;
+    protected resolveMysteryBonusContainer?: PromiseResolverType;
     protected _freeSpinPlate: Nullable<AbstractFreeSpinContainer>;
     protected _freeSpinSummary: Nullable<AbstractFreeSpinContainer>;
     private _bigWinInvokedAt;

package/dist/components/AbstractMainContainer/AbstractMainContainer.js

@@ -44,7 +44,7 @@ export class AbstractMainContainer extends Container {
     gambleGame = null;
     rouletteWinContainer = null;
     mysteryBonusContainer = null;
-    resolveMysteryBonusContainer;
+    resolveMysteryBonusContainer = undefined;
     _freeSpinPlate = null;
     _freeSpinSummary = null;
     _bigWinInvokedAt = null;
@@ -63,6 +63,7 @@ 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());
     }
     /**
@@ -283,8 +284,9 @@ export class AbstractMainContainer extends Container {
      * 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;
     }
     /**
@@ -563,8 +565,9 @@ export class AbstractMainContainer extends Container {
      * 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;
@@ -604,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();
@@ -770,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();
         }

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/common/AnimatedNumber.d.ts

@@ -1,15 +1,17 @@
 import { Container } from "pixi.js";
+import { Spine } from "pixi-spine";
 /**
  * Class representing animated number, based on spine animation.
  * Animation names should be exact the same as a represented symbol.
  */
 export declare class AnimatedNumber extends Container {
-    private spineName;
-    private number;
-    private digits;
+    spineName: string;
+    number: number | string;
+    digits: Spine[];
     constructor(spineName: string, number: number | string);
     private setDigits;
-    private removeDigits;
+    setMoveAnimation(): void;
+    removeDigits(): void;
     get value(): number | string;
     set value(value: number | string);
     play(): void;

package/dist/components/common/AnimatedNumber.js

@@ -31,6 +31,22 @@ export class AnimatedNumber extends Container {
         });
         this.pivot.set(this.width / 2, this.height / 2);
     }
+    setMoveAnimation() {
+        this.removeDigits();
+        Array.from(this.number.toString()).forEach((digit) => {
+            const digitSpine = new Spine(getSpineData(this.spineName));
+            digitSpine.state.setAnimation(0, digit + "-move", true);
+            digitSpine.x = (this.digits.at(-1)?.x || 0) + digitSpine.width * 2;
+            if (digit === "." || digit === ",") {
+                digitSpine.x += 15;
+                digitSpine.y += 25;
+            }
+            digitSpine.state.timeScale = 1;
+            this.addChild(digitSpine);
+            this.digits.push(digitSpine);
+        });
+        this.pivot.set(this.width / 2, this.height / 2);
+    }
     removeDigits() {
         this.digits.forEach((digit) => this.removeChild(digit));
         this.digits = [];

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;

package/dist/connectivity/ConnectionWrapper.d.ts

@@ -1,10 +1,12 @@
 import { ExtraDataRequest, GambleCardColor, GambleDataInterface, InitDataInterface, ServerMessage, SpinData, SubscribableConnectionWrapper } from "../connectivity";
 /**
  * Class for managing connection to the server via websockets
+ * This class handles communication with the server, including fetching initial data, spin data, free spin data, and gamble data.
+ * @implements {SubscribableConnectionWrapper}
  */
 export declare class ConnectionWrapper implements SubscribableConnectionWrapper {
     private webSocketConnection;
-    private config;
+    private config?;
     private fetchInProgress;
     private lastFetchResponse;
     private lastGambleResponse;
@@ -15,18 +17,43 @@ export declare class ConnectionWrapper implements SubscribableConnectionWrapper
      */
     private handleMessage;
     private _messageHistory;
-    private _initData;
+    private _initData?;
     constructor();
+    /**
+     * Method for opening a websocket connection
+     * @returns {Promise<void>} resolves when the connection is opened
+     */
     private openConnection;
     /**
      * Method for initializing communication with the server
      */
     initCommunication(): Promise<void>;
+    /**
+     * Method for subscribing to configuration changes
+     * @param {() => void} subscriberFn - function to be called when configuration changes
+     * @returns {void}
+     * @memberof ConnectionWrapper
+     */
     subscribeForConfigChanges(subscriberFn: () => void): void;
+    /**
+     * Method for fetching initial data from the server
+     * @returns {Promise<void>} resolves when the data is fetched
+     * @memberof ConnectionWrapper
+     */
     fetchInitData(): Promise<void>;
+    /**
+     * Method for getting initial data from the server
+     * @returns {InitDataInterface} initial data from the server
+     */
     initData(): InitDataInterface;
+    /**
+     * Method for fetching free spin data from the server
+     * @param {number} roundNumber round number
+     * @param {number} quantity quantity of free spins
+     * @param {number} price price of free spins
+     * @returns {SpinData} spin data
+     */
     fetchFreeSpinData(roundNumber: number, quantity: number, price: number): Promise<SpinData>;
-    private transformFreeSpinData;
     /**
      * Method for fetching spin data from the server
      * @param {number} roundNumber round number
@@ -35,7 +62,25 @@ export declare class ConnectionWrapper implements SubscribableConnectionWrapper
      * @returns {SpinData} spin data
      */
     fetchSpinData(roundNumber: number, bet: number, extra_data?: ExtraDataRequest): Promise<SpinData>;
+    /**
+     * Sends end of round data to the server
+     * This method is used to notify the server that the round has ended and to update the server state accordingly.
+     * @param {number} roundNumber - the round number to send data from
+     * @returns {Promise<ServerMessage>} - server message with end of round data
+     */
+    sendEndOfRoundData(roundNumber: number): Promise<ServerMessage>;
+    /**
+     * Method for fetching gamble data from the server
+     * @param {number} roundNumber round number
+     * @param {number} bet bet amount
+     * @param {GambleCardColor} choice gamble card color choice
+     * @returns {Promise<GambleDataInterface>} gamble data
+     */
     fetchGambleData(roundNumber: number, bet: number, choice: GambleCardColor): Promise<GambleDataInterface>;
+    /**
+     * Method for getting a fresh websocket instance
+     * @returns {WebSocket} fresh websocket instance
+     */
     private getFreshWsInstance;
     /**
      * Method for fetching data from the server
@@ -43,6 +88,14 @@ export declare class ConnectionWrapper implements SubscribableConnectionWrapper
      * @returns {ServerMessage} server response
      */
     private fetch;
+    /**
+     * Method for getting message history
+     * @returns {ServerMessage[]} message history
+     */
     getMessageHistory(): ServerMessage[];
+    /**
+     * Method for getting the last gamble response
+     * @returns {GambleDataInterface | null} last gamble response
+     */
     getLastGambleResponse(): typeof this.lastGambleResponse;
 }

package/dist/connectivity/ConnectionWrapper.js

@@ -7,6 +7,8 @@ import { logError, logInfo, logWarn } from "../utils";
 const overrideMap = new Map();
 /**
  * Class for managing connection to the server via websockets
+ * This class handles communication with the server, including fetching initial data, spin data, free spin data, and gamble data.
+ * @implements {SubscribableConnectionWrapper}
  */
 export class ConnectionWrapper {
     webSocketConnection;
@@ -40,35 +42,43 @@ export class ConnectionWrapper {
     constructor() {
         this.webSocketConnection = this.getFreshWsInstance();
     }
+    /**
+     * Method for opening a websocket connection
+     * @returns {Promise<void>} resolves when the connection is opened
+     */
     async openConnection() {
-        return new Promise((resolve) => {
-            this.webSocketConnection.addEventListener("open", resolve);
-        });
+        return new Promise((resolve) => this.webSocketConnection.addEventListener("open", resolve));
     }
     /**
      * Method for initializing communication with the server
      */
     async initCommunication() {
-        this.webSocketConnection.addEventListener("error", (event) => {
-            logError(`Error in webSocket connection: ${event}`);
-        });
+        this.webSocketConnection.addEventListener("error", (event) => logError(`Error in webSocket connection: ${event}`));
         await this.openConnection();
         this.webSocketConnection.addEventListener("close", async (event) => {
             logWarn(`Reiniting communications after connection was closed. Reason: ${event.reason}`);
             this.webSocketConnection = this.getFreshWsInstance();
             await this.initCommunication();
             await this.fetchInitData();
-            this.subscribers.forEach((subscriberFn) => {
-                subscriberFn();
-            });
-            RainMan.globals.actionsAfterClosureWebSocket?.();
+            this.subscribers.forEach((subscriberFn) => subscriberFn());
         });
         this.webSocketConnection.addEventListener("message", (event) => this.handleMessage(JSON.parse(event.data)));
         logInfo("connection established, listener set");
     }
+    /**
+     * Method for subscribing to configuration changes
+     * @param {() => void} subscriberFn - function to be called when configuration changes
+     * @returns {void}
+     * @memberof ConnectionWrapper
+     */
     subscribeForConfigChanges(subscriberFn) {
         this.subscribers.push(subscriberFn);
     }
+    /**
+     * Method for fetching initial data from the server
+     * @returns {Promise<void>} resolves when the data is fetched
+     * @memberof ConnectionWrapper
+     */
     async fetchInitData() {
         this._initData = (await this.fetch({
             action: "init",
@@ -85,26 +95,40 @@ export class ConnectionWrapper {
             vendor_id: RainMan.config.gameInitVendorId
         }));
         RainMan.globals.currency = Currencies[this._initData.currency];
+        RainMan.settingsStore.setFreeSpinsPriceTable(this._initData.free_spins_buy_table);
     }
+    /**
+     * Method for getting initial data from the server
+     * @returns {InitDataInterface} initial data from the server
+     */
     initData() {
         return this._initData;
     }
+    /**
+     * Method for fetching free spin data from the server
+     * @param {number} roundNumber round number
+     * @param {number} quantity quantity of free spins
+     * @param {number} price price of free spins
+     * @returns {SpinData} spin data
+     */
     async fetchFreeSpinData(roundNumber, quantity, price) {
         if (typeof this.config?.token === "undefined") {
             throw new Error("Token was not defined");
         }
         const data = (await this.fetch({
-            action: "buy-free-spins",
+            action: "buy",
+            operation: "buy-free-spins",
+            buy_price: price,
             round_number: roundNumber,
-            free_spins_quantity: quantity,
-            free_spins_price: price,
             token: this.config.token,
-            reference: RainMan.config.gameInitReference
+            reference: RainMan.config.gameInitReference,
+            bet: RainMan.settingsStore.bet,
+            extra_data: {
+                free_spins_quantity: quantity
+            }
         }));
-        return new SpinData(this.config, this.transformFreeSpinData(data));
-    }
-    transformFreeSpinData(data) {
-        return { ...data, previous_gambles: [], results: [], win_amount_total: 0, wins: {}, extra_data: {} };
+        RainMan.settingsStore.setRoundNumber(data.round_number);
+        return new SpinData(this.config, data);
     }
     /**
      * Method for fetching spin data from the server
@@ -126,8 +150,35 @@ export class ConnectionWrapper {
             extra_data
         });
         this._messageHistory.push(data);
+        this.sendEndOfRoundData(roundNumber);
         return new SpinData(this.config, data);
     }
+    /**
+     * Sends end of round data to the server
+     * This method is used to notify the server that the round has ended and to update the server state accordingly.
+     * @param {number} roundNumber - the round number to send data from
+     * @returns {Promise<ServerMessage>} - server message with end of round data
+     */
+    async sendEndOfRoundData(roundNumber) {
+        if (typeof this.config?.token === "undefined") {
+            throw new Error("Token was not defined");
+        }
+        const data = await this.fetch({
+            action: "end",
+            round_number: roundNumber,
+            reference: RainMan.config.gameInitReference,
+            token: this.config.token
+        });
+        this._messageHistory.push(data);
+        return data;
+    }
+    /**
+     * Method for fetching gamble data from the server
+     * @param {number} roundNumber round number
+     * @param {number} bet bet amount
+     * @param {GambleCardColor} choice gamble card color choice
+     * @returns {Promise<GambleDataInterface>} gamble data
+     */
     async fetchGambleData(roundNumber, bet, choice) {
         if (typeof this.config?.token === "undefined") {
             throw new Error("Token was not defined");
@@ -140,8 +191,14 @@ export class ConnectionWrapper {
             bet,
             choice
         }));
+        this._messageHistory.push(this.lastGambleResponse);
+        this.sendEndOfRoundData(roundNumber);
         return this.lastGambleResponse;
     }
+    /**
+     * Method for getting a fresh websocket instance
+     * @returns {WebSocket} fresh websocket instance
+     */
     getFreshWsInstance() {
         return new WebSocket(RainMan.config.websocketUrl);
     }
@@ -171,9 +228,17 @@ export class ConnectionWrapper {
             waitForData();
         });
     }
+    /**
+     * Method for getting message history
+     * @returns {ServerMessage[]} message history
+     */
     getMessageHistory() {
         return this._messageHistory;
     }
+    /**
+     * Method for getting the last gamble response
+     * @returns {GambleDataInterface | null} last gamble response
+     */
     getLastGambleResponse() {
         return this.lastGambleResponse;
     }

package/dist/connectivity/LocalConnectionWrapper.d.ts

@@ -18,6 +18,7 @@ export declare class LocalConnectionWrapper implements SubscribableConnectionWra
     initData(): InitDataInterface;
     fetchSpinData(): Promise<SpinData>;
     subscribeForConfigChanges(subscriberFn: () => void): void;
+    sendEndOfRoundData(roundNumber: number): Promise<ServerMessage>;
     fetchFreeSpinData(roundNumber: number, quantity: number): Promise<SpinData>;
     getMessageHistory(): ServerMessage[];
 }

package/dist/connectivity/LocalConnectionWrapper.js

@@ -41,6 +41,16 @@ export class LocalConnectionWrapper {
     subscribeForConfigChanges(subscriberFn) {
         this.subscribers.push(subscriberFn);
     }
+    sendEndOfRoundData(roundNumber) {
+        const data = {
+            action: "end",
+            balance: 1000,
+            round_number: roundNumber,
+            status: { code: 200, message: "OK" }
+        };
+        this.subscribers.forEach((subscriber) => subscriber());
+        return Promise.resolve(data);
+    }
     fetchFreeSpinData(roundNumber, quantity) {
         const data = {
             action: "buy-free-spins",

package/dist/connectivity/serverConnection.d.ts

@@ -1,4 +1,4 @@
-import { GambleCardColor, GambleDataInterface, InitDataInterface, SpinDataInterface } from "./serverData";
+import { EndDataInterface, GambleCardColor, GambleDataInterface, InitDataInterface, SpinDataInterface } from "./serverData";
 import { SpinData } from "./spinData";
 export interface ServerCommunication {
     initCommunication(): Promise<void>;
@@ -6,6 +6,7 @@ export interface ServerCommunication {
     initData(): InitDataInterface;
     fetchSpinData(roundNumber: number, bet: number, extraData?: ExtraDataRequest): Promise<SpinData>;
     fetchFreeSpinData(roundNumber: number, amount: number, price: number): Promise<SpinData>;
+    sendEndOfRoundData(roundNumber: number): Promise<ServerMessage>;
     getMessageHistory(): ServerMessage[];
 }
 export interface Subscribable {
@@ -34,17 +35,24 @@ export type SpinServerRequest = BaseServerRequest & {
     extra_data: ExtraDataRequest;
 };
 export type BuyFreeSpinServerRequest = BaseServerRequest & {
-    action: "buy-free-spins";
-    free_spins_quantity: number;
-    free_spins_price: number;
+    action: "buy";
+    operation: "buy-free-spins";
+    bet: number;
+    buy_price: number;
+    extra_data: {
+        free_spins_quantity: number;
+    };
 };
 export type GambleServerRequest = BaseServerRequest & {
     action: "gamble";
     bet: number;
     choice: GambleCardColor;
 };
+export type EndServerRequest = BaseServerRequest & {
+    action: "end";
+};
 export interface ExtraDataRequest {
 }
-export type ServerRequest = InitServerRequest | SpinServerRequest | BuyFreeSpinServerRequest | GambleServerRequest;
-export type ServerMessage = InitDataInterface | SpinDataInterface | GambleDataInterface;
+export type ServerRequest = InitServerRequest | SpinServerRequest | BuyFreeSpinServerRequest | GambleServerRequest | EndServerRequest;
+export type ServerMessage = InitDataInterface | SpinDataInterface | GambleDataInterface | EndDataInterface;
 export {};

package/dist/connectivity/serverData.d.ts

@@ -1,4 +1,5 @@
 import { PaytableTypes } from "../constants";
+import { Nullable } from "../utils";
 import { Point, RawTransformationDetails } from "./transformation";
 export interface InitDataInterface {
     action: string;
@@ -14,10 +15,21 @@ export interface InitDataInterface {
     wins_names: Array<string>;
     transformations_names: Array<string>;
     transformations_types: Array<number>;
+    free_spins_buy_table?: Record<number, number>;
+    free_spins_prize_table?: Record<number, number>;
     paytable: PayTableInterface;
     extra_data: InitExtraData;
     jackpot_wins?: JackpotWins;
 }
+export interface EndDataInterface {
+    action: "end";
+    balance: number;
+    round_number: number;
+    status: {
+        code: number;
+        message: string;
+    };
+}
 export type JackpotType = "jackpot-mini" | "jackpot-minor" | "jackpot-major" | "jackpot-grand";
 export type JackpotWins = {
     "jackpot-grand": {
@@ -76,9 +88,10 @@ export interface SpinDataInterface {
     symbols_on_reels: number[][];
     win_amount_total: number;
     wins: Record<string, RawWin>;
-    extra_data: ExtraData | null;
+    extra_data: Nullable<ExtraData>;
 }
 export interface ExtraData {
+    available_free_spins?: number;
 }
 export interface GambleDataInterface {
     action: "gamble";
@@ -90,7 +103,7 @@ export interface GambleDataInterface {
     winning_card: GambleCard;
 }
 export interface FreeSpinDataInterface {
-    action: "buy-free-spins";
+    action: "buy";
     available_free_spins: number;
     balance: number;
     round_number: number;

package/dist/connectivity/spinData.js

@@ -6,8 +6,8 @@ export class SpinData {
         this.rawData = data;
         this.config = config;
         this.balance = data.balance;
-        if (data.action !== "spin" && data.action !== "buy-free-spins") {
-            throw new Error(`Invalid type "${data.action}" provided, "spin" or "buy-free-spins" expected`);
+        if (data.action !== "spin" && data.action !== "buy") {
+            throw new Error(`Invalid type "${data.action}" provided, "spin" or "buy" expected`);
         }
     }
     getRawData() {

package/dist/constants/gamePhase.js

@@ -12,5 +12,5 @@ export const gamePhases = {
     BIG_WIN_INVOKED: "bigWinInvoked",
     SUPER_BONUS_WIN_INVOKED: "superBonusWinInvoked",
     BONUS_WIN_INVOKED: "bonusWinInvoked",
-    GAME_SUMMARY: "gameSummary",
+    GAME_SUMMARY: "gameSummary"
 };

package/dist/constants/transformation.js

@@ -10,5 +10,5 @@ export const transformationTypes = {
     swap: "swap",
     replace: "replace",
     spinAndFreeze: "spinAndFreeze",
-    verticalExpand: "vertical-expand",
+    verticalExpand: "vertical-expand"
 };

package/dist/constants/wins.js

@@ -19,5 +19,5 @@ export const PossibleWins = {
     bonus: "bonus",
     superBonus: "super-bonus",
     joker: "joker",
-    multi: "multi",
+    multi: "multi"
 };

package/dist/controllers/AbstractController.d.ts

@@ -86,12 +86,17 @@ export declare abstract class AbstractController<T> {
      * Function for disabling speed button
      * @param {boolean} shouldBeDisabled flag to disable speed button
      */
-    private disableSpeedButton;
+    disableSpeedButton(shouldBeDisabled: boolean): void;
     /**
      * Function for disabling information buttons
      * @param {boolean} shouldBeDisabled flag to disable information buttons
      */
     disableInformationButtons(shouldBeDisabled: boolean): void;
+    /**
+     * Function for disabling refresh buttons
+     * @param {boolean} shouldBeDisabled flag to disable refresh buttons
+     */
+    disableRefreshButton(shouldBeDisabled: boolean): void;
     /**
      * Function for handling disabling buttons
      * @param {boolean} disabled flag to disable buttons

package/dist/controllers/AbstractController.js

@@ -177,6 +177,13 @@ export class AbstractController {
         ];
         buttonsToChange.forEach((button) => button.flipDisabledFlag(shouldBeDisabled));
     }
+    /**
+     * Function for disabling refresh buttons
+     * @param {boolean} shouldBeDisabled flag to disable refresh buttons
+     */
+    disableRefreshButton(shouldBeDisabled) {
+        RainMan.componentRegistry.get(BUTTONS.refresh).flipDisabledFlag(shouldBeDisabled);
+    }
     /**
      * Function for handling disabling buttons
      * @param {boolean} disabled flag to disable buttons
@@ -531,8 +538,7 @@ export class AbstractController {
         if (RainMan.settingsStore.isFreeSpinsBought) {
             this.uiController.totalNumberOfFreeSpins += this.getBoughtNumberOfFreeSpins();
             RainMan.componentRegistry.getIfExists(FreeSpinButton.registryName)?.setInteractivity(false);
-            this.changeGamePhase(gamePhases.IDLE);
-            this.spin().then(() => RainMan.settingsStore.setIsFreeSpinBought(false));
+            RainMan.settingsStore.setIsFreeSpinBought(false);
             return;
         }
         if (RainMan.settingsStore.isAutoplayEnabled && !this.spinning) {
@@ -560,7 +566,7 @@ export class AbstractController {
      * @returns {number} - number of free spins bought
      */
     getBoughtNumberOfFreeSpins() {
-        return RainMan.settingsStore.buyFreeSpinsData?.getRawData().available_free_spins || 0;
+        return RainMan.settingsStore.buyFreeSpinsData?.getRawData().extra_data.available_free_spins || 0;
     }
     /**
      * Function for autoplay spin
@@ -619,8 +625,7 @@ export class AbstractController {
     async fetchAndPrepareSpinData() {
         this.changeGamePhase(gamePhases.DATA_FETCH);
         this.handleDisablingButtons(true);
-        const data = RainMan.settingsStore.buyFreeSpinsData ||
-            (await this.connection.fetchSpinData(this.roundNumber, RainMan.settingsStore.bet, this.getExtraData()));
+        const data = await this.connection.fetchSpinData(this.roundNumber, RainMan.settingsStore.bet, this.getExtraData());
         debugSpinData(data);
         const spinLogic = this.spinLogicFactory(data.getRawData(), this.config);
         this._lastWinAmount = this.mysteryWinSymbol ? spinLogic.winTotalAmountWithoutMystery : spinLogic.winTotalAmount;
@@ -633,6 +638,8 @@ export class AbstractController {
         }
         this.changeGamePhase(gamePhases.CONFIGURING_SPIN);
         this.uiController.currentBalance = data.balance;
+        this.roundNumber = data.getRawData().round_number;
+        RainMan.settingsStore.setRoundNumber(data.getRawData().round_number);
         return {
             data,
             spinLogic
@@ -704,8 +711,9 @@ export class AbstractController {
             case gamePhases.IDLE:
                 break;
             case gamePhases.HANDLING_ACTIONS:
-                if (!this.canSkipActions())
+                if (!this.canSkipActions()) {
                     return;
+                }
                 this.changeGamePhase(gamePhases.STOPPING_HANDLING_ACTIONS);
                 if (this.currentlyPlayedAction !== undefined) {
                     this.stopPlayingSymbolsStreak();
@@ -736,10 +744,12 @@ export class AbstractController {
         const availableFreeSpins = spinLogic.availableFreeSpins;
         const availableFreeSpinsIncreased = availableFreeSpins > RainMan.settingsStore.howManyFreeSpinsLeft;
         this.hideFreeSpinsMessageBox = availableFreeSpinsIncreased;
-        if (!availableFreeSpinsIncreased)
+        if (!availableFreeSpinsIncreased) {
             this.uiController.updateShownFreeSpinAmount(availableFreeSpins);
-        else
+        }
+        else {
             this.uiController.updateShownFreeSpinAmount(RainMan.settingsStore.howManyFreeSpinsLeft - 1);
+        }
         if (availableFreeSpins > 0) {
             RainMan.settingsStore.setTotalNumberOfFreeSpins(availableFreeSpins + RainMan.settingsStore.freeSpinNumberBought);
         }
@@ -764,8 +774,9 @@ export class AbstractController {
             this.uiController.limitWinAmount(spinLogic.winTotalAmount);
         }
         this.composeWinActionsQueue(spinLogic);
-        if (spinLogic.winTotalAmount === 0 && this.invokeFreeSpinPlateAfterWin)
+        if (spinLogic.winTotalAmount === 0 && this.invokeFreeSpinPlateAfterWin) {
             this.uiController.messageBox.hideCurrentWinText();
+        }
         RainMan.settingsStore.setIsPlayingAnyAction(true);
         await this.playWinActionQueue();
         await this.countBigWin();
@@ -788,7 +799,7 @@ export class AbstractController {
         RainMan.settingsStore.resetIsLastFreeSpin();
         this.mainContainer.destroyBigWin();
         this.columnsContainer.resetPlayedSounds();
-        if (this.invokeFreeSpinPlateAfterWin || RainMan.settingsStore.isFreeSpinsBought) {
+        if (this.invokeFreeSpinPlateAfterWin) {
             this.uiController.messageBox.hideCurrentWinText();
             this.mainContainer.messageBox.hideFreeSpinText();
             hideLayerIfPresent();
@@ -804,8 +815,9 @@ export class AbstractController {
             this.uiController.triggerUiElementsUpdate();
             this.uiController.messageBox.showFreeSpinText();
         }
-        if (availableFreeSpinsIncreased)
+        if (availableFreeSpinsIncreased) {
             this.uiController.updateShownFreeSpinAmount(availableFreeSpins);
+        }
         if (this.invokeFreeSpinSummaryPlateAfterWin && !this.skipFreeSpinSummary) {
             hideLayerIfPresent();
             await this.handleFreeSpinSummaryPlateInvocation();

package/dist/controllers/UiController.js

@@ -17,6 +17,7 @@ export class UiController {
     constructor(config) {
         this.config = config;
         this._messageBox = RainMan.componentRegistry.get(MessageBox.registryName);
+        RainMan.globals.updateFreeSpinShown = this.updateShownFreeSpinAmount.bind(this);
     }
     get messageBox() {
         return this._messageBox;

package/dist/loading/AbstractLoadingContainer.js

@@ -19,7 +19,7 @@ export class AbstractLoadingContainer extends Container {
         this.loaderContainer = new SpriteLoadingContainer("./assets/images/materials/texture.png", {
             fill: ["#FCD784", "#AE6119", "#FEE391"], // gradient
             stroke: "#4a1850",
-            dropShadowColor: "#000000",
+            dropShadowColor: "#000000"
         });
         RainMan.app.renderer.on("resize", () => this.resize()); // arrow fn to pass this context to resize
     }

package/dist/stores/SettingsStore.d.ts

@@ -20,7 +20,7 @@ export declare class SettingsStore {
     totalNumberOfFreeSpins: number;
     isFreeSpinsBought: boolean;
     freeSpinNumberBought: number;
-    buyFreeSpinsData: SpinData | null;
+    buyFreeSpinsData: Nullable<SpinData>;
     isAutoplayEnabled: boolean;
     isLastFreeSpin: boolean;
     infinitySpinsEnabled: boolean;
@@ -38,6 +38,7 @@ export declare class SettingsStore {
     balancedDecreased: number;
     howManyFreeSpinsLeft: number;
     howManyAutoSpinsLeft: number;
+    freeSpinBuyTable: Record<number, number>;
     volumeLevel: number;
     popupPaytablePosition?: Point;
     popupPaytableData?: PaytableData[];
@@ -47,6 +48,7 @@ export declare class SettingsStore {
     popupPaytableRepositionCallback?: () => void;
     updateVolumeButtonTexture?: () => void;
     handleModalInvocation?: (layerId: string) => void;
+    handleInvokeFreeSpinPlate?: (freeSpinAmount: number, isAdditionalFreeSpin: boolean) => Promise<void>;
     increaseBet?: () => void;
     decreaseBet?: () => void;
     enableButtons?: () => void;
@@ -61,6 +63,7 @@ export declare class SettingsStore {
     changeBetChangeDisabled(flag: boolean): void;
     isIosScrollerInteractive(flag: boolean): void;
     resetCumulativeWinAmount(): void;
+    setFreeSpinsPriceTable(freeSpinsPriceTable: Record<number, number>): void;
     /**
      * Sets bet value
      * @param {number} newBet updated bet value
@@ -113,8 +116,9 @@ export declare class SettingsStore {
     resetIsLastFreeSpin(): void;
     setTotalNumberOfFreeSpins(newValue: number): void;
     resetTotalNumberOfFreeSpins(): void;
-    setIsFreeSpinBought(newValue: boolean, data?: SpinData | null): void;
+    setIsFreeSpinBought(newValue: boolean, data?: Nullable<SpinData>): void;
     setFreeSpinNumberBought(newValue: number): void;
+    setHandleInvokeFreeSpinPlate(callback: (freeSpinAmount: number, isAdditionalFreeSpin: boolean) => Promise<void>): void;
     resetFreeSpinNumberBought(): void;
     setRoundNumber(newValue: number): void;
     setModalsAvailability(flag: boolean): void;

package/dist/stores/SettingsStore.js

@@ -41,6 +41,7 @@ export class SettingsStore {
     balancedDecreased = 0;
     howManyFreeSpinsLeft = 0;
     howManyAutoSpinsLeft = INITIAL_AUTO_SPIN_COUNT;
+    freeSpinBuyTable = {};
     volumeLevel = getFromLocalStorage(LOCAL_STORAGE.volumeLevel, 100);
     popupPaytablePosition;
     popupPaytableData;
@@ -50,6 +51,7 @@ export class SettingsStore {
     popupPaytableRepositionCallback;
     updateVolumeButtonTexture;
     handleModalInvocation;
+    handleInvokeFreeSpinPlate;
     increaseBet;
     decreaseBet;
     enableButtons;
@@ -129,6 +131,9 @@ export class SettingsStore {
     resetCumulativeWinAmount() {
         this.cumulativeWinAmount = 0;
     }
+    setFreeSpinsPriceTable(freeSpinsPriceTable) {
+        this.freeSpinBuyTable = freeSpinsPriceTable;
+    }
     /**
      * Sets bet value
      * @param {number} newBet updated bet value
@@ -333,6 +338,11 @@ export class SettingsStore {
     }
     setFreeSpinNumberBought(newValue) {
         this.freeSpinNumberBought = newValue;
+        this.howManyFreeSpinsLeft = newValue;
+        this.totalNumberOfFreeSpins = newValue;
+    }
+    setHandleInvokeFreeSpinPlate(callback) {
+        this.handleInvokeFreeSpinPlate = callback;
     }
     resetFreeSpinNumberBought() {
         this.freeSpinNumberBought = 0;

package/dist/utils/common/functions.js

@@ -72,7 +72,7 @@ export const waitForAnimationToEnd = async (spine, animationName, loopAnimationN
                 if (loopAnimationName)
                     spine.state.setAnimation(0, loopAnimationName, true);
                 resolve();
-            },
+            }
         });
     });
 };

package/dist/utils/common/placementHelpers.js

@@ -8,7 +8,7 @@ export const scaleToParent = (width, height, parentWidth, parentHeight) => {
         // some dependent size. image, figure etc.
         target: new Size(width, height),
         // policy is optional. default is null
-        policy: POLICY.ShowAll, // null | ExactFit | NoBorder | FullHeight | FullWidth | ShowAll
+        policy: POLICY.ShowAll // null | ExactFit | NoBorder | FullHeight | FullWidth | ShowAll
     });
 };
 const getMobileScreenRatio = () => {

package/dist/utils/common/types.d.ts

@@ -1,7 +1,8 @@
 export type Nullable<T> = T | null;
 export type PlayableAction = () => Promise<void> | Promise<void[]>;
-export type VoidPromiseResolver = (value: void | PromiseLike<void>) => void;
 export type DeviceOrientation = "pc" | "mobile-portrait" | "mobile-landscape";
 export type DeepPartial<T> = T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
+export type VoidFunction = () => void;
+export type PromiseResolverType<T = void> = (value: T | PromiseLike<T>) => void;

package/package.json

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