pixi-rainman-game-engine 0.2.0 → 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/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/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/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,6 +56,9 @@ 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;
@@ -65,7 +68,17 @@ export declare abstract class AbstractController<T> {
     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;
@@ -90,6 +103,10 @@ 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
@@ -106,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
@@ -120,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
@@ -127,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>;
@@ -146,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
@@ -165,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[];
 }

package/dist/controllers/AbstractController.js

@@ -9,7 +9,7 @@ import { QuickStopController } from "./QuickStopController";
 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
@@ -103,6 +103,9 @@ export class AbstractController {
         this.uiController.updateBet("first");
         this.uiController.triggerUiElementsUpdate();
     }
+    /**
+     * Function for reinitializing all buttons
+     */
     reinitializeAllButtons() {
         this.initButtons();
         this.initBetButtons();
@@ -212,6 +215,11 @@ export class AbstractController {
                 clearMobileSpinTimeout();
         });
     }
+    /**
+     * This function is responsible for checking if buttons (not bet buttons) should be disabled
+     *
+     * @return {boolean}
+     */
     get shouldButtonsBeDisabled() {
         if (this.quickStopController.quickStopCounterLock)
             return true;
@@ -221,6 +229,11 @@ export class AbstractController {
             this.gamePhase === gamePhases.CONFIGURING_SPIN ||
             this.gamePhase === gamePhases.DATA_FETCH);
     }
+    /**
+     * This function is responsible for checking if bet buttons should be disabled
+     *
+     * @return {boolean}
+     */
     get shouldBetButtonsBeDisabled() {
         return this.shouldButtonsBeDisabled || RainMan.settingsStore.isFreeSpinsPlayEnabled;
     }
@@ -298,6 +311,10 @@ export class AbstractController {
             this.uiController.messageBox.showAutoSpinText();
         }
     }
+    /**
+     *  This function is responsible for getting indexes of reels which should show mystery fx, based on {@link spinLogic}
+     * @param {SpinLogic} spinLogic
+     */
     getReelIndexesToShowMysteryFx(spinLogic) {
         const { onStopBlindsConfiguration } = spinLogic;
         const reelsIndexesWithScatter = [];
@@ -460,6 +477,9 @@ export class AbstractController {
         this.changeGamePhase(gamePhases.IDLE);
         return this.throttledSpin();
     }
+    /**
+     * Function for clearing and destroying actions in win actions queue
+     */
     clearAndDestroyActions() {
         this.winActionsQueue.length = 0;
         this.currentlyPlayedAction = undefined;
@@ -482,6 +502,11 @@ export class AbstractController {
      * @param {SpinLogic} _spinLogic
      */
     onDataFetch(_spinData, _spinLogic) { }
+    /**
+     * Getter for extra data for some games
+     *
+     * @returns {ExtraDataRequest}
+     */
     getExtraData() {
         return {};
     }
@@ -512,6 +537,10 @@ export class AbstractController {
             spinLogic,
         };
     }
+    /**
+     * Checks if we can skip action based on conditions. By default it checks {@link !this.isPlayingUnskippableStreak}
+     *
+     */
     canSkipActions() {
         return !this.isPlayingUnskippableStreak;
     }
@@ -660,6 +689,15 @@ export class AbstractController {
         RainMan.settingsStore.setModalsAvailability(true);
         this.performActionsAfterSpin();
     }
+    /**
+     *  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
+     */
     async handleFreeSpinPlateInvocation(numberOfFreeSpins, isAdditionalFreeSpin = false) {
         await this.buttonsEventManager.disableButtonsForAction(async () => {
             await this.mainContainer.invokeFreeSpinPlate(numberOfFreeSpins ?? RainMan.settingsStore.totalNumberOfFreeSpins, isAdditionalFreeSpin);
@@ -667,6 +705,12 @@ export class AbstractController {
         this.changeGamePhase(gamePhases.IDLE);
         this.invokeFreeSpinPlateAfterWin = false;
     }
+    /**
+     * Function for invoking free spin summary plate, invoked in mainContainer
+     * ```ts
+     *    this.mainContainer.invokeFreeSpinSummary(numberOfFreeSpins, totalFreeSpinWinAmount);
+     * ```
+     */
     async handleFreeSpinSummaryPlateInvocation() {
         await this.buttonsEventManager.disableButtonsForAction(async () => {
             this.uiController.updateDisplayedBalance(this.uiController.totalFreeSpinWinAmount);
@@ -725,6 +769,11 @@ export class AbstractController {
     stopPlayingSymbolsTransformation() {
         this.columnsContainer.stopPlayingSymbolsTransformationInColumns();
     }
+    /**
+     * 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
+     */
     async countBigWin(customAmount) {
         if (RainMan.config.disableBigWinOnBonus)
             return;
@@ -748,6 +797,11 @@ export class AbstractController {
             }, RainMan.config.durationOfActions.bigWinPhaseTimeout / animationTimeDivider);
         });
     }
+    /**
+     * 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
+     */
     async countBonusWin(winAmount) {
         if (!winAmount)
             return;
@@ -768,6 +822,11 @@ export class AbstractController {
             }, RainMan.config.durationOfActions.bonusWinPhaseTimeout / animationTimeDivider);
         });
     }
+    /**
+     *  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
+     */
     async countSuperBonusWin(winAmount) {
         if (!winAmount)
             return;
@@ -788,6 +847,13 @@ export class AbstractController {
             }, RainMan.config.durationOfActions.superBonusWinPhaseTimeout / animationTimeDivider);
         });
     }
+    /**
+     *  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
+     */
     async countMysteryWin(winAmount, quantity = 3) {
         if (!winAmount || !this.mysteryWinSymbol)
             return;
@@ -834,6 +900,11 @@ export class AbstractController {
         }
         return parsedStreak;
     }
+    /**
+     * Function for getting symbols ids from {@link StreakReelsIndexes}
+     *
+     * @param streak
+     */
     getSymbolIdsForStreak(streak) {
         const symbolsIds = [];
         streak.forEach((reelIndex, index) => {
@@ -855,6 +926,9 @@ export class AbstractController {
             this.uiController.updateShownBalance();
         }
     }
+    /**
+     * Function will turn off loop while `RainMan.settingsStore.isAutoplayEnabled` is `true`
+     */
     async handleLoopingWinActionQueue() {
         if (RainMan.settingsStore.isAutoplayEnabled || this.invokeFreeSpinPlateAfterWin)
             return;
@@ -862,6 +936,9 @@ export class AbstractController {
         await this.loopWinActionsQueue();
         this.isLoopingWinActionsQueue = false;
     }
+    /**
+     * Function for looping win actions queue, after initial play
+     */
     async loopWinActionsQueue() { }
     getFreeSpinsWins(spinLogic) {
         const wins = spinLogic.winScenarios.find((winScenario) => winScenario.wins.find((win) => win.type === PossibleWins.freeSpins))?.wins || [];

package/dist/controllers/QuickStopController.d.ts

@@ -1,7 +1,8 @@
 import { ButtonsEventManager } from "../application";
 /**
  * This controller is used to show the speed popup and handle quick stops
- * After 4 quick stops, the speed popup will be shown
+ * After 4 quick stops, the speed popup will be shown.
+ * Number of quick spin can be adjusted in {@link MAX_QUICK_STOPS}
  *
  * @exports
  */

package/dist/controllers/QuickStopController.js

@@ -3,7 +3,8 @@ import { RainMan } from "../Rainman";
 const MAX_QUICK_STOPS = 4;
 /**
  * This controller is used to show the speed popup and handle quick stops
- * After 4 quick stops, the speed popup will be shown
+ * After 4 quick stops, the speed popup will be shown.
+ * Number of quick spin can be adjusted in {@link MAX_QUICK_STOPS}
  *
  * @exports
  */

package/dist/controllers/UiController.d.ts

@@ -28,6 +28,11 @@ export declare class UiController {
     increaseTotalFreeSpinWinAmount(value: number): void;
     resetTotalFreeSpinWinAmount(): void;
     private getNewBet;
+    /**
+     *  Functions to be called before bet is updated
+     *
+     * @param _lastBet - last bet
+     */
     protected beforeUpdateBet(_lastBet: number): void;
     /**
      * Function to be called after bet is updated
@@ -39,6 +44,9 @@ export declare class UiController {
     updateShownSpeedLevel(currentSpeed: SpeedLevel): void;
     updateShownBalance(): void;
     updateShownCurrentWin(): void;
+    /**
+     * Shows possible win in a bottom panel, if exists
+     */
     updateShownPossibleWin(): void;
     updateShownFreeSpinAmount(amount: number, isAdditionalFreeSpins?: boolean): void;
     delegateUpdatingWinAndBalance(amount: Nullable<number>): void;

package/dist/controllers/UiController.js

@@ -70,7 +70,11 @@ export class UiController {
                 return this.config?.getFirstBet() || 0;
         }
     }
-    // functions used to handle state for different values of bets, e.g. collected eggs or gold for bonus game
+    /**
+     *  Functions to be called before bet is updated
+     *
+     * @param _lastBet - last bet
+     */
     beforeUpdateBet(_lastBet) { }
     /**
      * Function to be called after bet is updated
@@ -103,6 +107,9 @@ export class UiController {
         }
         RainMan.componentRegistry.get(MessageBox.currentWinTextRegistryName).set(this.recentWin);
     }
+    /**
+     * Shows possible win in a bottom panel, if exists
+     */
     updateShownPossibleWin() {
         this.messageBox.showPossibleWinText();
         RainMan.componentRegistry.get(MessageBox.possibleWinTextRegistryName).set(this.recentWin);

package/dist/layers/layers.d.ts

@@ -1,5 +1,21 @@
 import { Layer } from "@pixi/layers";
+/**
+ * Layer visibility hierarchy (from bottom):
+ * - {@link BackgroundLayer}
+ * - {@link FrameLayer}
+ * - {@link AnimationLayer}
+ * - {@link UXLayer}
+ */
 export declare const UXLayer: Layer;
+/**
+ * {@inheritDoc UXLayer}
+ */
 export declare const BackgroundLayer: Layer;
+/**
+ * {@inheritDoc UXLayer}
+ */
 export declare const FrameLayer: Layer;
+/**
+ * {@inheritDoc UXLayer}
+ */
 export declare const AnimationLayer: Layer;

package/dist/layers/layers.js

@@ -1,9 +1,25 @@
 import { Layer } from "@pixi/layers";
+/**
+ * Layer visibility hierarchy (from bottom):
+ * - {@link BackgroundLayer}
+ * - {@link FrameLayer}
+ * - {@link AnimationLayer}
+ * - {@link UXLayer}
+ */
 export const UXLayer = new Layer();
 UXLayer.name = "UXLayer";
+/**
+ * {@inheritDoc UXLayer}
+ */
 export const BackgroundLayer = new Layer();
 BackgroundLayer.name = "backgroundLayer";
+/**
+ * {@inheritDoc UXLayer}
+ */
 export const FrameLayer = new Layer();
 FrameLayer.name = "frameLayer";
+/**
+ * {@inheritDoc UXLayer}
+ */
 export const AnimationLayer = new Layer();
 AnimationLayer.name = "animationLayer";

package/dist/stores/SettingsStore.d.ts

@@ -58,8 +58,23 @@ export declare class SettingsStore {
     resetCumulativeWinAmount(): void;
     updateBet(newBet: number): void;
     setBatteryFlag(flag: boolean): void;
+    /**
+     * Resets animation timescale for all spines `allSpines` in {@link ResumableContainer}, {@link SpineWithResumableContainer}
+     */
     refreshBatterySaver(): void;
+    /**
+     * Sets flag for ambient music.
+     *
+     * @param flag
+     * @param saveToLocalStorage - default {@link true}, if true the flag will be saved to localStorage
+     */
     setAmbientMusicFlag(flag: boolean, saveToLocalStorage?: boolean): void;
+    /**
+     * Sets flag for effect sounds
+     *
+     * @param flag
+     * @param saveToLocalStorage - default {@link true}, if true the flag will be saved to localStorage
+     */
     setSoundFxFlag(flag: boolean, saveToLocalStorage?: boolean): void;
     flipSoundsEnabled(volumeLevel?: number | null): void;
     isSoundEnabled(): boolean;
@@ -77,6 +92,11 @@ export declare class SettingsStore {
     resetDataForSymbolPaytablePopup(): void;
     setUpdateVolumeButtonTexture(fn: () => void): void;
     repositionSymbolPaytablePopup(x: number, y: number): void;
+    /**
+     * Initialize paytable map for all symbols. based on backend data {@link InitDataInterface.paytable}
+     *
+     * @param initConfigData
+     */
     initPaytableMap(initConfigData: InitDataInterface): void;
     decreaseAutoSpinsCount(): void;
     setAutoSpinsCount(count: number): void;

package/dist/stores/SettingsStore.js

@@ -132,9 +132,18 @@ export class SettingsStore {
         this.refreshBatterySaver();
         setToLocalStorage(LOCAL_STORAGE.batterySaver, flag);
     }
+    /**
+     * Resets animation timescale for all spines `allSpines` in {@link ResumableContainer}, {@link SpineWithResumableContainer}
+     */
     refreshBatterySaver() {
         this.containersWithSpines.forEach((spine) => spine.setAnimationTimescale(!this.batterySaverFlag));
     }
+    /**
+     * Sets flag for ambient music.
+     *
+     * @param flag
+     * @param saveToLocalStorage - default {@link true}, if true the flag will be saved to localStorage
+     */
     setAmbientMusicFlag(flag, saveToLocalStorage = true) {
         this.ambientMusicFlag = flag;
         SoundManager.setPlayStatus(SoundTracks.music, flag);
@@ -144,6 +153,12 @@ export class SettingsStore {
             removeFromLocalStorage(LOCAL_STORAGE.isSoundEnabled);
         }
     }
+    /**
+     * Sets flag for effect sounds
+     *
+     * @param flag
+     * @param saveToLocalStorage - default {@link true}, if true the flag will be saved to localStorage
+     */
     setSoundFxFlag(flag, saveToLocalStorage = true) {
         this.soundFxFlag = flag;
         if (!flag)
@@ -257,6 +272,11 @@ export class SettingsStore {
     repositionSymbolPaytablePopup(x, y) {
         this.popupPaytablePosition = { x, y };
     }
+    /**
+     * Initialize paytable map for all symbols. based on backend data {@link InitDataInterface.paytable}
+     *
+     * @param initConfigData
+     */
     initPaytableMap(initConfigData) {
         for (const [key, name] of initConfigData.symbols_names.entries()) {
             const backendId = initConfigData.symbols[key];

package/dist/utils/common/functions.d.ts

@@ -1,13 +1,31 @@
 import { Spine } from "pixi-spine";
 import { Point } from "../../connectivity";
 export declare const ceilToDecimal: (value: number, decimalPlaces?: number) => number;
+/**
+ * Wait for a specified amount of time
+ *
+ * @param ms - time in milliseconds
+ */
 export declare const wait: (ms: number) => Promise<void>;
 export declare const range: (start: number, stop: number, step: number) => number[];
 export declare const getRandomInt: (min: number, max: number) => number;
 export declare const removeMatchingElements: <T>(array: T[], elementsToRemove: T[]) => T[];
 export declare const hideLayerIfPresent: (elementsToSkip?: string[]) => boolean;
+/**
+ *  Hides paytable
+ */
 export declare const hidePaytable: () => void;
+/**
+ *  Toggles paytable, while user clicks on the symbol
+ */
 export declare const togglePaytable: () => void;
+/**
+ * Waits for spine animation to end
+ *
+ * @param spine
+ * @param animationName
+ * @param loopAnimationName
+ */
 export declare const waitForAnimationToEnd: (spine: Spine, animationName: string, loopAnimationName?: string) => Promise<void>;
 export declare const setTimeScale: (spine: Spine, flag: boolean) => void;
 export declare const changeResolution: (high: boolean) => void;

package/dist/utils/common/functions.js

@@ -3,6 +3,11 @@ import { allUiItems, UI_ITEMS } from "./uiItems";
 export const ceilToDecimal = (value, decimalPlaces = 2) => {
     return Number(value.toFixed(decimalPlaces));
 };
+/**
+ * Wait for a specified amount of time
+ *
+ * @param ms - time in milliseconds
+ */
 export const wait = (ms) => {
     return new Promise((resolve) => setTimeout(resolve, ms));
 };
@@ -33,18 +38,31 @@ export const hideLayerIfPresent = (elementsToSkip = []) => {
     });
     return anyHidden;
 };
+/**
+ *  Hides paytable
+ */
 export const hidePaytable = () => {
     const paytableLayer = window.document.getElementById(UI_ITEMS.symbolPayTable);
     if (paytableLayer === null)
         return;
     paytableLayer.style.display = "none";
 };
+/**
+ *  Toggles paytable, while user clicks on the symbol
+ */
 export const togglePaytable = () => {
     const paytableLayer = window.document.getElementById(UI_ITEMS.symbolPayTable);
     if (paytableLayer === null)
         return;
     paytableLayer.style.display = paytableLayer.style.display === "flex" ? "none" : "flex";
 };
+/**
+ * Waits for spine animation to end
+ *
+ * @param spine
+ * @param animationName
+ * @param loopAnimationName
+ */
 export const waitForAnimationToEnd = async (spine, animationName, loopAnimationName) => {
     spine.state.clearListeners();
     await new Promise((resolve) => {

package/dist/utils/common/placementHelpers.d.ts

@@ -2,5 +2,10 @@ import { Rect } from "adaptive-scale/lib";
 import { Container, DisplayObject } from "pixi.js";
 import { Nullable } from "./types";
 export declare const scaleToParent: (width: number, height: number, parentWidth: number, parentHeight: number) => Rect;
+/**
+ *  Get global min ratio of current device, used for scaling elements.
+ *
+ * @exports
+ */
 export declare const globalMinRatio: () => number;
 export declare const setChildIndexWithAscendingOrder: (parentContainer: Container, childrenComponents: Nullable<DisplayObject>[]) => void;

package/dist/utils/common/placementHelpers.js

@@ -19,6 +19,11 @@ const valueForMobile = () => {
     }
     return globalYRatio * 2;
 };
+/**
+ *  Get global min ratio of current device, used for scaling elements.
+ *
+ * @exports
+ */
 export const globalMinRatio = () => {
     if (getScreenRatio() < 1) {
         return valueForMobile();

package/dist/winComponents/AnimableParticlesEmitter.d.ts

@@ -1,7 +1,7 @@
 import { EmitterConfigV3 } from "@pixi/particle-emitter";
 import { Container } from "pixi.js";
 /**
- * Class for creating Emitter and plays animation while Big, mystery wins
+ * Class for creating Emitter and plays particle animation background while Big, mystery wins
  *
  * @export
  * @class AnimableParticlesEmitter

package/dist/winComponents/AnimableParticlesEmitter.js

@@ -1,7 +1,7 @@
 import { Emitter } from "@pixi/particle-emitter";
 import { Container } from "pixi.js";
 /**
- * Class for creating Emitter and plays animation while Big, mystery wins
+ * Class for creating Emitter and plays particle animation background while Big, mystery wins
  *
  * @export
  * @class AnimableParticlesEmitter

package/package.json

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