pixi-rainman-game-engine 0.3.40 → 0.3.41

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

@@ -5,13 +5,13 @@ export const SpeedButtonSwitch = observer(() => {
     const speedLevelMapper = {
         slow: "turtle",
         normal: "rabbit",
-        fast: "cheetah",
+        fast: "cheetah"
     };
     const { settingStore } = useStores();
     const { currentSpeed } = settingStore;
     return (<label className="switch turtle-switch speed-level-id">
             <span className="turtle-switch-round-box"/>
-            <img className="turtle-switch__icon" src={`assets/settings/speed-${speedLevelMapper[currentSpeed]}.png`}/>
+            <img className="turtle-switch__icon" src={`assets/settings/speed-${speedLevelMapper[currentSpeed]}.webp`}/>
             <div className="dot-container">
                 {Array.from({ length: 3 }).map((_, i) => (<div key={i} className={`white-dot ${i < settingStore.indexOfSpeedLevel ? "white-dot--active" : ""}`}/>))}
             </div>

package/dist/SettingsUI/components/VolumeSettings/volume.css

@@ -36,7 +36,7 @@
     bottom: 5px;
     width: 30px;
     height: 30px;
-    background-image: url("/assets/settings/sound-icon.png");
+    background-image: url("/assets/settings/sound-icon.webp");
     background-position: center;
     background-size: contain;
     background-repeat: no-repeat;

package/dist/application/SoundManager/SoundManager.js

@@ -1,7 +1,12 @@
 import { Sound, sound } from "@pixi/sound";
 import { RainMan } from "../../Rainman";
 import { SoundTracks } from "./types";
-const soundsToLoop = [SoundTracks.mysteryFxLoop, SoundTracks.music, SoundTracks.freeSpinsMusic];
+const soundsToLoop = [
+    SoundTracks.mysteryFxLoop,
+    SoundTracks.music,
+    SoundTracks.freeSpinsMusic,
+    SoundTracks.cardDrawing
+];
 export const pixiSoundContext = sound.context;
 /**
  * Class for managing sound in game, uses the pixi sound library
@@ -148,7 +153,8 @@ export class SoundManagerInstance {
         sound.play({
             singleInstance: true,
             loop: soundsToLoop.includes(soundName),
-            volume: this.getVolumeLevel(soundName)
+            volume: this.getVolumeLevel(soundName),
+            speed: soundName === "cardDrawing" ? 0.8 : 1
         });
     }
     /**

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

@@ -64,6 +64,10 @@ export interface SoundTracks {
     rouletteStop: "rouletteStop";
     mysterySymbol: "mysterySymbol";
     jackpotWin: "jackpotWin";
+    cardWin: "cardWin";
+    cardLose: "cardLose";
+    cardDrawing: "cardDrawing";
+    cardCollect: "cardCollect";
 }
 export type SoundTrack = SoundTracks[keyof SoundTracks];
 /**

package/dist/application/SoundManager/types.js

@@ -61,5 +61,9 @@ export const SoundTracks = {
     rouletteStart: "rouletteStart",
     rouletteLoop: "rouletteLoop",
     rouletteStop: "rouletteStop",
-    jackpotWin: "jackpotWin"
+    jackpotWin: "jackpotWin",
+    cardWin: "cardWin",
+    cardLose: "cardLose",
+    cardDrawing: "cardDrawing",
+    cardCollect: "cardCollect"
 };

package/dist/components/GambleGame/GambleGame.js

@@ -1,6 +1,7 @@
 import i18next from "i18next";
 import { Container, Sprite, Text, Texture } from "pixi.js";
 import { Spine } from "pixi-spine";
+import { SoundManager } from "../../application";
 import { COLOR_BUTTONS_CENTER_OFFSET, COLOR_BUTTONS_SCALE_X, gamblesTextStyle } from "../../constants";
 import { RainMan } from "../../Rainman";
 import { getDeviceOrientation, getSpineData, globalMinRatio } from "../../utils";
@@ -60,6 +61,7 @@ export class GambleGame extends Container {
         this.addChildrenOnce();
         this.bindButtonsOnce();
         this.resize();
+        SoundManager.play("cardDrawing");
     }
     configureButtons() {
         this.collectButton.eventMode = "static";
@@ -88,6 +90,7 @@ export class GambleGame extends Container {
         this.collectButton.setOnClick(() => {
             RainMan.settingsStore.gambleGameWin = this.lastWinAmount;
             RainMan.componentRegistry.get(BUTTONS.gamble).flipDisabledFlag(true);
+            SoundManager.play("cardCollect");
             this.resolver(this.balanceValue);
         });
     }
@@ -170,6 +173,8 @@ export class GambleGame extends Container {
         if (this.lastWinAmount === 0) {
             return;
         }
+        SoundManager.stop("cardDrawing");
+        this.collectButton.flipDisabledFlag(true);
         this.redButton.flipDisabledFlag(true);
         this.blackButton.flipDisabledFlag(true);
         this.card.state.addAnimation(0, "wait", true, 0);
@@ -178,6 +183,12 @@ export class GambleGame extends Container {
             this.card.state.clearTracks();
             this.card.state.clearListeners();
             this.card.state.addAnimation(0, gambleData.winning_card, false, 0);
+            if (gambleData.win_amount > 0) {
+                SoundManager.play("cardWin");
+            }
+            else {
+                SoundManager.play("cardLose");
+            }
             this.card.state.addListener({ complete: () => resolve() });
         });
         if (gambleData.win_amount > 0) {
@@ -186,6 +197,8 @@ export class GambleGame extends Container {
             this.blackButton.flipDisabledFlag(false);
             this.redButton.eventMode = "static";
             this.blackButton.eventMode = "static";
+            SoundManager.play("cardDrawing");
+            this.collectButton.flipDisabledFlag(false);
         }
         this.card.state.addAnimation(0, "wait2", true, 0);
         this.lastWinAmount = gambleData.win_amount;

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

@@ -95,6 +95,16 @@ export declare abstract class AbstractColumnsContainer extends Container impleme
      * @returns {Promise<void>}
      */
     configBlindSpin(finalSymbolReels: SymbolReels, afterSpinResolver: (value: void | PromiseLike<void>) => void, indexesOfReelsToExtendSpinningTime: number[]): Promise<void>;
+    /**
+     * This function is responsible for setting symbols in single column
+     * @public
+     * @param {SymbolReels} finalSymbolReels final symbols in columns
+     * @param {(value: void | PromiseLike<void>) => void} afterSpinResolver resolver for after spin
+     * @param {number} columnIndex index of column to configure
+     * @param {boolean} shouldExtendSpinningTime determines whether to extend spinning time for the column
+     * @returns {Promise<void>}
+     */
+    configBlindSpinForColumn(finalSymbolReels: SymbolReels, afterSpinResolver: (value: void | PromiseLike<void>) => void, columnIndex: number, shouldExtendSpinningTime?: boolean): Promise<void>;
     /**
      * This cancels the timeout, removes the stored delayed action and invalidates
      * any older timeout callback that might still try to execute later.
@@ -227,4 +237,12 @@ export declare abstract class AbstractColumnsContainer extends Container impleme
      * @returns {PlayableAction[]} - array of playable actions
      */
     protected prepareConfiguringReelsEnd(finalSymbolReels: SymbolReels): PlayableAction[];
+    /**
+     * Function for preparing configuring for single reel
+     * @protected
+     * @param {SymbolReels} finalSymbolReels - final symbol reels
+     * @param {number} columnIndex - column index
+     * @returns {PlayableAction} - playable action
+     */
+    protected prepareConfiguringReelsEndForIndex(finalSymbolReels: SymbolReels, columnIndex: number): PlayableAction;
 }

package/dist/components/frame/AbstractColumnsContainer.js

@@ -187,6 +187,63 @@ export class AbstractColumnsContainer extends Container {
             resolve();
         });
     }
+    /**
+     * This function is responsible for setting symbols in single column
+     * @public
+     * @param {SymbolReels} finalSymbolReels final symbols in columns
+     * @param {(value: void | PromiseLike<void>) => void} afterSpinResolver resolver for after spin
+     * @param {number} columnIndex index of column to configure
+     * @param {boolean} shouldExtendSpinningTime determines whether to extend spinning time for the column
+     * @returns {Promise<void>}
+     */
+    async configBlindSpinForColumn(finalSymbolReels, afterSpinResolver, columnIndex, shouldExtendSpinningTime = false) {
+        return new Promise(async (resolve) => {
+            this.clearPendingMysteryDelay();
+            this.mysteryFxGeneration = 0;
+            this.skipRemainingMysteryFxs = false;
+            const frame = RainMan.componentRegistry.get(AbstractFrame.registryName);
+            const column = this.allColumns[columnIndex];
+            if (column === undefined) {
+                afterSpinResolver();
+                resolve();
+                return;
+            }
+            const configureSpinAction = this.prepareConfiguringReelsEndForIndex(finalSymbolReels, columnIndex);
+            if (this.quickReelsStop ||
+                this.skipRemainingMysteryFxs ||
+                RainMan.settingsStore.currentSpeed === SPEED_LEVELS.fast) {
+                await configureSpinAction();
+                SoundManager.play(SoundTracks.allRollStops);
+            }
+            else if (shouldExtendSpinningTime) {
+                this.currentColumn = column;
+                column.adaptToSpeed(RainMan.settingsStore.currentSpeed);
+                frame.invokeMysteryFx(column.x, column.y);
+                this.skipScatterDelay = configureSpinAction;
+                await column.speedUpForMysterySpin(100, 1500);
+                if (this.quickReelsStop || this.skipRemainingMysteryFxs) {
+                    await column.changeVelocity(Speed.STOP, 0, frame);
+                }
+                else {
+                    if (!RainMan.settingsStore.isAutoplayEnabled ||
+                        (RainMan.settingsStore.isAutoplayEnabled && !this.quickReelsStop)) {
+                        this.scheduleMysteryDelay(configureSpinAction, RainMan.config.durationOfActions.scatterDelayerTime);
+                    }
+                    await column.changeVelocity(Speed.STOP, RainMan.config.durationOfActions.scatterSpinningTime, frame);
+                }
+                frame.destroyMysteryFx();
+            }
+            else {
+                await configureSpinAction();
+            }
+            await column.getStopPromise();
+            this.clearPendingMysteryDelay();
+            this.mysteryFxGeneration = 0;
+            this.skipRemainingMysteryFxs = false;
+            afterSpinResolver();
+            resolve();
+        });
+    }
     /**
      * This cancels the timeout, removes the stored delayed action and invalidates
      * any older timeout callback that might still try to execute later.
@@ -441,4 +498,20 @@ export class AbstractColumnsContainer extends Container {
             this.currentColumn = null;
         });
     }
+    /**
+     * Function for preparing configuring for single reel
+     * @protected
+     * @param {SymbolReels} finalSymbolReels - final symbol reels
+     * @param {number} columnIndex - column index
+     * @returns {PlayableAction} - playable action
+     */
+    prepareConfiguringReelsEndForIndex(finalSymbolReels, columnIndex) {
+        const column = this.allColumns[columnIndex];
+        return async () => {
+            this.currentColumn = column;
+            column.configBlindSpin(finalSymbolReels[columnIndex]);
+            await column.getTriggersPromise();
+            this.currentColumn = null;
+        };
+    }
 }

package/dist/controllers/AbstractController.js

@@ -322,7 +322,6 @@ export class AbstractController {
         if (RainMan.componentRegistry.has(BUTTONS.take)) {
             this.buttonsEventManager.initTakeButton(() => {
                 RainMan.settingsStore.useTakeAction?.();
-                this.uiController.currentBalance = RainMan.settingsStore.balanceAfterSpin;
                 RainMan.settingsStore.isTakeActionAvailable = false;
                 RainMan.settingsStore.isGambleGameAvailable = false;
                 if (RainMan.componentRegistry.has(BUTTONS.gamble)) {
@@ -914,6 +913,7 @@ export class AbstractController {
         if (takeData.status.code === 200) {
             RainMan.settingsStore.isTakeActionAvailable = false;
             logInfo(`💰 Round ${takeData.round_number} ended with balance:`, takeData.balance);
+            this.uiController.currentBalance = takeData.balance;
         }
         else {
             RainMan.settingsStore.isTakeActionAvailable = true;
@@ -1237,6 +1237,7 @@ export class AbstractController {
         if (this.speedLevelBeforeFreeSpins !== null &&
             !RainMan.settingsStore.isFreeSpinsPlayEnabled &&
             !RainMan.globals.isSuperBonusGameEnabled) {
+            RainMan.settingsStore.setIsTemporarySpeed(false);
             RainMan.componentRegistry.setSpeedLevel(this.speedLevelBeforeFreeSpins);
             this.uiController.updateShownSpeedLevel(this.speedLevelBeforeFreeSpins);
             this.speedLevelBeforeFreeSpins = null;

package/package.json

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