pixi-rainman-game-engine 0.1.48 → 0.1.50

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/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?.();

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,6 +106,15 @@ export class AbstractSymbolsColumn extends Container {
                 .easing(TWEEN.Easing.Linear.None)
                 .to({ velocity }, duration)
                 .start()
+                .onComplete(async () => {
+                this.tween = null;
+                if (frame) {
+                    await frame.hideMysteryFx();
+                    frame.destroyMysteryFx();
+                }
+                this.skipHidingMysteryFx = false;
+                resolve();
+            })
                 .onStop(async () => {
                 this.tween = null;
                 if (frame) {

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.d.ts

@@ -49,6 +49,7 @@ export declare abstract class AbstractController<T> {
     private componentRegistry;
     protected skipFreeSpinSummary: boolean;
     protected scatterCountForFx: number;
+    protected isLongPress: boolean;
     protected _lastWinAmount: number;
     protected constructor(buttonsEventManager: ButtonsEventManager, mainContainer: AbstractMainContainer, connection: SubscribableConnectionWrapper);
     init(): void;

package/dist/controllers/AbstractController.js

@@ -48,6 +48,7 @@ export class AbstractController {
     componentRegistry;
     skipFreeSpinSummary = false;
     scatterCountForFx = 2;
+    isLongPress = false;
     _lastWinAmount = 0;
     constructor(buttonsEventManager, mainContainer, connection) {
         this.buttonsEventManager = buttonsEventManager;
@@ -184,17 +185,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;
+            }
+            this.isLongPress = false;
         };
         refreshButton.on("touchstart", () => {
-            if (this.mobileSpinTimeout !== null)
-                return;
-            this.mobileSpinTimeout = setInterval(() => this.handleSpinLogic(), RainMan.config.durationOfActions.mobileSpinTimeout);
+            this.isLongPress = false;
+            this.mobileSpinTimeout = setInterval(() => {
+                this.isLongPress = true;
+                this.throttledSpin();
+            }, RainMan.config.durationOfActions.mobileSpinTimeout);
+        });
+        refreshButton.on("touchend", () => {
+            if (this.isLongPress) {
+                this.handleSpinLogic();
+            }
+            clearMobileSpinTimeout();
         });
-        refreshButton.on("touchend", () => clearMobileSpinTimeout());
         refreshButton.on("globaltouchmove", (event) => {
             if (event.target !== refreshButton)
                 clearMobileSpinTimeout();
@@ -437,7 +446,7 @@ export class AbstractController {
     autoplaySpin() {
         if (!RainMan.settingsStore.howManyAutoSpinsLeft)
             return;
-        if (!RainMan.settingsStore.infinitySpinsEnabled || RainMan.settingsStore.howManyAutoSpinsLeft > 0) {
+        if (!RainMan.settingsStore.infinitySpinsEnabled) {
             RainMan.settingsStore.decreaseAutoSpinsCount();
         }
         if (RainMan.settingsStore.howManyAutoSpinsLeft === 0) {
@@ -592,7 +601,7 @@ export class AbstractController {
         this.unlockLogicAfterSpinning();
         if (RainMan.settingsStore.isFreeSpinsPlayEnabled) {
             this.uiController.increaseTotalFreeSpinWinAmount(spinLogic.winTotalAmountWithoutMystery);
-            this.uiController.limitWinAmount(spinLogic.winTotalAmount);
+            this.uiController.limitWinAmount(this.uiController.totalFreeSpinWinAmount);
         }
         else {
             this.uiController.limitWinAmount(spinLogic.winTotalAmount);
@@ -713,12 +722,10 @@ export class AbstractController {
             return;
         const amount = customAmount || this.uiController.recentWin;
         this.mainContainer.invokeBigWin();
-        this.changeGamePhase(gamePhases.BIG_WIN_INVOKED);
         const animationTimeDivider = RainMan.settingsStore.currentSpeed === SPEED_LEVELS.fast ? 3 : 1;
         await RainMan.componentRegistry
             .get(COMPONENTS.bigWin)
             .update(amount, RainMan.config.durationOfActions.updatableTextCountingDuration / animationTimeDivider);
-        this.changeGamePhase(gamePhases.STOPPING_HANDLING_ACTIONS);
         await new Promise((resolve) => {
             this.resolveBigWin = resolve;
             setTimeout(() => {
@@ -727,7 +734,6 @@ export class AbstractController {
                 this.mainContainer.destroyBigWin();
                 this.resolveBigWin();
                 this.resolveBigWin = undefined;
-                this.changeGamePhase(gamePhases.IDLE);
             }, RainMan.config.durationOfActions.bigWinPhaseTimeout / animationTimeDivider);
         });
     }
@@ -736,12 +742,10 @@ export class AbstractController {
             return;
         const amount = winAmount || this.uiController.recentWin;
         this.mainContainer.invokeBonusWin();
-        this.changeGamePhase(gamePhases.BONUS_WIN_INVOKED);
         const animationTimeDivider = RainMan.settingsStore.currentSpeed === SPEED_LEVELS.fast ? 3 : 1;
         await RainMan.componentRegistry
             .get(COMPONENTS.bonusWin)
             .update(amount, RainMan.config.durationOfActions.updatableTextCountingDuration / animationTimeDivider);
-        this.changeGamePhase(gamePhases.STOPPING_HANDLING_ACTIONS);
         await new Promise((resolve) => {
             this.resolveBonusWin = resolve;
             setTimeout(() => {
@@ -750,7 +754,6 @@ export class AbstractController {
                 this.mainContainer.destroyBonusWin();
                 this.resolveBonusWin();
                 this.resolveBonusWin = undefined;
-                this.changeGamePhase(gamePhases.IDLE);
             }, RainMan.config.durationOfActions.bonusWinPhaseTimeout / animationTimeDivider);
         });
     }
@@ -759,12 +762,10 @@ export class AbstractController {
             return;
         const amount = winAmount || RainMan.settingsStore.cumulativeWinAmount;
         this.mainContainer.invokeSuperBonusWin();
-        this.changeGamePhase(gamePhases.SUPER_BONUS_WIN_INVOKED);
         const animationTimeDivider = RainMan.settingsStore.currentSpeed === SPEED_LEVELS.fast ? 3 : 1;
         await RainMan.componentRegistry
             .get(COMPONENTS.superBonusWin)
             .update(amount, RainMan.config.durationOfActions.updatableTextCountingDuration / animationTimeDivider);
-        this.changeGamePhase(gamePhases.STOPPING_HANDLING_ACTIONS);
         await new Promise((resolve) => {
             this.resolveSuperBonusWin = resolve;
             setTimeout(() => {
@@ -773,7 +774,6 @@ export class AbstractController {
                 this.mainContainer.destroySuperBonusWin();
                 this.resolveSuperBonusWin();
                 this.resolveSuperBonusWin = undefined;
-                this.changeGamePhase(gamePhases.IDLE);
             }, RainMan.config.durationOfActions.superBonusWinPhaseTimeout / animationTimeDivider);
         });
     }
@@ -786,10 +786,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(() => {

package/package.json

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