pixi-rainman-game-engine 0.1.47 → 0.1.48

package/dist/ComponentRegistry/ComponentRegistry.js

@@ -1,4 +1,4 @@
-import { isIncentiveComponentInterface, isSpeedAdapterInterface, SPEED_LEVELS, SpeedLevelHandler, TimedIncentiveController, } from "../application";
+import { isIncentiveComponentInterface, isSpeedAdapterInterface, SpeedLevelHandler, TimedIncentiveController, } from "../application";
 import { SpeedControlButton } from "../components";
 import { RainMan } from "../Rainman";
 import { openFullscreen } from "../utils";
@@ -58,9 +58,6 @@ export class ComponentRegistry {
      */
     nextSpeedLevel() {
         this.speedLevelHandler.nextSpeed();
-        if (this.speedLevelHandler.currentSpeed !== SPEED_LEVELS.slow) {
-            RainMan.globals.disableSpeedPopup?.(false);
-        }
         RainMan.settingsStore.setSpeedLevel(this.speedLevelHandler.currentSpeed);
         this.updateAllSpeedAdaptable(RainMan.settingsStore.currentSpeed);
         this.get(SpeedControlButton.registryName).forceTextureUpdate();

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

@@ -10,7 +10,7 @@ import { CloseModalButton } from "../CloseModalButton";
 import { RichLimitingSlider } from "../RichLimitingSlider";
 import { SpeedButtonWithHeader, SwitchWithHeader } from "../SwitchWithHeader";
 export const AutoplaySettings = observer(() => {
-    const [limit_numbers, setLimitNumbers] = useState([0]);
+    const [limitNumbers, setLimitNumbers] = useState([0]);
     const initialAutoSpinCount = 50;
     const availableAutoSpinLimits = [10, 20, 50, 100, 150, 200, 250, 300, 350, 400, 500, 600, 700, 800, 900, 1000];
     const { settingStore } = useStores();
@@ -66,7 +66,7 @@ export const AutoplaySettings = observer(() => {
         }}>
                     <p>-</p>
                 </button>
-                {limit_numbers.map((limiter, index) => (<button key={`${limiter}${index}`} value={limiter} className={`autoplay-settings__limit ${limiter === howManyAutoSpinsLeft ? "autoplay-settings__limit--active" : ""} middle ${infinitySpinsEnabled ? "autoplay-settings__limit--infinity" : ""}`} disabled={settingStore.infinitySpinsEnabled} onClick={(event) => updateLimitsBounds(Number(event.currentTarget.value))}>
+                {limitNumbers.map((limiter, index) => (<button key={`${limiter}${index}`} value={limiter} className={`autoplay-settings__limit ${limiter === howManyAutoSpinsLeft ? "autoplay-settings__limit--active" : ""} middle ${infinitySpinsEnabled ? "autoplay-settings__limit--infinity" : ""}`} disabled={settingStore.infinitySpinsEnabled} onClick={(event) => updateLimitsBounds(Number(event.currentTarget.value))}>
                         <p>{limiter}</p>
                     </button>))}
                 <button className={`autoplay-settings__limit right ${infinitySpinsEnabled ? "autoplay-settings__limit--infinity" : ""}`} onClick={() => {
@@ -110,7 +110,7 @@ export const AutoplaySettings = observer(() => {
         }}>
                     <p>{i18next.t("cancel")}</p>
                 </button>
-                <button id={COMPONENTS.autoSpinConfirm} className="autoplay-settings__confirmation-button">
+                <button id={COMPONENTS.autoSpinConfirm} onClick={() => settingStore.decreaseAutoSpinsCount()} className="autoplay-settings__confirmation-button">
                     <p>{i18next.t("confirm")}</p>
                 </button>
             </div>

package/dist/application/ButtonsEventManager/ButtonsEventManager.d.ts

@@ -82,6 +82,8 @@ export declare class ButtonsEventManager {
     initFreeSpinModal(): void;
     /**
      * Method for initializing volume button
+     * This method changes texture of Volume button based on volume level
+     * If music was muted, it will be resumed
      *
      * @public
      */

package/dist/application/ButtonsEventManager/ButtonsEventManager.js

@@ -1,5 +1,6 @@
 import i18n from "i18next";
 import { sample } from "lodash";
+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 } from "../../utils";
@@ -74,6 +75,10 @@ export class ButtonsEventManager {
                     if (this.settingsSpeedButton) {
                         this.settingsSpeedButton.addEventListener("click", () => {
                             RainMan.componentRegistry.nextSpeedLevel();
+                            if (RainMan.settingsStore.currentSpeed === SPEED_LEVELS.fast ||
+                                RainMan.settingsStore.currentSpeed === SPEED_LEVELS.normal) {
+                                RainMan.globals.disableSpeedPopup?.(true);
+                            }
                             messageBox.updateIncentiveText(sample(i18n.t("idleMessages", { returnObjects: true })[RainMan.componentRegistry.getSpeedLevel()]));
                         });
                     }
@@ -179,6 +184,8 @@ export class ButtonsEventManager {
     }
     /**
      * Method for initializing volume button
+     * This method changes texture of Volume button based on volume level
+     * If music was muted, it will be resumed
      *
      * @public
      */
@@ -186,6 +193,9 @@ 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);
+            }
             RainMan.componentRegistry.get(VolumeButton.registryName).changeTextureDependOnVolume();
             this.handleModalInvocation(UI_ITEMS.volume);
         });

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

@@ -61,11 +61,23 @@ export declare class SoundManagerInstance implements SpeedAdapterInterface<Sound
      * @param {SoundTrack} soundName
      */
     pause(soundName: SoundTrack): void;
+    /**
+     * Function for resuming sound with given name
+     *
+     * @param {SoundTrack} soundName
+     */
+    resume(soundName: SoundTrack): void;
     /**
      * Function for adapting sound into the speed of animations
      *
      * @param {SpeedLevel} speedLevel
      */
     adaptToSpeed(speedLevel: SpeedLevel): void;
+    /**
+     * Function for stopping sound with given name
+     *
+     * @param {SoundTrack} soundName - name of the sound
+     */
+    stop(soundName: SoundTrack): void;
 }
 export declare const SoundManager: SoundManagerInstance;

package/dist/application/SoundManager/SoundManager.js

@@ -123,6 +123,14 @@ export class SoundManagerInstance {
     pause(soundName) {
         this.musicCatalogue.get(soundName)?.pause();
     }
+    /**
+     * Function for resuming sound with given name
+     *
+     * @param {SoundTrack} soundName
+     */
+    resume(soundName) {
+        this.musicCatalogue.get(soundName)?.resume();
+    }
     /**
      * Function for adapting sound into the speed of animations
      *
@@ -131,5 +139,13 @@ export class SoundManagerInstance {
     adaptToSpeed(speedLevel) {
         this.overrides = this.speedLevelMapper[speedLevel];
     }
+    /**
+     * Function for stopping sound with given name
+     *
+     * @param {SoundTrack} soundName - name of the sound
+     */
+    stop(soundName) {
+        this.musicCatalogue.get(soundName)?.stop();
+    }
 }
 export const SoundManager = SoundManagerInstance.getInstance();

package/dist/application/SpeedState/SpeedLevelHandler.d.ts

@@ -25,7 +25,6 @@ export declare class SpeedLevelHandler {
      * Setter for speed level
      *
      * @param newSpeedLevel
-     * @returns
      */
     setSpeed(newSpeedLevel: SpeedLevel): void;
     /**

package/dist/application/SpeedState/SpeedLevelHandler.js

@@ -34,7 +34,6 @@ export class SpeedLevelHandler {
      * Setter for speed level
      *
      * @param newSpeedLevel
-     * @returns
      */
     setSpeed(newSpeedLevel) {
         switch (newSpeedLevel) {

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

@@ -48,9 +48,9 @@ export declare abstract class AbstractColumnsContainer extends Container impleme
      * @returns {Promise<void>}
      */
     configBlindSpin(finalSymbolReels: SymbolReels, afterSpinResolver: (value: void | PromiseLike<void>) => void, indexesOfReelsToExtendSpinningTime: number[]): Promise<void>;
-    playAllStreaks(streaks: StreakReelsIndexes[], amount: number): Promise<void>;
+    playAllStreaks(streaks: StreakReelsIndexes[], amount: number, allSymbols?: SymbolId[]): Promise<void>;
     resetPlayedSounds(): void;
-    protected playSoundDependingOnAmount(amount: number): void;
+    protected playSoundDependingOnAmount(amount: number, _allSymbols?: SymbolId[]): void;
     protected playStreakSound(symbols: SymbolId[]): void;
     /**
      * Function for playing animation of streak
@@ -68,6 +68,7 @@ export declare abstract class AbstractColumnsContainer extends Container impleme
     animate(delta: number): void;
     abstract getColumnAtPosition(column: number): AbstractSymbolsColumn;
     stopPlayingSymbolsInColumns(): void;
+    stopPlayingSymbolsTransformationInColumns(): void;
     setInteractivityForSymbols(flag: boolean): void;
     handleDestroyTransformations(transformations: DropTransformationDetails[], skipAnimations?: boolean, isStandalone?: boolean, allowSoundInSymbolsColumn?: boolean): Promise<void>;
     protected createMask(): Graphics;

package/dist/components/frame/AbstractColumnsContainer.js

@@ -105,7 +105,7 @@ export class AbstractColumnsContainer extends Container {
             resolve();
         });
     }
-    async playAllStreaks(streaks, amount) {
+    async playAllStreaks(streaks, amount, allSymbols = []) {
         const columnsToPlay = [];
         streaks.forEach((streak) => {
             streak.forEach((symbolIndex, index) => {
@@ -121,13 +121,13 @@ export class AbstractColumnsContainer extends Container {
         columnsToPlay.forEach((column, index) => {
             column.forEach((symbolIndex) => promises.push(this.getColumnAtPosition(index).playSymbolAtPosition(symbolIndex, true)));
         });
-        this.playSoundDependingOnAmount(amount);
+        this.playSoundDependingOnAmount(amount, allSymbols);
         await Promise.allSettled(promises);
     }
     resetPlayedSounds() {
         this.playedSounds = [];
     }
-    playSoundDependingOnAmount(amount) {
+    playSoundDependingOnAmount(amount, _allSymbols = []) {
         const bet = RainMan.settingsStore.bet;
         if (amount < WIN_MULTIPLIER_VALUES.LOW_WIN * bet) {
             SoundManager.play(SoundTracks.lowWin);
@@ -202,6 +202,9 @@ export class AbstractColumnsContainer extends Container {
     stopPlayingSymbolsInColumns() {
         this.allColumns.forEach((column) => column.stopAllPlayingSymbols());
     }
+    stopPlayingSymbolsTransformationInColumns() {
+        this.allColumns.forEach((column) => column.stopTransformationPlayingSymbols());
+    }
     setInteractivityForSymbols(flag) {
         this.allColumns.forEach((column) => column.setAllSymbolsInteractiveFlag(flag));
     }

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

@@ -4,6 +4,7 @@ import { Nullable } from "../../utils";
 import { ResumableContainer } from "../common";
 import { AbstractColumnsContainer } from "./AbstractColumnsContainer";
 import { AbstractInnerFrame } from "./AbstractInnerFrame";
+import { MysteryFxCoordinates } from "./types";
 import { WinLineAnimation } from "./WinLineAnimation";
 /**
  * This class is representing all of elements in center frame like Columns Container, frame animation
@@ -30,12 +31,14 @@ export declare abstract class AbstractFrame extends ResumableContainer implement
     }>;
     protected abstract innerFrame: AbstractInnerFrame;
     protected winLineAnimations: WinLineAnimation[];
+    protected mysteryFxCoordinates: MysteryFxCoordinates;
     protected constructor(spineName: string);
     get columnsContainer(): AbstractColumnsContainer;
     adaptToSpeed(speedLevel: SpeedLevel): void;
     invokeMysteryFx(x: number, y: number): void;
     protected repositionMysteryFx(_x: number, _y: number): void;
     hideMysteryFx(): Promise<void>;
+    private resetMysteryFxCoordinates;
     destroyMysteryFx(): void;
     protected createWinLineAnimation(_animationName: string): WinLineAnimation | null;
     playAllWinLineAnimations(animationNames: string[]): Promise<void>;

package/dist/components/frame/AbstractFrame.js

@@ -22,6 +22,7 @@ export class AbstractFrame extends ResumableContainer {
     mysteryFxHighlight = null;
     mysteryFxConfig = null;
     winLineAnimations = [];
+    mysteryFxCoordinates = { x: 0, y: 0 };
     constructor(spineName) {
         super();
         this.name = AbstractFrame.registryName;
@@ -37,17 +38,20 @@ export class AbstractFrame extends ResumableContainer {
     invokeMysteryFx(x, y) {
         if (!this.mysteryFxConfig)
             return;
+        if (this.mysteryFxHighlight)
+            this.removeChild(this.mysteryFxHighlight);
+        this.mysteryFxCoordinates = { x, y };
         const spineName = this.mysteryFxConfig.mobileSpineName && getDeviceOrientation() === "mobile-portrait"
             ? this.mysteryFxConfig.mobileSpineName
             : this.mysteryFxConfig.spineName;
         this.mysteryFxHighlight = new Spine(getSpineData(spineName));
         this.repositionMysteryFx(x, y);
-        this.addChild(this.mysteryFxHighlight);
         SoundManager.play(SoundTracks.mysteryFxLoop);
         this.mysteryFxHighlight.state.setAnimation(0, this.mysteryFxConfig.startAnimationName || this.mysteryFxConfig.loopAnimationName, false);
         this.mysteryFxHighlight.state.addListener({
             complete: () => this.mysteryFxHighlight?.state.setAnimation(0, this.mysteryFxConfig.loopAnimationName, true),
         });
+        this.addChild(this.mysteryFxHighlight);
     }
     repositionMysteryFx(_x, _y) { }
     async hideMysteryFx() {
@@ -59,8 +63,9 @@ export class AbstractFrame extends ResumableContainer {
                 return resolve();
             }
             if (this.mysteryFxHighlight) {
-                SoundManager.pause(SoundTracks.mysteryFxLoop);
+                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(),
@@ -68,6 +73,9 @@ export class AbstractFrame extends ResumableContainer {
             }
         });
     }
+    resetMysteryFxCoordinates() {
+        this.mysteryFxCoordinates = { x: 0, y: 0 };
+    }
     destroyMysteryFx() {
         if (this.mysteryFxHighlight) {
             SoundManager.pause(SoundTracks.mysteryFxLoop);
@@ -80,12 +88,12 @@ export class AbstractFrame extends ResumableContainer {
         return null;
     }
     async playAllWinLineAnimations(animationNames) {
-        await Promise.all(animationNames.map((animationName) => this.playWinLineAnimation(animationName)));
+        await Promise.allSettled(animationNames.map((animationName) => this.playWinLineAnimation(animationName)));
     }
     async playWinLineAnimation(animationName) {
         const winLineAnimation = this.createWinLineAnimation(animationName);
         if (winLineAnimation === null) {
-            logError(`Function createWinLineAnimation in Frame is not implemented`);
+            logError("Function createWinLineAnimation in Frame is not implemented!");
             return;
         }
         this.winLineAnimations.push(winLineAnimation);
@@ -112,6 +120,8 @@ export class AbstractFrame extends ResumableContainer {
         this.addChild(this.innerFrame);
     }
     resize() {
+        if (this.mysteryFxHighlight)
+            this.removeChild(this.mysteryFxHighlight);
         this.changeFrameForOrientation();
         const expectedScreenDimensions = {
             width: this.transformedWidth(),
@@ -122,6 +132,7 @@ export class AbstractFrame extends ResumableContainer {
         this.height = dimensions.height;
         this.width = dimensions.width;
         this.addChild(this.innerFrame);
+        this.repositionMysteryFx(this.mysteryFxCoordinates.x, this.mysteryFxCoordinates.y);
         if (this.mysteryFxHighlight)
             this.addChild(this.mysteryFxHighlight);
         this.winLineAnimations.forEach((winLineAnimation) => this.addChild(winLineAnimation));

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

@@ -0,0 +1,4 @@
+export type MysteryFxCoordinates = {
+    x: number;
+    y: number;
+};

package/dist/components/frame/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -18,6 +18,7 @@ export declare abstract class AbstractSymbolBase extends Container {
     protected animationSpeedMultiplier: number;
     private endOfMultiplierAnimationPromise;
     protected endOfSymbolAnimationPromise: ((value: void | PromiseLike<void>) => void) | undefined;
+    protected endOfSwapAnimationPromise: ((value: void | PromiseLike<void>) => void) | undefined;
     protected popSymbolAnimationPromise: ((value: void | PromiseLike<void>) => void) | undefined;
     protected abstract paytableIgnoredSymbols: SymbolId[];
     private _id;
@@ -25,6 +26,9 @@ export declare abstract class AbstractSymbolBase extends Container {
     get id(): SymbolId;
     setInteractiveFlag(flag: boolean): void;
     updateTimeScaleOfSpine(scale?: number): void;
+    protected changeSpecialFaceForSymbol(symbolId: SymbolId): string;
+    swapSymbolsToSpecials(symbolId: SymbolId, specialResourceName: string, spineScale: number): () => Promise<void>;
+    protected animateForSpecialSwap(animationName: string, specialResourceName: string, symbolId: SymbolId, spineScale: number): () => Promise<void>;
     switchSymbolBaseDisplayedObject(option: "sprite" | "spine", suffix?: string): void;
     handleMultiplierAnimation(multiplier: number): Promise<void>;
     play(suffix?: string): Promise<void>;
@@ -34,6 +38,8 @@ export declare abstract class AbstractSymbolBase extends Container {
     swapSymbol(symbolId: SymbolId): void;
     private setupClickListener;
     protected setSymbol(symbolId: SymbolId, shouldSwitchSprite?: boolean): void;
+    stopTransformationPlaying(): void;
+    protected resolveTransformationsPromise(): void;
     protected resolveAndDestroyPlayingPromise(): void;
     protected abstract getResourceForSymbolId(symbolId: SymbolId): LoadersSpineData;
     protected abstract getAnimationNameForSymbol(symbolId: SymbolId, suffix?: string): string;

package/dist/components/symbols/AbstractSymbolBase.js

@@ -20,6 +20,7 @@ export class AbstractSymbolBase extends Container {
     animationSpeedMultiplier = defaultSpeedConfig.animationDefaultSpeedScale;
     endOfMultiplierAnimationPromise;
     endOfSymbolAnimationPromise;
+    endOfSwapAnimationPromise;
     popSymbolAnimationPromise;
     _id;
     constructor(parent, symbolId, multiplierSpineName = null) {
@@ -48,6 +49,31 @@ export class AbstractSymbolBase extends Container {
     updateTimeScaleOfSpine(scale = 0) {
         this.animationSpeedMultiplier = scale;
     }
+    changeSpecialFaceForSymbol(symbolId) {
+        return `efx_${symbolId.toLowerCase()}`;
+    }
+    swapSymbolsToSpecials(symbolId, specialResourceName, spineScale) {
+        const animation = this.changeSpecialFaceForSymbol(symbolId);
+        return this.animateForSpecialSwap(animation, specialResourceName, symbolId, spineScale);
+    }
+    animateForSpecialSwap(animationName, specialResourceName, symbolId, spineScale) {
+        return () => {
+            this.swapSymbol(symbolId);
+            return new Promise((resolve) => {
+                this.spine = new Spine(getSpineData(specialResourceName));
+                this.endOfSwapAnimationPromise = resolve;
+                this.spine.state.timeScale = (this.animationSpeedMultiplier = 1) ? 1.5 : this.animationSpeedMultiplier;
+                this.spine.state.setAnimation(0, animationName, false);
+                this.spine.scale.set(spineScale);
+                this.addChild(this.spine);
+                this.spine.state.addListener({
+                    complete: () => {
+                        resolve();
+                    },
+                });
+            });
+        };
+    }
     switchSymbolBaseDisplayedObject(option, suffix = "") {
         if (option === "spine") {
             this.removeChild(this.spine);
@@ -145,6 +171,16 @@ export class AbstractSymbolBase extends Container {
         if (shouldSwitchSprite)
             this.switchSymbolBaseDisplayedObject("sprite");
     }
+    stopTransformationPlaying() {
+        this.setSymbol(this._id);
+        this.resolveTransformationsPromise();
+    }
+    resolveTransformationsPromise() {
+        if (this.endOfSwapAnimationPromise) {
+            this.endOfSwapAnimationPromise();
+            this.endOfSwapAnimationPromise = undefined;
+        }
+    }
     resolveAndDestroyPlayingPromise() {
         if (this.endOfMultiplierAnimationPromise) {
             this.endOfMultiplierAnimationPromise();

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

@@ -60,6 +60,7 @@ export declare abstract class AbstractSymbolsColumn extends Container implements
     getTriggersPromise(): Promise<void>;
     getStopPromise(): Promise<void>;
     stopAllPlayingSymbols(): void;
+    stopTransformationPlayingSymbols(): void;
     getSymbolAtPosition(position: number): AbstractSymbolBase;
     findSymbols(symbolId: SymbolId): Array<AbstractSymbolBase>;
     playSymbolAtPosition(position: number, playSymbol: boolean, multiplier?: number, suffix?: string): Promise<void>;

package/dist/components/symbols/AbstractSymbolsColumn.js

@@ -81,7 +81,7 @@ export class AbstractSymbolsColumn extends Container {
     }
     async changeVelocity(velocity, duration, frame) {
         await new Promise((resolve) => {
-            this.tween = new TWEEN.Tween({ velocity: this.velocity })
+            this.tween = new TWEEN.Tween({ velocity: velocity })
                 .onUpdate((value) => {
                 this.velocity = value.velocity;
             })
@@ -91,8 +91,7 @@ export class AbstractSymbolsColumn extends Container {
                 .onStop(async () => {
                 this.tween = null;
                 if (frame) {
-                    if (!this.skipHidingMysteryFx)
-                        await frame.hideMysteryFx();
+                    await frame.hideMysteryFx();
                     frame.destroyMysteryFx();
                 }
                 this.skipHidingMysteryFx = false;
@@ -181,6 +180,9 @@ export class AbstractSymbolsColumn extends Container {
     stopAllPlayingSymbols() {
         this.symbols.forEach((symbol) => symbol.stopPlaying());
     }
+    stopTransformationPlayingSymbols() {
+        this.symbols.forEach((symbol) => symbol.stopTransformationPlaying());
+    }
     getSymbolAtPosition(position) {
         return this.symbols[position];
     }

package/dist/constants/gamePhase.d.ts

@@ -10,6 +10,8 @@ export declare const gamePhases: {
     readonly STOPPING_HANDLING_ACTIONS: "stoppingHandlingActions";
     readonly DATA_FETCH: "dataFetch";
     readonly BIG_WIN_INVOKED: "bigWinInvoked";
+    readonly SUPER_BONUS_WIN_INVOKED: "superBonusWinInvoked";
+    readonly BONUS_WIN_INVOKED: "bonusWinInvoked";
     readonly GAME_SUMMARY: "gameSummary";
 };
 export type GamePhase = (typeof gamePhases)[keyof typeof gamePhases];

package/dist/constants/gamePhase.js

@@ -10,5 +10,7 @@ export const gamePhases = {
     STOPPING_HANDLING_ACTIONS: "stoppingHandlingActions",
     DATA_FETCH: "dataFetch",
     BIG_WIN_INVOKED: "bigWinInvoked",
-    GAME_SUMMARY: "gameSummary"
+    SUPER_BONUS_WIN_INVOKED: "superBonusWinInvoked",
+    BONUS_WIN_INVOKED: "bonusWinInvoked",
+    GAME_SUMMARY: "gameSummary",
 };

package/dist/controllers/AbstractController.d.ts

@@ -154,6 +154,7 @@ export declare abstract class AbstractController<T> {
     private lockLogicWhileSpinning;
     private unlockLogicAfterSpinning;
     protected stopPlayingSymbolsStreak(): void;
+    protected stopPlayingSymbolsTransformation(): void;
     protected countBigWin(customAmount?: number): Promise<void>;
     protected countBonusWin(winAmount?: number): Promise<void>;
     protected countSuperBonusWin(winAmount?: number): Promise<void>;

package/dist/controllers/AbstractController.js

@@ -437,7 +437,7 @@ export class AbstractController {
     autoplaySpin() {
         if (!RainMan.settingsStore.howManyAutoSpinsLeft)
             return;
-        if (!RainMan.settingsStore.infinitySpinsEnabled) {
+        if (!RainMan.settingsStore.infinitySpinsEnabled || RainMan.settingsStore.howManyAutoSpinsLeft > 0) {
             RainMan.settingsStore.decreaseAutoSpinsCount();
         }
         if (RainMan.settingsStore.howManyAutoSpinsLeft === 0) {
@@ -592,7 +592,7 @@ export class AbstractController {
         this.unlockLogicAfterSpinning();
         if (RainMan.settingsStore.isFreeSpinsPlayEnabled) {
             this.uiController.increaseTotalFreeSpinWinAmount(spinLogic.winTotalAmountWithoutMystery);
-            this.uiController.limitWinAmount(this.uiController.totalFreeSpinWinAmount);
+            this.uiController.limitWinAmount(spinLogic.winTotalAmount);
         }
         else {
             this.uiController.limitWinAmount(spinLogic.winTotalAmount);
@@ -702,6 +702,9 @@ export class AbstractController {
         this.columnsContainer.stopPlayingSymbolsInColumns();
         this.frame.stopPlayingWinLineAnimations();
     }
+    stopPlayingSymbolsTransformation() {
+        this.columnsContainer.stopPlayingSymbolsTransformationInColumns();
+    }
     async countBigWin(customAmount) {
         if (RainMan.config.disableBigWinOnBonus)
             return;
@@ -710,10 +713,12 @@ 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(() => {
@@ -722,6 +727,7 @@ export class AbstractController {
                 this.mainContainer.destroyBigWin();
                 this.resolveBigWin();
                 this.resolveBigWin = undefined;
+                this.changeGamePhase(gamePhases.IDLE);
             }, RainMan.config.durationOfActions.bigWinPhaseTimeout / animationTimeDivider);
         });
     }
@@ -730,11 +736,12 @@ export class AbstractController {
             return;
         const amount = winAmount || this.uiController.recentWin;
         this.mainContainer.invokeBonusWin();
-        this.changeGamePhase(gamePhases.BIG_WIN_INVOKED);
+        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(() => {
@@ -743,6 +750,7 @@ export class AbstractController {
                 this.mainContainer.destroyBonusWin();
                 this.resolveBonusWin();
                 this.resolveBonusWin = undefined;
+                this.changeGamePhase(gamePhases.IDLE);
             }, RainMan.config.durationOfActions.bonusWinPhaseTimeout / animationTimeDivider);
         });
     }
@@ -751,10 +759,12 @@ 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(() => {
@@ -763,6 +773,7 @@ export class AbstractController {
                 this.mainContainer.destroySuperBonusWin();
                 this.resolveSuperBonusWin();
                 this.resolveSuperBonusWin = undefined;
+                this.changeGamePhase(gamePhases.IDLE);
             }, RainMan.config.durationOfActions.superBonusWinPhaseTimeout / animationTimeDivider);
         });
     }

package/package.json

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