pixi-rainman-game-engine 0.1.53 → 0.2.1

package/dist/DescribedPlayableAction/DescribedPlayableAction.d.ts

@@ -1,6 +1,6 @@
 import { Nullable, PlayableAction } from "../utils";
 /**
- * Class representing a described playable action
+ * Class representing a described playable action in action queue.
  */
 export declare class DescribedPlayableAction<T> {
     readonly type: T;

package/dist/DescribedPlayableAction/DescribedPlayableAction.js

@@ -1,5 +1,5 @@
 /**
- * Class representing a described playable action
+ * Class representing a described playable action in action queue.
  */
 export class DescribedPlayableAction {
     type;

package/dist/Rainman/Rainman.d.ts

@@ -4,6 +4,16 @@ import { SymbolIds, WinTypeIds } from "../application";
 import { ComponentRegistry } from "../ComponentRegistry";
 import { SettingsStore } from "../stores";
 import { AppConfig, Globals, OptionalAppConfig, RequiredAppConfig } from "./types";
+/**
+ * This class represents Pixi application. Before initializing game, user has to configure following:
+ * - {@link Application}
+ * - {@link RequiredAppConfig} and {@link OptionalAppConfig}
+ * - {@link SymbolIds} present in `gameEngineConfig`
+ * - {@link WinTypeIds} present in `gameEngineConfig`
+ *
+ * @export
+ * @class RainMan
+ */
 export declare class RainMan {
     static app: Application;
     static config: RequiredAppConfig & OptionalAppConfig;

package/dist/Rainman/Rainman.js

@@ -4,6 +4,16 @@ import { Currencies } from "ts-money";
 import { ComponentRegistry } from "../ComponentRegistry";
 import { settingStore } from "../SettingsUI/hooks";
 import { defaultAppConfig } from "./appConfig";
+/**
+ * This class represents Pixi application. Before initializing game, user has to configure following:
+ * - {@link Application}
+ * - {@link RequiredAppConfig} and {@link OptionalAppConfig}
+ * - {@link SymbolIds} present in `gameEngineConfig`
+ * - {@link WinTypeIds} present in `gameEngineConfig`
+ *
+ * @export
+ * @class RainMan
+ */
 export class RainMan {
     static app;
     static config;

package/dist/Rainman/types.d.ts

@@ -65,6 +65,7 @@ export type AppConfig = RequiredAppConfig & DeepPartial<OptionalAppConfig>;
  */
 export interface Globals {
     currency: Currency;
+    actionsAfterClosureWebSocket?: () => void;
     disableSpeedPopup?: (value: boolean) => void;
     handleDisablingButtons?: (value?: boolean) => void;
     throttledSpin?: () => void;

package/dist/application/ApiConfig/SymbolId.d.ts

@@ -2,6 +2,14 @@
  * Interface for specifying symbols in game
  * This type can be modified for each game in engine.d.ts file
  *
+ * @example
+ * ```
+ * interface SymbolIds {
+ *  cherries: "cherries",
+ *  lemon: "lemon",
+ *   }
+ * ```
+ *
  * @export
  * @interface SymbolIds
  * @typedef {SymbolIds}

package/dist/application/ApiConfig/WinTypeId.d.ts

@@ -1,6 +1,12 @@
 /**
  * Interface for specifying win in game
  * This type can be modified for each game in engine.d.ts file
+ * @example
+ * ```
+ * interface WinTypeIds {
+ *  streak: "streak";
+ *   }
+ * ```
  *
  * @export
  * @interface WinTypeIds

package/dist/application/SpinLogic/WinScenarios.d.ts

@@ -1,6 +1,6 @@
 import { TransformationDetails, Win } from "../../connectivity";
 /**
- * This class represents win scenarios
+ * This class represents win and transformation scenarios described in {@link transformationTypes} and {@link PossibleWins}
  *
  * @exports {WinScenarios}
  */

package/dist/application/SpinLogic/WinScenarios.js

@@ -1,5 +1,5 @@
 /**
- * This class represents win scenarios
+ * This class represents win and transformation scenarios described in {@link transformationTypes} and {@link PossibleWins}
  *
  * @exports {WinScenarios}
  */

package/dist/components/buttons/BaseButton/ButtonState.d.ts

@@ -1,3 +1,14 @@
+/**
+ * Describes all button states in game
+ *@example
+ * ```
+ *     const textureMap = {
+ *            [ButtonStates.NORMAL]: getTexture("continueButton-normal.png"),
+ *            [ButtonStates.CLICKED]: getTexture("continueButton-clicked.png"),
+ *            [ButtonStates.OVER]: getTexture("continueButton-hover.png"),
+ *     } as TextureMap;
+ * ```
+ */
 export declare const ButtonStates: {
     readonly NORMAL: "NORMAL";
     readonly OVER: "OVER";

package/dist/components/buttons/BaseButton/ButtonState.js

@@ -1,3 +1,14 @@
+/**
+ * Describes all button states in game
+ *@example
+ * ```
+ *     const textureMap = {
+ *            [ButtonStates.NORMAL]: getTexture("continueButton-normal.png"),
+ *            [ButtonStates.CLICKED]: getTexture("continueButton-clicked.png"),
+ *            [ButtonStates.OVER]: getTexture("continueButton-hover.png"),
+ *     } as TextureMap;
+ * ```
+ */
 export const ButtonStates = {
     NORMAL: "NORMAL",
     OVER: "OVER",

package/dist/components/common/AnimatedNumber.d.ts

@@ -1,4 +1,8 @@
 import { Container } from "pixi.js";
+/**
+ * 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;

package/dist/components/common/AnimatedNumber.js

@@ -1,6 +1,10 @@
 import { Container } from "pixi.js";
 import { Spine } from "pixi-spine";
 import { getSpineData } from "../../utils";
+/**
+ * Class representing animated number, based on spine animation.
+ * Animation names should be exact the same as a represented symbol.
+ */
 export class AnimatedNumber extends Container {
     spineName;
     number;

package/dist/components/common/ResumableContainers.d.ts

@@ -1,7 +1,7 @@
 import { Container, Sprite } from "pixi.js";
 import { Spine } from "pixi-spine";
 /**
- * Class representing container with all spines
+ * Class representing container with all spines. Every used spine have to be put in `allSpines` array to enable battery saver functionality
  *
  * @extends {Spine}
  * @class

package/dist/components/common/ResumableContainers.js

@@ -2,7 +2,7 @@ import { Container, Sprite } from "pixi.js";
 import { Spine } from "pixi-spine";
 import { setTimeScale } from "../../utils";
 /**
- * Class representing container with all spines
+ * Class representing container with all spines. Every used spine have to be put in `allSpines` array to enable battery saver functionality
  *
  * @extends {Spine}
  * @class

package/dist/components/frame/AbstractColumnsContainer.js

@@ -93,9 +93,6 @@ export class AbstractColumnsContainer extends Container {
                 const configureSpinAction = configuredBlindSpinsActions.shift();
                 if (configureSpinAction !== undefined) {
                     if (indexesOfReelsToExtendSpinningTime.includes(index)) {
-                        indexesOfReelsToExtendSpinningTime.forEach((number) => {
-                            this.allColumns[number].changeMultiplier();
-                        });
                         this.currentColumn = this.allColumns[index];
                         this.currentColumn.adaptToSpeed(RainMan.settingsStore.currentSpeed);
                         frame.invokeMysteryFx(this.currentColumn.x, this.currentColumn.y);

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

@@ -7,7 +7,8 @@ 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
+ * Class aggregating all reels and activities related to them. Each frame has its own proportions, which allow for proper positioning on the screen.
+ * This represents all of elements in center frame like {@link ColumnsContainer}, frame animation (on {@link FrameLayer})
  *
  * @export
  * @abstract
@@ -35,13 +36,27 @@ export declare abstract class AbstractFrame extends ResumableContainer implement
     protected constructor(spineName: string);
     get columnsContainer(): AbstractColumnsContainer;
     adaptToSpeed(speedLevel: SpeedLevel): void;
+    /**
+     * Invoke mystery fx on symbol position
+     *
+     * @param x {number}
+     * @param y {number}
+     */
     invokeMysteryFx(x: number, y: number): void;
     protected repositionMysteryFx(_x: number, _y: number): void;
     hideMysteryFx(): void;
     private resetMysteryFxCoordinates;
     destroyMysteryFx(): void;
+    /**
+     * Create win line animation, individual for each game, based on {@link WinLineAnimation}
+     * */
     protected createWinLineAnimation(_animationName: string): WinLineAnimation | null;
     playAllWinLineAnimations(animationNames: string[]): Promise<void>;
+    /**
+     * Creates and plays win line animation.
+     *
+     * @param animationName
+     */
     playWinLineAnimation(animationName: string): Promise<void>;
     stopPlayingWinLineAnimations(): void;
     isPlayingWinLineAnimation(): boolean;

package/dist/components/frame/AbstractFrame.js

@@ -5,7 +5,8 @@ import { RainMan } from "../../Rainman";
 import { getDeviceOrientation, getSpineData, logError, scaleToParent } from "../../utils";
 import { ResumableContainer } from "../common";
 /**
- * This class is representing all of elements in center frame like Columns Container, frame animation
+ * Class aggregating all reels and activities related to them. Each frame has its own proportions, which allow for proper positioning on the screen.
+ * This represents all of elements in center frame like {@link ColumnsContainer}, frame animation (on {@link FrameLayer})
  *
  * @export
  * @abstract
@@ -35,6 +36,12 @@ export class AbstractFrame extends ResumableContainer {
     adaptToSpeed(speedLevel) {
         this.velocityMultiplier = this.speedLevelMapper[speedLevel];
     }
+    /**
+     * Invoke mystery fx on symbol position
+     *
+     * @param x {number}
+     * @param y {number}
+     */
     invokeMysteryFx(x, y) {
         if (!this.mysteryFxConfig)
             return;
@@ -78,12 +85,20 @@ export class AbstractFrame extends ResumableContainer {
             this.mysteryFxHighlight = null;
         }
     }
+    /**
+     * Create win line animation, individual for each game, based on {@link WinLineAnimation}
+     * */
     createWinLineAnimation(_animationName) {
         return null;
     }
     async playAllWinLineAnimations(animationNames) {
         await Promise.allSettled(animationNames.map((animationName) => this.playWinLineAnimation(animationName)));
     }
+    /**
+     * Creates and plays win line animation.
+     *
+     * @param animationName
+     */
     async playWinLineAnimation(animationName) {
         const winLineAnimation = this.createWinLineAnimation(animationName);
         if (winLineAnimation === null) {

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

@@ -1,7 +1,7 @@
 import { Container } from "pixi.js";
 import { AbstractColumnsContainer } from "./AbstractColumnsContainer";
 /**
- * Wrapper class for Columns Container
+ * Wrapper class for Columns Container {@link ColumnsContainer}
  *
  * @export
  * @abstract

package/dist/components/frame/AbstractInnerFrame.js

@@ -1,7 +1,7 @@
 import { Container } from "pixi.js";
 import { FrameLayer } from "../../layers";
 /**
- * Wrapper class for Columns Container
+ * Wrapper class for Columns Container {@link ColumnsContainer}
  *
  * @export
  * @abstract

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

@@ -12,7 +12,7 @@ import { LoadersSpineData, Nullable } from "../../utils";
  */
 export declare abstract class AbstractSymbolBase extends Container {
     private multiplierSpineName;
-    protected symbolImage: Sprite;
+    symbolImage: Sprite;
     spine: Spine;
     protected destroySuffix: string;
     protected animationSpeedMultiplier: number;

package/dist/components/symbols/AbstractSymbolBase.js

@@ -62,7 +62,7 @@ export class AbstractSymbolBase extends Container {
             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.timeScale = this.animationSpeedMultiplier === 1 ? 1.5 : this.animationSpeedMultiplier;
                 this.spine.state.setAnimation(0, animationName, false);
                 this.spine.scale.set(spineScale);
                 this.addChild(this.spine);

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

@@ -6,7 +6,7 @@ import { AbstractColumnsContainer, AbstractFrame } from "../frame";
 import { AbstractSymbolBase } from "./AbstractSymbolBase";
 import { AnimationTimeSettings } from "./types";
 /**
- * Class represent single column in ColumnsContainer
+ * Class represent single column in {@link ColumnsContainer}. It contains array of {@link AbstractSymbolBase}
  *
  * @export
  * @abstract
@@ -52,7 +52,6 @@ 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;

package/dist/components/symbols/AbstractSymbolsColumn.js

@@ -8,7 +8,7 @@ import { logInfo } from "../../utils";
 import { droppableSymbolsFactory } from "./DroppableSymbolsColumn";
 import { Phase, Speed } from "./types";
 /**
- * Class represent single column in ColumnsContainer
+ * Class represent single column in {@link ColumnsContainer}. It contains array of {@link AbstractSymbolBase}
  *
  * @export
  * @abstract
@@ -80,15 +80,11 @@ 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.resolveMysterySpeedUp = resolve;
-            this.tween = new TWEEN.Tween({ velocity: velocity })
-                .to({ value: 70 }, duration)
-                .easing(TWEEN.Easing.Linear.None)
+            this.tween = new TWEEN.Tween({ velocity: Speed.FAST })
+                .to({ velocity: velocity }, duration)
                 .onUpdate((value) => {
                 this.velocity = value.velocity;
             })

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

@@ -1,7 +1,7 @@
 import { SymbolId } from "../../application";
 import { AbstractSymbolBase } from "./AbstractSymbolBase";
 /**
- * This class represents symbol that can be dropped from column
+ * This class represents symbol that can be dropped from column. Based on transformation type `drop` from {@link transformationTypes}
  *
  * @export
  * @class DroppableSymbol

package/dist/components/symbols/DroppableSymbol.js

@@ -1,5 +1,5 @@
 /**
- * This class represents symbol that can be dropped from column
+ * This class represents symbol that can be dropped from column. Based on transformation type `drop` from {@link transformationTypes}
  *
  * @export
  * @class DroppableSymbol

package/dist/connectivity/ConnectionWrapper.js

@@ -64,6 +64,7 @@ export class ConnectionWrapper {
             this.subscribers.forEach((subscriberFn) => {
                 subscriberFn();
             });
+            RainMan.globals.actionsAfterClosureWebSocket?.();
         });
         this.webSocketConnection.addEventListener("message", (event) => this.handleMessage(JSON.parse(event.data)));
         logInfo("connection established, listener set");

package/dist/connectivity/serverData.d.ts

@@ -60,6 +60,9 @@ export interface RangeSymbolMultiplierTable {
     type: typeof PaytableTypes.range;
     quantity: RangeQuantityValue;
 }
+/**
+ *  Type for symbol (or jackpots if present) paytables
+ */
 export type SymbolMultiplierTable = FixedSymbolMultiplierTable | RangeSymbolMultiplierTable;
 export type PayTableInterface = Record<string, SymbolMultiplierTable>;
 export interface SpinDataInterface {

package/dist/connectivity/transformation.d.ts

@@ -1,6 +1,9 @@
 import { transformationTypes } from "constants/transformation";
 import { SymbolId } from "../application";
 import { SymbolReels } from "./wins";
+/**
+ * Describes coordinated of symbol on reels
+ */
 export type Point = {
     x: number;
     y: number;

package/dist/constants/gamePhase.d.ts

@@ -1,5 +1,5 @@
 /**
- * This object represents all the states in Rainman game
+ * This object represents all game states in Rainman game
  */
 export declare const gamePhases: {
     readonly IDLE: "idle";

package/dist/constants/gamePhase.js

@@ -1,5 +1,5 @@
 /**
- * This object represents all the states in Rainman game
+ * This object represents all game states in Rainman game
  */
 export const gamePhases = {
     IDLE: "idle",

package/dist/constants/transformation.d.ts

@@ -1,3 +1,6 @@
+/**
+ * All transformation types available in Rainman games
+ */
 export declare const transformationTypes: {
     readonly destroy: "destroy";
     readonly drop: "drop";

package/dist/constants/transformation.js

@@ -1,3 +1,6 @@
+/**
+ * All transformation types available in Rainman games
+ */
 export const transformationTypes = {
     destroy: "destroy",
     drop: "drop",

package/dist/constants/wins.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Describes all possible win types in all of Rainman games
+ */
 export declare const PossibleWins: {
     readonly mystery: "mystery";
     readonly streak: "streak";

package/dist/constants/wins.js

@@ -1,3 +1,6 @@
+/**
+ * Describes all possible win types in all of Rainman games
+ */
 export const PossibleWins = {
     mystery: "mystery",
     streak: "streak",

package/dist/controllers/AbstractController.d.ts

@@ -10,7 +10,7 @@ import { SpinDataWithLogic } from "./types";
 import { UiController } from "./UiController";
 /**
  * Abstract controller class for games, this class control game flow
- * and handle all game logic
+ * and handle all game logic, including wins, transformations
  *
  * @abstract
  * @class AbstractController
@@ -56,17 +56,29 @@ export declare abstract class AbstractController<T> {
      * Function for initializing function after timeout
      */
     reinitializeUserBalanceData(): void;
+    /**
+     * Function for reinitializing all buttons
+     */
     reinitializeAllButtons(): void;
     private setupSpaceOrEnterListener;
     disableBetButtons(shouldBeDisabled: boolean): void;
     private disableSpeedButton;
     private disableInformationButtons;
-    private disableFreeSpinButton;
     protected handleDisablingButtons(disabled?: boolean): void;
     private initButtons;
     private initBetButtons;
     private initSpinButton;
+    /**
+     * This function is responsible for checking if buttons (not bet buttons) should be disabled
+     *
+     * @return {boolean}
+     */
     get shouldButtonsBeDisabled(): boolean;
+    /**
+     * This function is responsible for checking if bet buttons should be disabled
+     *
+     * @return {boolean}
+     */
     get shouldBetButtonsBeDisabled(): boolean;
     get lastWinAmount(): number;
     get balance(): number;
@@ -91,12 +103,15 @@ export declare abstract class AbstractController<T> {
     protected changeGamePhase(newPhase: GamePhase): void;
     private setRefreshButtonBasedOnPhase;
     private setMessageBoxBasedOnPhase;
+    /**
+     *  This function is responsible for getting indexes of reels which should show mystery fx, based on {@link spinLogic}
+     * @param {SpinLogic} spinLogic
+     */
     protected getReelIndexesToShowMysteryFx(spinLogic: SpinLogic): number[];
     /**
      * Function is responsible for initializing the spin process
      * This also is handler for refresh button and space functionalities
      * After the spin, this function removes free spin plate/summary, big win, mystery containers
-     *
      */
     protected handleSpinLogic(): void;
     /**
@@ -108,6 +123,9 @@ export declare abstract class AbstractController<T> {
      * Function for autoplay spin
      */
     protected autoplaySpin(): void;
+    /**
+     * Function for clearing and destroying actions in win actions queue
+     */
     protected clearAndDestroyActions(): void;
     /**
      * Function disabling autoplay functionality
@@ -122,6 +140,11 @@ export declare abstract class AbstractController<T> {
      * @param {SpinLogic} _spinLogic
      */
     protected onDataFetch(_spinData: SpinData, _spinLogic: SpinLogic): void;
+    /**
+     * Getter for extra data for some games
+     *
+     * @returns {ExtraDataRequest}
+     */
     protected getExtraData(): ExtraDataRequest;
     /**
      * Function for fetching and preparing spin data
@@ -129,6 +152,10 @@ export declare abstract class AbstractController<T> {
      * @returns {SpinDataWithLogic}
      */
     protected fetchAndPrepareSpinData(): Promise<SpinDataWithLogic>;
+    /**
+     * Checks if we can skip action based on conditions. By default it checks {@link !this.isPlayingUnskippableStreak}
+     *
+     */
     protected canSkipActions(): boolean;
     protected onSpinningStart(): Promise<void>;
     protected onSpinningEnd(_spinLogic: SpinLogic): Promise<void>;
@@ -148,16 +175,53 @@ export declare abstract class AbstractController<T> {
      * @returns {Promise<void>}
      */
     private spin;
+    /**
+     *  Function for invoking free spin plate, invoked in mainContainer
+     * ```ts
+     * this.mainContainer.invokeFreeSpinPlate(numberOfFreeSpins, isAdditionalFreeSpin);
+     * ```
+     *
+     * @param numberOfFreeSpins - number of free spins, if not provided, `RainMan.settingsStore.totalNumberOfFreeSpins` will be used
+     * @param isAdditionalFreeSpin  - flag for displaying additional free spins
+     */
     private handleFreeSpinPlateInvocation;
+    /**
+     * Function for invoking free spin summary plate, invoked in mainContainer
+     * ```ts
+     *    this.mainContainer.invokeFreeSpinSummary(numberOfFreeSpins, totalFreeSpinWinAmount);
+     * ```
+     */
     protected handleFreeSpinSummaryPlateInvocation(): Promise<void>;
     private handleAutoplayLogic;
     private lockLogicWhileSpinning;
     private unlockLogicAfterSpinning;
     protected stopPlayingSymbolsStreak(): void;
     protected stopPlayingSymbolsTransformation(): void;
+    /**
+     * Function for displaying big win. Invoking that by `this.mainContainer.invokeBigWin();` and destroying it by `this.mainContainer.destroyBigWin();`
+     *
+     * @param customAmount - amount of win, if not provided, `RainMan.settingsStore.bet` will be used
+     */
     protected countBigWin(customAmount?: number): Promise<void>;
+    /**
+     * Function for displaying bonus win. Invoking that by `this.mainContainer.invokeBonusWin();` and destroying it by `this.mainContainer.destroyBonusWin();`
+     *
+     * @param customAmount - amount of win, if not provided, `RainMan.settingsStore.bet` will be used
+     */
     protected countBonusWin(winAmount?: number): Promise<void>;
+    /**
+     *  Function for displaying super bonus win. Invoking that by `this.mainContainer.invokeSuperBonusWin();` and destroying it by `this.mainContainer.destroySuperBonusWin();`
+     *
+     * @param winAmount - amount of win, if not provided `RainMan.settingsStore.cumulativeWinAmount` will be used
+     */
     protected countSuperBonusWin(winAmount?: number): Promise<void>;
+    /**
+     *  Function for displaying mystery win. Invoking that by `this.mainContainer.invokeMysteryWin();` and destroying it by `this.mainContainer.destroyMysteryWin();`.
+     * Function requires `this.mysteryWinSymbol` to be fired.
+     *
+     * @param winAmount
+     * @param quantity  - how many symbols create mystery win, by default 3
+     */
     protected countMysteryWin(winAmount?: number, quantity?: number): Promise<void>;
     /**
      * Parser for streaks and reels quantity
@@ -167,11 +231,30 @@ export declare abstract class AbstractController<T> {
      * @returns {StreakReelsIndexes}
      */
     protected parseStreak(streak: StreakReelsIndexes, reelsQuantity: number): StreakReelsIndexes;
+    /**
+     * Function for getting symbols ids from {@link StreakReelsIndexes}
+     *
+     * @param streak
+     */
     protected getSymbolIdsForStreak(streak: StreakReelsIndexes): SymbolId[];
     protected updateUiValues(value: number): void;
+    /**
+     * Function for composing win actions queue based on wins and transformations from {@link transformationTypes} and {@link PossibleWins}
+     *
+     * @param spinLogic
+     */
     protected abstract composeWinActionsQueue(spinLogic: SpinLogic): void;
+    /**
+     * Function for playing win actions queue from `this.winActionsQueue` or `this.winActionsQueueSorted`, if used.
+     */
     protected abstract playWinActionQueue(): Promise<void>;
+    /**
+     * Function will turn off loop while `RainMan.settingsStore.isAutoplayEnabled` is `true`
+     */
     protected handleLoopingWinActionQueue(): Promise<void>;
+    /**
+     * Function for looping win actions queue, after initial play
+     */
     protected loopWinActionsQueue(): Promise<void>;
     getFreeSpinsWins(spinLogic: SpinLogic): FreeSpinWin[];
 }