pixi-rainman-game-engine 0.3.0 → 0.3.2

package/dist/components/AbstractFreeSpinContainer/AbstractFreeSpinContainer.d.ts

@@ -1,5 +1,6 @@
 import { Container, Sprite, Text } from "pixi.js";
 import { Spine } from "pixi-spine";
+import { Nullable } from "../../utils";
 /**
  * This class represents summary and information at start of free games
  * @abstract
@@ -9,16 +10,50 @@ import { Spine } from "pixi-spine";
  */
 export declare abstract class AbstractFreeSpinContainer extends Container {
     protected abstract freeSpinPlate: Sprite | Spine;
-    shownAt: number | null;
+    shownAt: Nullable<number>;
     protected scaleMultiplier: number;
     protected constructor();
     /**
      * This getter enables to remove container after you click Refresh button or you click space
+     * @abstract
+     * @public
+     * @returns {() => void}
      */
     abstract get onClick(): () => void;
+    /**
+     * This getter enables to remove container after you click Refresh button or you click space
+     * @public
+     * @returns {Promise<void>} function to remove container
+     */
     onStart(): Promise<void>;
+    /**
+     * This method is used to resize the container
+     * It sets the scale of the container based on the global minimum ratio
+     * and repositions the container to the center of the screen.
+     * @public
+     * @returns {void}
+     */
     resize(): void;
+    /**
+     * This method is used to reposition the container to the center of the screen
+     * It sets the x and y position of the container based on the screen width and height.
+     * @protected
+     * @returns {void}
+     */
     protected reposition(): void;
+    /**
+     * This method is used to center the component inside the free spin plate
+     * It sets the x position of the component to the center of the free spin plate.
+     * @protected
+     * @param {Text | Container} component - component to center
+     * @returns {void}
+     */
     protected centerComponent(component: Text | Container): void;
+    /**
+     * This method is used to initialize the positions of the child components
+     * @protected
+     * @abstract
+     * @returns {void}
+     */
     protected abstract initChildPositions(): void;
 }

package/dist/components/AbstractFreeSpinContainer/AbstractFreeSpinContainer.js

@@ -18,16 +18,41 @@ export class AbstractFreeSpinContainer extends Container {
         this.shownAt = performance.now();
         this.parentLayer = UXLayer;
     }
+    /**
+     * This getter enables to remove container after you click Refresh button or you click space
+     * @public
+     * @returns {Promise<void>} function to remove container
+     */
     async onStart() { }
+    /**
+     * This method is used to resize the container
+     * It sets the scale of the container based on the global minimum ratio
+     * and repositions the container to the center of the screen.
+     * @public
+     * @returns {void}
+     */
     resize() {
         this.scale.set(globalMinRatio() * this.scaleMultiplier);
         this.reposition();
         this.initChildPositions();
     }
+    /**
+     * This method is used to reposition the container to the center of the screen
+     * It sets the x and y position of the container based on the screen width and height.
+     * @protected
+     * @returns {void}
+     */
     reposition() {
         this.x = RainMan.app.screen.width / 2 - this.width / 2;
         this.y = RainMan.app.screen.height / 2 - this.height / 2;
     }
+    /**
+     * This method is used to center the component inside the free spin plate
+     * It sets the x position of the component to the center of the free spin plate.
+     * @protected
+     * @param {Text | Container} component - component to center
+     * @returns {void}
+     */
     centerComponent(component) {
         component.x = this.freeSpinPlate.width / 2 - component.width / 2;
     }

package/dist/components/AbstractMainContainer/AbstractMainContainer.d.ts

@@ -26,6 +26,7 @@ import { MessageBox } from "../messageBox";
  * - {@link overlay} - overlay, used when modal is shown
  * - {@link gambleGame} - gamble game
  * @abstract
+ * @class AbstractMainContainer
  * @augments {Container}
  */
 export declare abstract class AbstractMainContainer extends Container {
@@ -63,6 +64,7 @@ export declare abstract class AbstractMainContainer extends Container {
     protected constructor();
     /**
      * Function for invoking mystery win plate
+     * @public
      * @param {string} _animationName - The name of the animation to play.
      * @param {string} _popupAnimation - The name of the popup animation to play.
      * @param {WinTypeId} _winType - The type of win to display.
@@ -73,21 +75,26 @@ export declare abstract class AbstractMainContainer extends Container {
     invokeMysteryWinPlate(_animationName: string, _popupAnimation: string, _winType: WinTypeId, _amount: number, _isAdditionalFreeSpins: boolean): Promise<void>;
     /**
      * This function initializes the spines that should be paused when the battery saver is on
+     * @protected
      * @param {typeof RainMan.settingsStore.containersWithSpines} containersWithSpines - array of containers with spines
+     * @returns {void}
      */
     protected triggerStoreInitState(...containersWithSpines: typeof RainMan.settingsStore.containersWithSpines): void;
     /**
      * Function for getting free spin plate
+     * @public
      * @returns {Nullable<AbstractFreeSpinContainer>} The container for the free spin plate, or null if not set.
      */
     get freeSpinPlate(): Nullable<AbstractFreeSpinContainer>;
     /**
      * Function for getting free spin summary
+     * @public
      * @returns {Nullable<AbstractFreeSpinContainer>} The container for the free spin summary, or null if not set.
      */
     get freeSpinSummary(): Nullable<AbstractFreeSpinContainer>;
     /**
      * Function for creating free spin container
+     * @protected
      * @param {() => void} _resolver - resolver for promise
      * @param {number} _freeSpinCount - number of free spins
      * @param {boolean} _isAdditionalFreeSpin - flag for displaying additional free spins
@@ -96,21 +103,25 @@ export declare abstract class AbstractMainContainer extends Container {
     protected createFreeSpinPlate(_resolver: () => void, _freeSpinCount: number, _isAdditionalFreeSpin: boolean): AbstractFreeSpinContainer | null;
     /**
      * Function for creating bonus win container
+     * @protected
      * @returns {Nullable<UpdatableSpineContainer>} The container for the bonus win animation, or null.
      */
     protected createBonusWinContainer(): Nullable<UpdatableSpineContainer>;
     /**
      * Creates a container for the super bonus win animation.
+     * @protected
      * @returns {UpdatableSpineContainer | null} The container for the super bonus win animation, or null.
      */
     protected createSuperBonusWinContainer(): Nullable<UpdatableSpineContainer>;
     /**
      * Function for creating mystery win container
+     * @protected
      * @returns {Nullable<UpdatableSpineContainer>} The container for the mystery win animation, or null.
      */
     protected createMysteryWinContainer(): Nullable<UpdatableSpineContainer> | MysteryWinContainer;
     /**
      * Function for creating mystery bonus container
+     * @protected
      * @param {string} _animationName - animation name for the mystery bonus container
      * @returns {Nullable<UpdatableSpineContainer>} The container for the mystery bonus animation, or null.
      */
@@ -119,27 +130,34 @@ export declare abstract class AbstractMainContainer extends Container {
      * Function for specifying the container for the free spin summary
      * This needs to be implemented in each game
      * In some cases there will be free spin button that should be removed during free spins
+     * @protected
+     * @returns {void}
      */
     protected changeContainerForFreeSpin(): void;
     /**
      * Function for specifying the container for base game
      * This needs to be implemented in each game
+     * @protected
+     * @returns {void}
      */
     protected changeContainerForBaseGame(): void;
     /**
      * Function for creating roulette win container
+     * @protected
      * @param {string} _animationName animation name for the roulette container
      * @returns {Nullable<UpdatableSpineContainer>} The container for the roulette win animation, or null.
      */
     protected createRouletteContainer(_animationName: string): Nullable<UpdatableSpineContainer>;
     /**
      * Function for destroying the roulette win container
+     * @protected
      * @param {WinTypeId} winType win type of jackpot roulette win
      * @returns {void}
      */
     protected destroyRouletteWin(winType: WinTypeId): void;
     /**
      * Function for invoking mystery bonus container
+     * @protected
      * @param {string} animationName animation name for the mystery bonus container
      * @returns {Promise<void>}
      */
@@ -148,12 +166,15 @@ export declare abstract class AbstractMainContainer extends Container {
      * Function for invoking free spin plate
      * If game draw an additional free spin, you can set isAdditionalFreeSpin to true
      * and it will display additional free spin plate
+     * @public
      * @param {number} freeSpinCount - number of free spins
      * @param {boolean} isAdditionalFreeSpin - flag for displaying additional free spins
+     * @returns {Promise<void>}
      */
     invokeFreeSpinPlate(freeSpinCount: number, isAdditionalFreeSpin?: boolean): Promise<void>;
     /**
      * Function for creating free spin summary
+     * @protected
      * @param {void} _resolver - resolver for promise
      * @param {number} _freeSpinCount - number of free spins
      * @param {number} _winAmount - win amount during free spins
@@ -162,12 +183,15 @@ export declare abstract class AbstractMainContainer extends Container {
     protected createFreeSpinSummary(_resolver: () => void, _freeSpinCount: number, _winAmount: number): AbstractFreeSpinContainer | null;
     /**
      * Function for invoking free spin summary
+     * @public
      * @param {number} freeSpinCount - amount of free spins
      * @param {number} winAmount - win amount during free spins
+     * @returns {Promise<void>}
      */
     invokeFreeSpinSummary(freeSpinCount: number, winAmount: number): Promise<void>;
     /**
      * Function for hiding free spin summary
+     * @public
      * @returns {void}
      */
     hideFreeSpinSummary(): void;
@@ -175,118 +199,164 @@ export declare abstract class AbstractMainContainer extends Container {
      * Function for showing the overlay
      * This function creates a semi-transparent overlay that covers the entire screen.
      * It is used to block interactions with the game while a modal is displayed.
+     * @protected
+     * @returns {void}
      */
     protected showOverlay(): void;
     /**
      * Function for hiding the overlay
      * This function removes the overlay from the main container and sets it to null.
+     * @protected
+     * @returns {void}
      */
     protected hideOverlay(): void;
     /**
      * Function for getting the time since the big win was invoked.
+     * @public
      * @returns {number} The time in milliseconds since the big win was invoked, or 0 if it has not been invoked.
      */
     get bigWinVisibleFor(): number;
     /**
      * Function for getting the free spin button.
+     * @public
      * @returns {typeof this.freeSpinButton} The free spin button instance.
      */
     getFreeSpinButton(): typeof this.freeSpinButton;
     /**
      * Function for getting the time since the mystery win was invoked.
+     * @public
      * @returns {number} The time in milliseconds since the mystery win was invoked, or 0 if it has not been invoked.
      */
     get mysteryWinVisibleFor(): number;
     /**
      * Function for getting the time since the bonus win was invoked.
+     * @public
      * @returns {number} The time in milliseconds since the bonus win was invoked, or 0 if it has not been invoked.
      */
     get bonusWinVisibleFor(): number;
     /**
      * Function for getting the time since the super bonus win was invoked.
+     * @public
      * @returns {number} The time in milliseconds since the super bonus win was invoked, or 0 if it has not been invoked.
      */
     get superBonusWinVisibleFor(): number;
     /**
      * Abstract function for creating the big win container.
      * This function should be implemented in each game to create a specific big win container.
+     * @protected
+     * @abstract
+     * @returns {UpdatableSpineContainer | MysteryWinContainer} big win container
      */
     protected abstract createBigWinContainer(): UpdatableSpineContainer | MysteryWinContainer;
     /**
      * Function for invoking big win animation, using `this.createBigWinContainer()` abstract function.
+     * @public
+     * @returns {void}
      */
     invokeBigWin(): void;
     /**
      * Function for invoking big win animation, using `this.createSuperBonusWinContainer()` abstract function.
+     * @public
+     * @returns {void}
      */
     invokeSuperBonusWin(): void;
     /**
      * Function for invoking big win animation, using `this.createBonusWinContainer()` abstract function.
+     * @public
+     * @returns {void}
      */
     invokeBonusWin(): void;
     /**
      * Function for invoking mystery win animation, using `this.createMysteryWinContainer()` abstract function.
+     * @public
+     * @returns {void}
      */
     invokeMysteryWin(): void;
     /**
      * Function for destroying the big win container
      * This function removes the big win container from the main container,
      * destroys its animations, and sets it to null.
+     * @public
+     * @returns {void}
      */
     destroyBigWin(): void;
     /**
      * Function for destroying the mystery win container
+     * @public
+     * @returns {void}
      */
     destroyMysteryWin(): void;
     /**
      * Function for destroying the bonus win container
+     * **NOTE**: This is used in game like LDE/LP, where there is different behavior for bonus wins
+     * @public
+     * @returns {void}
      */
     destroyBonusWin(): void;
     /**
      * Function for destroying the super bonus win container
+     * **NOTE**: This is used in game like LDE/LP, where there is different behavior for super bonus wins
+     * @public
+     * @returns {void}
      */
     destroySuperBonusWin(): void;
+    /**
+     * This is used in game like DC where we have container that draws the bonus or jackpots
+     * @public
+     * @returns {void}
+     */
     destroyMysteryBonus(): void;
     /**
      * Function for invoking gamble game
+     * @public
      * @returns {Promise<void>} - A promise that resolves when the gamble game is finished.
      */
     invokeGambleGame(): Promise<void>;
     /**
      * Function for creating the under frame panel.
      * This panel is used in mobile portrait mode to display additional information.
+     * @protected
      * @returns {Graphics | Sprite} The under frame panel as a Graphics or Sprite object.
      */
     protected createUnderFramePanel(): Graphics | Sprite;
     /**
      * Function for enabling mobile portrait mode.
      * It creates the under frame panel, portrait play buttons, and adds them to the container.
+     * @public
      * @returns {void}
      */
     enableForMobile(): void;
     /**
      * Function for enabling landscape mode.
+     * @public
      * @returns {void}
      */
     enableForLandscape(): void;
     /**
      * Function for positioning the round win container.
+     * @protected
      * @returns {void}
      */
     protected positionRoundWinContainer(): void;
     /**
      * Function for invoking the roulette win plate.
+     * @public
      * @param {string} winAnimationName The name of the win animation.
      * @param {WinTypeId} winType The type of win.
      * @param {string} startAnimationName The name of the start animation defaulting to "start".
+     * @returns {Promise<void>}
      */
     invokeRouletteWinPlate(winAnimationName: string, winType: WinTypeId, startAnimationName?: string): Promise<void>;
     /**
      * Function for disabling components for mobile portrait orientation.
+     * @public
+     * @returns {void}
      */
     disableForMobile(): void;
     /**
      * Function for disabling components for landscape orientation.
+     * @public
+     * @returns {void}
      */
     disableForLandscape(): void;
     /**
@@ -294,31 +364,38 @@ export declare abstract class AbstractMainContainer extends Container {
      * This function should be implemented in each game.
      * @protected
      * @abstract
+     * @returns {void}
      */
     protected abstract repositionComponentsForScreenRatio(): void;
     /**
      * Function for resizing the main container and its components.
      * This function removes the current frame and any win containers,
      * resizes the message box, background, animated front,
+     * @public
+     * @returns {void}
      */
     resize(): void;
     /**
      * Function for creating the left buttons
+     * @protected
      * @returns {LeftButtons} - Returns a new instance of LeftButtons.
      */
     protected createLeftButtons(): LeftButtons;
     /**
      * Function for creating the right buttons
+     * @protected
      * @returns {RightButtons} - Returns a new instance of RightButtons.
      */
     protected createRightButtons(): RightButtons;
     /**
      * Function for creating the left buttons for mobile portrait orientation
+     * @protected
      * @returns {LeftButtonsMobile} - Returns a new instance of LeftButtonsMobile for mobile portrait orientation.
      */
     protected createLeftButtonsMobile(): LeftButtonsMobile;
     /**
      * Function for creating the right buttons for mobile portrait orientation
+     * @protected
      * @returns {RightButtonsMobile} - Returns a new instance of RightButtonsMobile for mobile portrait orientation.
      */
     protected createRightButtonsMobile(): RightButtonsMobile;
@@ -351,9 +428,9 @@ export declare abstract class AbstractMainContainer extends Container {
      * It checks the current device orientation and creates the appropriate left and right buttons.
      * It also removes the previous left and right buttons from the container.
      * It resizes the right buttons if the current orientation is "mobile-portrait".
-     * @protected
-     * @returns {void}
+     * @private
      * @memberof AbstractMainContainer
+     * @returns {void}
      */
     private initComponentsForScreenRatio;
     /**
@@ -362,11 +439,15 @@ export declare abstract class AbstractMainContainer extends Container {
      * under frame panel, overlay, big win container, super bonus win container, bonus win container,
      * mystery win container, gamble game, bottom panel, free spin plate, and
      * free spin summary.
+     * @private
+     * @returns {void}
      */
     private resizeDependentComponents;
     /**
      * This method is used to refresh the layers in the main container.
      * It removes the existing layers and adds them back in the correct order.
+     * @protected
+     * @returns {void}
      */
     protected refreshLayers(): void;
 }