pixi-rainman-game-engine 0.2.26 → 0.2.28

package/dist/ComponentRegistry/ComponentRegistry.js

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

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

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

package/dist/application/ButtonsEventManager/ButtonsEventManager.js

@@ -1,6 +1,6 @@
 import i18n from "i18next";
 import { sample } from "lodash";
-import { SoundManager } from "../../application";
+import { SoundManager, SoundTracks } from "../../application";
 import { AutoplayButton, Background, BUTTONS, COMPONENTS, FreeSpinButton, MessageBox, SpeedControlButton, VolumeButton } from "../../components";
 import { RainMan } from "../../Rainman";
 import { allUiItems, hideLayerIfPresent, UI_ITEMS, wait } from "../../utils";
@@ -199,7 +199,7 @@ export class ButtonsEventManager {
             if (RainMan.settingsStore.isSoundEnabled()) {
                 SoundManager.resumeAll();
                 if (RainMan.settingsStore.shouldPlayAmbientMusic) {
-                    SoundManager.setPlayStatus("music", RainMan.settingsStore.shouldPlayAmbientMusic);
+                    SoundManager.setPlayStatus(RainMan.settingsStore.isFreeSpinsPlayEnabled ? SoundTracks.freeSpinsMusic : SoundTracks.music, RainMan.settingsStore.shouldPlayAmbientMusic);
                 }
             }
             RainMan.componentRegistry.get(VolumeButton.registryName).changeTextureDependOnVolume();

package/dist/application/SoundManager/SoundManager.js

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

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

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

package/dist/application/SoundManager/types.js

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

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

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

package/dist/components/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/frame/AbstractColumnsContainer.d.ts

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

package/dist/components/frame/AbstractColumnsContainer.js

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

package/dist/connectivity/ConnectionWrapper.d.ts

@@ -69,6 +69,12 @@ export declare class ConnectionWrapper implements SubscribableConnectionWrapper
      * @returns {Promise<ServerMessage>} - server message with end of round data
      */
     sendEndOfRoundData(roundNumber: number): Promise<ServerMessage>;
+    /**
+     *  Method for sending take action to the server. User can save his balance after spin and then safely leave the game.
+     * @param {number} roundNumber - the round number to send data from
+     * @returns {Promise<ServerMessage>} - server message with end of round data
+     */
+    sendTakeAction(roundNumber: number): Promise<ServerMessage>;
     /**
      * Method for fetching gamble data from the server
      * @param {number} roundNumber round number

package/dist/connectivity/ConnectionWrapper.js

@@ -150,7 +150,7 @@ export class ConnectionWrapper {
             extra_data
         });
         this._messageHistory.push(data);
-        this.sendEndOfRoundData(roundNumber - 1);
+        this.sendEndOfRoundData(roundNumber);
         return new SpinData(this.config, data);
     }
     /**
@@ -172,6 +172,24 @@ export class ConnectionWrapper {
         this._messageHistory.push(data);
         return data;
     }
+    /**
+     *  Method for sending take action to the server. User can save his balance after spin and then safely leave the game.
+     * @param {number} roundNumber - the round number to send data from
+     * @returns {Promise<ServerMessage>} - server message with end of round data
+     */
+    async sendTakeAction(roundNumber) {
+        if (typeof this.config?.token === "undefined") {
+            throw new Error("Token was not defined");
+        }
+        const data = await this.fetch({
+            action: "take",
+            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
@@ -192,7 +210,7 @@ export class ConnectionWrapper {
             choice
         }));
         this._messageHistory.push(this.lastGambleResponse);
-        this.sendEndOfRoundData(roundNumber - 1);
+        this.sendEndOfRoundData(roundNumber);
         return this.lastGambleResponse;
     }
     /**

package/dist/connectivity/LocalConnectionWrapper.d.ts

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

package/dist/connectivity/LocalConnectionWrapper.js

@@ -51,6 +51,17 @@ export class LocalConnectionWrapper {
         this.subscribers.forEach((subscriber) => subscriber());
         return Promise.resolve(data);
     }
+    sendTakeAction(roundNumber) {
+        const data = {
+            action: "take",
+            balance: 1000,
+            round_number: roundNumber,
+            status: { code: 200, message: "OK" },
+            win_amount_total: 1
+        };
+        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 { EndDataInterface, GambleCardColor, GambleDataInterface, InitDataInterface, SpinDataInterface } from "./serverData";
+import { EndDataInterface, GambleCardColor, GambleDataInterface, InitDataInterface, SpinDataInterface, TakeDataInterface } from "./serverData";
 import { SpinData } from "./spinData";
 export interface ServerCommunication {
     initCommunication(): Promise<void>;
@@ -7,6 +7,7 @@ export interface ServerCommunication {
     fetchSpinData(roundNumber: number, bet: number, extraData?: ExtraDataRequest): Promise<SpinData>;
     fetchFreeSpinData(roundNumber: number, amount: number, price: number): Promise<SpinData>;
     sendEndOfRoundData(roundNumber: number): Promise<ServerMessage>;
+    sendTakeAction(roundNumber: number): Promise<ServerMessage>;
     getMessageHistory(): ServerMessage[];
 }
 export interface Subscribable {
@@ -51,8 +52,11 @@ export type GambleServerRequest = BaseServerRequest & {
 export type EndServerRequest = BaseServerRequest & {
     action: "end";
 };
+export type TakeServerRequest = BaseServerRequest & {
+    action: "take";
+};
 export interface ExtraDataRequest {
 }
-export type ServerRequest = InitServerRequest | SpinServerRequest | BuyFreeSpinServerRequest | GambleServerRequest | EndServerRequest;
-export type ServerMessage = InitDataInterface | SpinDataInterface | GambleDataInterface | EndDataInterface;
+export type ServerRequest = InitServerRequest | SpinServerRequest | BuyFreeSpinServerRequest | GambleServerRequest | EndServerRequest | TakeServerRequest;
+export type ServerMessage = InitDataInterface | SpinDataInterface | GambleDataInterface | EndDataInterface | TakeDataInterface;
 export {};

package/dist/connectivity/serverData.d.ts

@@ -30,6 +30,16 @@ export interface EndDataInterface {
         message: string;
     };
 }
+export interface TakeDataInterface {
+    action: "take";
+    balance: number;
+    round_number: number;
+    status: {
+        code: number;
+        message: string;
+    };
+    win_amount_total: number;
+}
 export type JackpotType = "jackpot-mini" | "jackpot-minor" | "jackpot-major" | "jackpot-grand";
 export type JackpotWins = {
     "jackpot-grand": {

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
@@ -204,6 +209,12 @@ export declare abstract class AbstractController<T> {
      * Function for clearing and destroying actions in win actions queue
      */
     protected clearAndDestroyActions(): void;
+    /**
+     * Function that is used to invoke take action after winning (send request to backend to save status of wallet).
+     * After that action, gamble and other bonus games are blocked.
+     *
+     */
+    protected useTakeAction(): Promise<void>;
     /**
      * Function disabling autoplay functionality
      */

package/dist/controllers/AbstractController.js

@@ -61,6 +61,7 @@ export class AbstractController {
         this.componentRegistry = RainMan.componentRegistry;
         this.setupSpaceOrEnterListener();
         RainMan.globals.handleDisablingButtons = this.handleDisablingButtons.bind(this);
+        RainMan.settingsStore.isTakeActionAvailable = false;
         RainMan.settingsStore.increaseBet = () => {
             this.uiController.updateBet("increase");
             SoundManager.play(SoundTracks.increaseRate);
@@ -78,6 +79,7 @@ export class AbstractController {
         this.config = new ApiConfig(initData);
         RainMan.settingsStore.initPaytableMap(initData);
         RainMan.globals.throttledSpin = this.throttledSpin.bind(this);
+        RainMan.settingsStore.useTakeAction = this.useTakeAction.bind(this);
         this.connection.subscribeForConfigChanges(this.reinitializeUserBalanceData.bind(this));
         this.uiController.updateBet("first");
         this.uiController.currentBalance = initData.balance;
@@ -177,6 +179,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
@@ -243,16 +252,19 @@ export class AbstractController {
      */
     initSpinButton() {
         const refreshButton = RainMan.componentRegistry.get(RefreshButton.registryName);
-        refreshButton.setOnClick(() => {
-            this.handleDisablingButtons(true);
-            this.handleSpinLogic();
-        });
         const clearMobileSpinTimeout = () => {
             if (this.mobileSpinTimeout) {
                 clearInterval(this.mobileSpinTimeout);
                 this.mobileSpinTimeout = null;
+                this.columnsContainer.clearQuickReelsStop();
             }
         };
+        refreshButton.setOnClick(() => this.handleSpinLogic());
+        refreshButton.on("touchend", () => clearMobileSpinTimeout());
+        refreshButton.on("touchcancel", () => clearMobileSpinTimeout());
+        refreshButton.on("touchleave", () => clearMobileSpinTimeout());
+        refreshButton.on("touchendoutside", () => clearMobileSpinTimeout());
+        refreshButton.on("globaltouchmove", () => clearMobileSpinTimeout());
         refreshButton.on("touchstart", () => {
             this.mobileSpinTimeout = setInterval(() => {
                 this.handleDisablingButtons(true);
@@ -268,13 +280,6 @@ export class AbstractController {
                 this.handleSpinLogic();
             }, RainMan.config.durationOfActions.mobileSpinTimeout);
         });
-        refreshButton.on("touchend", () => {
-            clearMobileSpinTimeout();
-        });
-        refreshButton.on("globaltouchmove", (event) => {
-            if (event.target !== refreshButton)
-                clearMobileSpinTimeout();
-        });
     }
     /**
      * This function is responsible for checking if buttons (not bet buttons) should be disabled
@@ -455,6 +460,7 @@ export class AbstractController {
     handleSpinLogic() {
         this.handleDisablingButtons(true);
         RainMan.globals.shouldShowModals = false;
+        this.columnsContainer.clearQuickReelsStop();
         if (this.mainContainer.freeSpinPlate) {
             if (this.mainContainer.freeSpinPlate.shownAt === null ||
                 performance.now() - this.mainContainer.freeSpinPlate.shownAt <
@@ -516,15 +522,16 @@ export class AbstractController {
             RainMan.config.durationOfActions.speedPopupVisibleTime) {
             RainMan.globals.handleDisablingButtons?.();
             elementsToSkipHide.push(UI_ITEMS.speedSettings);
+            this.columnsContainer.clearQuickReelsStop();
         }
         hideLayerIfPresent(elementsToSkipHide);
         hidePaytable();
         if (this.gamePhase === gamePhases.DATA_FETCH ||
             this.gamePhase === gamePhases.SPINNING ||
             this.gamePhase === gamePhases.CONFIGURING_SPIN) {
-            this.columnsContainer.enableQuickReelsStop();
             this.isSpinThrottled = true;
-            this.quickStopController.handleResetCounter(!!this.spinThrottlerTimeout);
+            this.columnsContainer.enableQuickReelsStop();
+            this.quickStopController.handleResetCounter(this.spinThrottlerTimeout !== null);
             this.quickStopController.handleInvokingSpeedPopup();
             return;
         }
@@ -547,6 +554,11 @@ export class AbstractController {
             this.changeGamePhase(gamePhases.IDLE);
         }
         if (this.spinThrottlerTimeout !== null) {
+            this.columnsContainer.clearQuickReelsStop();
+            return;
+        }
+        if (this.mobileSpinTimeout !== null) {
+            this.columnsContainer.clearQuickReelsStop();
             return;
         }
         if (this.gamePhase === gamePhases.IDLE || this.gamePhase === gamePhases.HANDLING_ACTIONS) {
@@ -586,6 +598,28 @@ export class AbstractController {
         this.winActionsQueue.length = 0;
         this.currentlyPlayedAction = undefined;
     }
+    /**
+     * Function that is used to invoke take action after winning (send request to backend to save status of wallet).
+     * After that action, gamble and other bonus games are blocked.
+     *
+     */
+    async useTakeAction() {
+        if (!RainMan.settingsStore.isTakeActionAvailable ||
+            RainMan.settingsStore.roundNumber === 0 ||
+            this._lastWinAmount === 0) {
+            logInfo("Take action can't be performed");
+            return;
+        }
+        const takeData = await window.connectionWrapper.sendTakeAction(RainMan.settingsStore.roundNumber);
+        if (takeData.status.code === 200) {
+            RainMan.settingsStore.isTakeActionAvailable = false;
+            logInfo(`💰 Round ${takeData.round_number} ended with balance:`, takeData.balance);
+        }
+        else {
+            RainMan.settingsStore.isTakeActionAvailable = true;
+            logInfo("Error with take action");
+        }
+    }
     /**
      * Function disabling autoplay functionality
      */
@@ -730,6 +764,7 @@ export class AbstractController {
         this.changeGamePhase(gamePhases.SPINNING);
         this.uiController.resetWinAmount();
         await this.onSpinningStart();
+        this.columnsContainer.clearQuickReelsStop();
         this.columnsContainer.blindSpin();
         this.clearAndDestroyActions();
         const { spinLogic } = await this.fetchAndPrepareSpinData();
@@ -737,6 +772,12 @@ export class AbstractController {
         const availableFreeSpins = spinLogic.availableFreeSpins;
         const availableFreeSpinsIncreased = availableFreeSpins > RainMan.settingsStore.howManyFreeSpinsLeft;
         this.hideFreeSpinsMessageBox = availableFreeSpinsIncreased;
+        if (this._lastWinAmount !== 0) {
+            RainMan.settingsStore.isTakeActionAvailable = true;
+        }
+        else {
+            RainMan.settingsStore.isTakeActionAvailable = false;
+        }
         if (!availableFreeSpinsIncreased) {
             this.uiController.updateShownFreeSpinAmount(availableFreeSpins);
         }
@@ -755,7 +796,6 @@ export class AbstractController {
         await new Promise((resolveAfterSpins) => {
             this.columnsContainer.configBlindSpin(spinLogic.onStopBlindsConfiguration, resolveAfterSpins, this.getReelIndexesToShowMysteryFx(spinLogic));
         });
-        this.columnsContainer.clearQuickReelsStop();
         this.changeGamePhase(gamePhases.HANDLING_ACTIONS);
         this.handleDisablingButtons(true);
         this.unlockLogicAfterSpinning();

package/dist/controllers/QuickStopController.d.ts

@@ -8,11 +8,44 @@ export declare class QuickStopController {
     private buttonsEventManager;
     quickStopCounterLock: boolean;
     shouldInvokeSpeedPopup: boolean;
-    private quickStopsCounter;
     speedPopupDisabled: boolean;
+    private quickStopsCounter;
     constructor(buttonsEventManager: ButtonsEventManager);
+    /**
+     * Function for handling invoking speed popup
+     * This function will increment the quick stops counter and lock the counter if it reaches the maximum
+     * If the maximum is reached, it will set the flag to show the speed popup
+     * @public
+     * @returns {void}
+     */
     handleInvokingSpeedPopup(): void;
+    /**
+     * Function for handling speed popup invocation
+     * This function will set the visibility of the speed popup and reset the quick stop counter lock
+     * It will also disable the speed popup to prevent it from being shown again until the next
+     * quick stop counter reset
+     * @public
+     * @returns {void}
+     */
     handleSpeedPopupInvocation(): void;
+    /**
+     * Function for setting speed popup disabled state
+     * @public
+     * @param {boolean} value - whether the speed popup should be disabled
+     */
     setSpeedPopupDisabled(value: boolean): void;
+    /**
+     * Function for resetting the quick stops counter
+     * This function will reset the quick stops counter to 0 if the shouldReset parameter is true
+     * @public
+     * @param {boolean} shouldReset - whether the quick stops counter should be reset
+     * @returns {void}
+     */
     handleResetCounter(shouldReset: boolean): void;
+    /**
+     * Function for setting quick stop counter lock state
+     * @public
+     * @param {boolean} value - whether the quick stop counter should be locked
+     */
+    setQuickStopCounterLock(value: boolean): void;
 }

package/dist/controllers/QuickStopController.js

@@ -10,12 +10,19 @@ export class QuickStopController {
     buttonsEventManager;
     quickStopCounterLock = false;
     shouldInvokeSpeedPopup = false;
-    quickStopsCounter = 0;
     speedPopupDisabled = false;
+    quickStopsCounter = 0;
     constructor(buttonsEventManager) {
         this.buttonsEventManager = buttonsEventManager;
         RainMan.globals.disableSpeedPopup = this.setSpeedPopupDisabled.bind(this);
     }
+    /**
+     * Function for handling invoking speed popup
+     * This function will increment the quick stops counter and lock the counter if it reaches the maximum
+     * If the maximum is reached, it will set the flag to show the speed popup
+     * @public
+     * @returns {void}
+     */
     handleInvokingSpeedPopup() {
         if (!this.quickStopCounterLock &&
             this.quickStopsCounter < MAX_QUICK_STOPS &&
@@ -27,6 +34,14 @@ export class QuickStopController {
             }
         }
     }
+    /**
+     * Function for handling speed popup invocation
+     * This function will set the visibility of the speed popup and reset the quick stop counter lock
+     * It will also disable the speed popup to prevent it from being shown again until the next
+     * quick stop counter reset
+     * @public
+     * @returns {void}
+     */
     handleSpeedPopupInvocation() {
         if (this.shouldInvokeSpeedPopup && !this.speedPopupDisabled) {
             this.buttonsEventManager?.setSpeedPopupVisibility("flex");
@@ -35,11 +50,32 @@ export class QuickStopController {
         }
         this.quickStopCounterLock = false;
     }
+    /**
+     * Function for setting speed popup disabled state
+     * @public
+     * @param {boolean} value - whether the speed popup should be disabled
+     */
     setSpeedPopupDisabled(value) {
         this.speedPopupDisabled = value;
     }
+    /**
+     * Function for resetting the quick stops counter
+     * This function will reset the quick stops counter to 0 if the shouldReset parameter is true
+     * @public
+     * @param {boolean} shouldReset - whether the quick stops counter should be reset
+     * @returns {void}
+     */
     handleResetCounter(shouldReset) {
-        if (shouldReset)
+        if (shouldReset) {
             this.quickStopsCounter = 0;
+        }
+    }
+    /**
+     * Function for setting quick stop counter lock state
+     * @public
+     * @param {boolean} value - whether the quick stop counter should be locked
+     */
+    setQuickStopCounterLock(value) {
+        this.quickStopCounterLock = value;
     }
 }

package/dist/stores/SettingsStore.d.ts

@@ -23,6 +23,7 @@ export declare class SettingsStore {
     buyFreeSpinsData: Nullable<SpinData>;
     isAutoplayEnabled: boolean;
     isLastFreeSpin: boolean;
+    isTakeActionAvailable: boolean;
     infinitySpinsEnabled: boolean;
     roundNumber: number;
     HiResolutionFlag: boolean;
@@ -52,6 +53,7 @@ export declare class SettingsStore {
     increaseBet?: () => void;
     decreaseBet?: () => void;
     enableButtons?: () => void;
+    useTakeAction?: () => void;
     private readonly initialAutoplaySettingsState;
     private modalsAvailable;
     private paytableMap;

package/dist/stores/SettingsStore.js

@@ -26,6 +26,7 @@ export class SettingsStore {
     buyFreeSpinsData = null;
     isAutoplayEnabled = false;
     isLastFreeSpin = false;
+    isTakeActionAvailable = true;
     infinitySpinsEnabled = false;
     roundNumber = 0;
     HiResolutionFlag = getFromLocalStorage(LOCAL_STORAGE.hiResolution, true);
@@ -55,6 +56,7 @@ export class SettingsStore {
     increaseBet;
     decreaseBet;
     enableButtons;
+    useTakeAction;
     initialAutoplaySettingsState = {
         infinitySpinsEnabled: false,
         onAnyWin: false,
@@ -159,7 +161,7 @@ export class SettingsStore {
      */
     setShouldPlayAmbientMusic(flag, saveToLocalStorage = true) {
         this.shouldPlayAmbientMusic = flag;
-        SoundManager.setPlayStatus(SoundTracks.music, flag);
+        SoundManager.setPlayStatus(this.isFreeSpinsPlayEnabled ? SoundTracks.freeSpinsMusic : SoundTracks.music, flag);
         this.updateVolumeButtonTexture?.();
         if (saveToLocalStorage) {
             setToLocalStorage(LOCAL_STORAGE.isAmbientMusicEnabled, flag);

package/package.json

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