pixi-rainman-game-engine 0.1.49 → 0.1.51

package/dist/Rainman/appConfig.js

@@ -35,9 +35,9 @@ export const defaultAppConfig = {
         freeSpinPlateVisibleTime: 2000,
         freeSpinSummaryVisibleTime: 2000,
         updatableTextCountingDuration: 500,
-        scatterDelayerTime: 2000,
-        scatterSpinningTime: 9200,
-        mobileSpinTimeout: 300,
+        mobileSpinTimeout: 100,
+        scatterDelayerTime: 1000,
+        scatterSpinningTime: 1200,
         mysteryWinMinimumTime: 2000,
         bigWinMinimumTime: 2000,
         bigWinPhaseTimeout: 2800,

package/dist/SettingsUI/components/SpeedSettingsPopup/speedSettingsPopup.css

@@ -40,6 +40,15 @@
     height: 78px;
     background-repeat: no-repeat no-repeat;
     background-size: contain;
+    cursor: pointer;
+}
+
+.speed-settings-popup__option:hover {
+    background-image: url("/assets/settings/speedPopup/speed-frame-active.png");
+    width: 145px;
+    height: 78px;
+    background-repeat: no-repeat no-repeat;
+    background-size: contain;
 }
 
 .speed-settings-popup_option--active {
@@ -101,6 +110,25 @@
     }
 }
 
+@media screen and (max-width: 450px) and (pointer: coarse) {
+    .speed-settings-popup__option {
+        width: 120px;
+        height: 66px;
+    }
+
+    .speed-settings-popup__option:hover {
+        background-image: url("/assets/settings/speedPopup/speed-frame-active.png");
+        background-repeat: no-repeat no-repeat;
+        background-size: contain;
+    }
+
+    .speed-settings-popup__option:focus {
+        background-image: url("/assets/settings/speedPopup/speed-frame-active.png");
+        background-repeat: no-repeat no-repeat;
+        background-size: contain;
+    }
+}
+
 @media only screen and (max-height: 450px) {
     .speed-settings-modal {
         width: 80vw;

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

@@ -14,8 +14,8 @@ const onChange = (newVolumeLevel) => {
 };
 const onAfterChange = (newVolumeLevel) => {
     RainMan.settingsStore.flipSoundsEnabled(newVolumeLevel);
-    if (RainMan.settingsStore.ambientMusicFlag) {
-        SoundManager.play("music");
+    if (RainMan.settingsStore.isSoundEnabled()) {
+        SoundManager.resumeAll();
     }
 };
 export const VolumeSettings = observer(() => {

package/dist/application/ButtonsEventManager/ButtonsEventManager.js

@@ -1,6 +1,6 @@
 import i18n from "i18next";
 import { sample } from "lodash";
-import { SoundManager, SoundTracks } from "../../application";
+import { SoundManager } from "../../application";
 import { AutoplayButton, Background, BUTTONS, COMPONENTS, FreeSpinButton, MessageBox, SpeedControlButton, VolumeButton, } from "../../components";
 import { RainMan } from "../../Rainman";
 import { allUiItems, hideLayerIfPresent, UI_ITEMS } from "../../utils";
@@ -193,9 +193,8 @@ export class ButtonsEventManager {
         RainMan.settingsStore.setUpdateVolumeButtonTexture(() => RainMan.componentRegistry.get(VolumeButton.registryName).changeTextureDependOnVolume());
         RainMan.componentRegistry.get(VolumeButton.registryName).setOnClick(() => {
             RainMan.settingsStore.flipSoundsEnabled();
-            if (RainMan.settingsStore.ambientMusicFlag && RainMan.settingsStore.isSoundEnabled()) {
-                SoundManager.resume(SoundTracks.music);
-            }
+            if (RainMan.settingsStore.isSoundEnabled())
+                SoundManager.resumeAll();
             RainMan.componentRegistry.get(VolumeButton.registryName).changeTextureDependOnVolume();
             this.handleModalInvocation(UI_ITEMS.volume);
         });

package/dist/application/SoundManager/SoundManager.js

@@ -103,7 +103,7 @@ export class SoundManagerInstance {
         this.musicCatalogue.forEach((sound, soundName) => {
             if (sound.paused && sound.isPlaying)
                 sound.resume();
-            if (soundName === SoundTracks.music && sound.paused) {
+            if (RainMan.settingsStore.ambientMusicFlag && soundName === SoundTracks.music && sound.paused) {
                 sound.resume();
             }
         });

package/dist/components/AbstractMainContainer/AbstractMainContainer.js

@@ -56,8 +56,8 @@ export class AbstractMainContainer extends Container {
         this.name = AbstractMainContainer.registryName;
         this.buttonsEventManager = new ButtonsEventManager();
         this.messageBox = new MessageBox();
-        if (RainMan.settingsStore.ambientMusicFlag)
-            SoundManager.setPlayStatus(SoundTracks.music, true);
+        if (RainMan.settingsStore.isSoundEnabled())
+            SoundManager.resumeAll();
         RainMan.app.renderer.on("resize", () => this.resize());
     }
     /**
@@ -193,6 +193,7 @@ export class AbstractMainContainer extends Container {
         this.overlay.drawRect(0, 0, width, height);
         this.overlay.eventMode = "static";
         this.overlay.endFill();
+        this.overlay.interactive = true;
         this.addChild(this.overlay);
     }
     hideOverlay() {

package/dist/components/frame/AbstractColumnsContainer.js

@@ -83,10 +83,15 @@ export class AbstractColumnsContainer extends Container {
                     break;
                 }
                 const configureSpinAction = configuredBlindSpinsActions.shift();
+                indexesOfReelsToExtendSpinningTime.forEach((number) => {
+                    this.allColumns[number].changeMultiplier();
+                });
                 if (configureSpinAction !== undefined) {
                     if (indexesOfReelsToExtendSpinningTime.includes(index)) {
                         this.currentColumn = this.allColumns[index];
+                        this.currentColumn.adaptToSpeed(RainMan.settingsStore.currentSpeed);
                         frame.invokeMysteryFx(this.currentColumn.x, this.currentColumn.y);
+                        await this.currentColumn.speedUpForMysterySpin(100, 1500);
                         this.skipScatterDelay = configureSpinAction;
                         setTimeout(() => {
                             this.skipScatterDelay?.();
@@ -134,11 +139,11 @@ export class AbstractColumnsContainer extends Container {
             return;
         }
         if (amount > WIN_MULTIPLIER_VALUES.MEDIUM_WIN_MIN * bet &&
-            amount < WIN_MULTIPLIER_VALUES.MEDIUM_WIN_MAX * bet) {
+            amount <= WIN_MULTIPLIER_VALUES.MEDIUM_WIN_MAX * bet) {
             SoundManager.play(SoundTracks.mediumWin);
             return;
         }
-        if (amount > WIN_MULTIPLIER_VALUES.HIGH_WIN_MIN * bet && amount < WIN_MULTIPLIER_VALUES.HIGH_WIN_MAX * bet) {
+        if (amount > WIN_MULTIPLIER_VALUES.HIGH_WIN_MIN * bet && amount <= WIN_MULTIPLIER_VALUES.HIGH_WIN_MAX * bet) {
             SoundManager.play(SoundTracks.highWin);
             return;
         }

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

@@ -37,7 +37,7 @@ export declare abstract class AbstractFrame extends ResumableContainer implement
     adaptToSpeed(speedLevel: SpeedLevel): void;
     invokeMysteryFx(x: number, y: number): void;
     protected repositionMysteryFx(_x: number, _y: number): void;
-    hideMysteryFx(): Promise<void>;
+    hideMysteryFx(): void;
     private resetMysteryFxCoordinates;
     destroyMysteryFx(): void;
     protected createWinLineAnimation(_animationName: string): WinLineAnimation | null;

package/dist/components/frame/AbstractFrame.js

@@ -54,31 +54,25 @@ export class AbstractFrame extends ResumableContainer {
         this.addChild(this.mysteryFxHighlight);
     }
     repositionMysteryFx(_x, _y) { }
-    async hideMysteryFx() {
-        return new Promise((resolve) => {
-            if (!this.mysteryFxConfig)
-                return resolve();
-            if (!this.mysteryFxConfig.endAnimationName) {
-                this.destroyMysteryFx();
-                return resolve();
-            }
-            if (this.mysteryFxHighlight) {
-                SoundManager.stop(SoundTracks.mysteryFxLoop);
-                SoundManager.play(SoundTracks.mysteryFxEnd);
-                this.resetMysteryFxCoordinates();
-                this.mysteryFxHighlight.state.setAnimation(0, this.mysteryFxConfig.endAnimationName, false);
-                this.mysteryFxHighlight.state.addListener({
-                    complete: () => resolve(),
-                });
-            }
-        });
+    hideMysteryFx() {
+        if (!this.mysteryFxConfig)
+            return;
+        if (!this.mysteryFxConfig.endAnimationName) {
+            return;
+        }
+        if (this.mysteryFxHighlight) {
+            SoundManager.play(SoundTracks.mysteryFxEnd);
+            this.resetMysteryFxCoordinates();
+            this.mysteryFxHighlight.state.setAnimation(0, this.mysteryFxConfig.endAnimationName, false);
+            return;
+        }
     }
     resetMysteryFxCoordinates() {
         this.mysteryFxCoordinates = { x: 0, y: 0 };
     }
     destroyMysteryFx() {
         if (this.mysteryFxHighlight) {
-            SoundManager.pause(SoundTracks.mysteryFxLoop);
+            SoundManager.stop(SoundTracks.mysteryFxLoop);
             this.removeChild(this.mysteryFxHighlight);
             this.mysteryFxHighlight.destroy();
             this.mysteryFxHighlight = null;

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

@@ -51,6 +51,8 @@ export declare abstract class AbstractSymbolsColumn extends Container implements
     get id(): string;
     protected get componentsTimingSettings(): AnimationTimeSettings;
     adaptToSpeed(speedLevel: SpeedLevel): void;
+    changeMultiplier(): void;
+    speedUpForMysterySpin(velocity: number, duration: number): Promise<void>;
     changeVelocity(velocity: number, duration: number, frame?: AbstractFrame): Promise<void>;
     protected animateDependentComponents(_distance: number): void;
     animate(delta: number, lastTime: number): void;

package/dist/components/symbols/AbstractSymbolsColumn.js

@@ -79,6 +79,24 @@ export class AbstractSymbolsColumn extends Container {
         this.velocityMultiplier = this.speedLevelMapper[speedLevel];
         this.symbols.forEach((symbol) => symbol.updateTimeScaleOfSpine(this.velocityMultiplier));
     }
+    changeMultiplier() {
+        this.velocityMultiplier = 3.5;
+    }
+    async speedUpForMysterySpin(velocity, duration) {
+        await new Promise((resolve) => {
+            this.tween = new TWEEN.Tween({ velocity: velocity })
+                .to({ value: 70 }, duration)
+                .easing(TWEEN.Easing.Linear.None)
+                .onUpdate((value) => {
+                this.velocity = value.velocity;
+            })
+                .onComplete(() => {
+                this.tween = null;
+                resolve();
+            })
+                .start();
+        });
+    }
     async changeVelocity(velocity, duration, frame) {
         await new Promise((resolve) => {
             this.tween = new TWEEN.Tween({ velocity: velocity })
@@ -88,10 +106,19 @@ export class AbstractSymbolsColumn extends Container {
                 .easing(TWEEN.Easing.Linear.None)
                 .to({ velocity }, duration)
                 .start()
+                .onComplete(async () => {
+                this.tween = null;
+                if (frame) {
+                    frame.hideMysteryFx();
+                    frame.destroyMysteryFx();
+                }
+                this.skipHidingMysteryFx = false;
+                resolve();
+            })
                 .onStop(async () => {
                 this.tween = null;
                 if (frame) {
-                    await frame.hideMysteryFx();
+                    frame.hideMysteryFx();
                     frame.destroyMysteryFx();
                 }
                 this.skipHidingMysteryFx = false;

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

@@ -17,8 +17,8 @@ export declare class DroppableSymbolsColumn {
     get symbolsToBeDestroyed(): DroppableSymbol[];
     get allSymbolsToBeMovedDown(): DroppableSymbol[];
     setSymbolsToBeDestroyed(rowIndex: number, replacementSymbol: SymbolId): void;
-    playAnimations(): Promise<void[]>;
-    destroyAnimations(isStandalone: boolean): Promise<void[]>;
+    playAnimations(): Promise<PromiseSettledResult<void>[]>;
+    destroyAnimations(isStandalone: boolean): Promise<PromiseSettledResult<void>[]>;
     moveDestroyedSymbolsToTop(tileHeight: number): void;
     swapDestroyedSymbols(): void;
     /**

package/dist/components/symbols/DroppableSymbolsColumn.js

@@ -34,7 +34,7 @@ export class DroppableSymbolsColumn {
         this.sortableSymbols[rowIndex].referencedYInColumn = rowIndex;
     }
     async playAnimations() {
-        return await Promise.all(this.symbolsToBeDestroyed.map((symbol) => symbol.symbol.play()));
+        return await Promise.allSettled(this.symbolsToBeDestroyed.map((symbol) => symbol.symbol.play()));
     }
     async destroyAnimations(isStandalone) {
         const destroyedSymbols = [];
@@ -43,7 +43,7 @@ export class DroppableSymbolsColumn {
                 destroyedSymbols.push(symbol.symbol.handlePopSymbol(isStandalone));
             this._numberToBeDropped++;
         });
-        return await Promise.all(destroyedSymbols);
+        return await Promise.allSettled(destroyedSymbols);
     }
     moveDestroyedSymbolsToTop(tileHeight) {
         this.symbolsToBeDestroyed.forEach((symbols, index) => {

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

@@ -8,7 +8,7 @@ export interface AnimationTimeSettings {
 }
 export declare enum Speed {
     FAST = 70,
-    STOP = 15
+    STOP = 65
 }
 /**
  * Enum that describes the phase of columns

package/dist/components/symbols/types.js

@@ -1,7 +1,7 @@
 export var Speed;
 (function (Speed) {
     Speed[Speed["FAST"] = 70] = "FAST";
-    Speed[Speed["STOP"] = 15] = "STOP";
+    Speed[Speed["STOP"] = 65] = "STOP";
 })(Speed || (Speed = {}));
 /**
  * Enum that describes the phase of columns

package/dist/controllers/AbstractController.js

@@ -184,17 +184,25 @@ export class AbstractController {
         const refreshButton = RainMan.componentRegistry.get(RefreshButton.registryName);
         refreshButton.setOnClick(() => this.handleSpinLogic());
         const clearMobileSpinTimeout = () => {
-            if (!this.mobileSpinTimeout)
-                return;
-            clearInterval(this.mobileSpinTimeout);
-            this.mobileSpinTimeout = null;
+            if (this.mobileSpinTimeout) {
+                clearInterval(this.mobileSpinTimeout);
+                this.mobileSpinTimeout = null;
+            }
         };
         refreshButton.on("touchstart", () => {
-            if (this.mobileSpinTimeout !== null)
-                return;
-            this.mobileSpinTimeout = setInterval(() => this.handleSpinLogic(), RainMan.config.durationOfActions.mobileSpinTimeout);
+            this.mobileSpinTimeout = setInterval(() => {
+                if (this.invokeFreeSpinPlateAfterWin ||
+                    this.invokeFreeSpinSummaryPlateAfterWin ||
+                    this.resolveBigWin !== undefined) {
+                    clearMobileSpinTimeout();
+                    return;
+                }
+                this.handleSpinLogic();
+            }, RainMan.config.durationOfActions.mobileSpinTimeout);
+        });
+        refreshButton.on("touchend", () => {
+            clearMobileSpinTimeout();
         });
-        refreshButton.on("touchend", () => clearMobileSpinTimeout());
         refreshButton.on("globaltouchmove", (event) => {
             if (event.target !== refreshButton)
                 clearMobileSpinTimeout();
@@ -777,10 +785,12 @@ export class AbstractController {
             .get(COMPONENTS.mysteryWin)
             .randomizeSet(winAmount, RainMan.settingsStore.getMysteryPaytable(this.mysteryWinSymbol, quantity));
         SoundManager.pause(SoundTracks.mysteryDrawLoop);
+        if (RainMan.settingsStore.isFreeSpinsPlayEnabled) {
+            this.uiController.limitWinAmount(this.uiController.totalFreeSpinWinAmount + winAmount);
+            this.uiController.increaseTotalFreeSpinWinAmount(winAmount);
+        }
         this.updateUiValues(winAmount);
         this._lastWinAmount += winAmount;
-        if (RainMan.settingsStore.isFreeSpinsPlayEnabled)
-            this.uiController.increaseTotalFreeSpinWinAmount(winAmount);
         await new Promise((resolve) => {
             this.resolveMysteryWin = resolve;
             setTimeout(() => {
@@ -834,7 +844,7 @@ export class AbstractController {
         }
     }
     async handleLoopingWinActionQueue() {
-        if (RainMan.settingsStore.isAutoplayEnabled)
+        if (RainMan.settingsStore.isAutoplayEnabled || this.invokeFreeSpinPlateAfterWin)
             return;
         this.isLoopingWinActionsQueue = true;
         await this.loopWinActionsQueue();

package/package.json

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