pixi-rainman-game-engine 0.3.0 → 0.3.2

package/dist/components/frame/AbstractColumnsContainer.js

@@ -48,6 +48,8 @@ export class AbstractColumnsContainer extends Container {
     /**
      * Function for resolving changing symbols in columns
      * This is used in games i.e. BoW and MB
+     * @public
+     * @returns {void}
      */
     resolveMysterySpeedUp() {
         this.allColumns.forEach((column) => {
@@ -58,8 +60,9 @@ export class AbstractColumnsContainer extends Container {
     }
     /**
      * Method for adapting to speed level
-     * @param {SpeedLevel} speedLevel new speed level
      * @public
+     * @param {SpeedLevel} speedLevel new speed level
+     * @returns {void}
      */
     adaptToSpeed(speedLevel) {
         this.velocityMultiplier = this.speedLevelMapper[speedLevel];
@@ -82,6 +85,7 @@ export class AbstractColumnsContainer extends Container {
     /**
      * Function for clearing quick reels stop
      * @public
+     * @returns {void}
      */
     clearQuickReelsStop() {
         this.quickReelsStop = false;
@@ -90,6 +94,7 @@ export class AbstractColumnsContainer extends Container {
     /**
      * Function for blind spinning all columns
      * @public
+     * @returns {void}
      */
     blindSpin() {
         this.allColumns.forEach((column) => column.blindSpin());
@@ -144,11 +149,11 @@ export class AbstractColumnsContainer extends Container {
     }
     /**
      * Function for playing all streaks
+     * @public
      * @param {StreakReelsIndexes[]} streaks - The streaks to play
      * @param {number} amount - The amount to play
      * @param {SymbolId[]} allSymbols - All symbols to consider
      * @returns {Promise<void>} - A promise that resolves when all streaks are played
-     * @public
      */
     async playAllStreaks(streaks, amount, allSymbols = []) {
         const columnsToPlay = [];
@@ -179,7 +184,7 @@ export class AbstractColumnsContainer extends Container {
     }
     /**
      * Function for playing sound depending on the amount
-     * @public
+     * @protected
      * @param {number} amount - The amount to check
      * @param {SymbolId[]} _allSymbols - All symbols to consider
      * @returns {void}
@@ -204,6 +209,12 @@ export class AbstractColumnsContainer extends Container {
             return;
         }
     }
+    /**
+     * Function for playing streak sounds
+     * @protected
+     * @param {SymbolId[]} symbols symbols of the streak
+     * @returns {void}
+     */
     playStreakSound(symbols) {
         for (const [symbol, sound] of Object.entries(this.mapSymbolToSound)) {
             if (!symbols.includes(symbol))
@@ -282,8 +293,8 @@ export class AbstractColumnsContainer extends Container {
     }
     /**
      * Function for setting interactivity for all symbols in columns
-     * @param {boolean} flag - flag for setting interactivity
      * @public
+     * @param {boolean} flag - flag for setting interactivity
      * @returns {void}
      */
     setInteractivityForSymbols(flag) {
@@ -291,6 +302,7 @@ export class AbstractColumnsContainer extends Container {
     }
     /**
      * Function for handling multiple symbol transformations
+     * @public
      * @param {DropTransformationDetails} transformations - array of transformations to apply
      * @param {boolean} skipAnimations - flag for skipping animations
      * @param {boolean} isStandalone - flag for standalone mode
@@ -321,12 +333,14 @@ export class AbstractColumnsContainer extends Container {
     /**
      * Function for fixing symbols columns position
      * @public
+     * @returns {void}
      */
     fixSymbolsColumnsPosition() {
         this.allColumns.forEach((column) => column.fixStationaryPositions());
     }
     /**
      * Function for preparing configuring reels end
+     * @protected
      * @param {SymbolReels} finalSymbolReels - final symbol reels
      * @returns {PlayableAction[]} - array of playable actions
      */

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

@@ -33,41 +33,137 @@ export declare abstract class AbstractFrame extends ResumableContainer implement
     protected winLineAnimations: WinLineAnimation[];
     protected mysteryFxCoordinates: MysteryFxCoordinates;
     protected constructor(spineName: string);
+    /**
+     * Getter for columns container
+     * @public
+     * @returns {AbstractColumnsContainer} - columns container
+     */
     get columnsContainer(): AbstractColumnsContainer;
+    /**
+     * Function for adapting speed of animations and spinning in columns
+     * @public
+     * @param {SpeedLevel} speedLevel new speed level to adapt to
+     * @returns {void}
+     */
     adaptToSpeed(speedLevel: SpeedLevel): void;
     /**
      * Invoke mystery fx on symbol position
+     * @public
      * @param {number} x - x position of reel
      * @param {number} y - y position of reel
+     * @returns {void}
      */
     invokeMysteryFx(x: number, y: number): void;
+    /**
+     * Function for repositioning the mystery FX
+     * This needs to be implemented in games with free spins
+     * If don't you this should not be implemented
+     * @protected
+     * @param {number} _x - x position of the mystery FX
+     * @param {number} _y - y position of the mystery FX
+     * @returns {void}
+     */
     protected repositionMysteryFx(_x: number, _y: number): void;
+    /**
+     * Function for playing jackpot animation
+     * @public
+     * @param {WinTypeId} _type type of the win
+     * @returns {void}
+     */
     playJackpotAnimation(_type: WinTypeId): void;
+    /**
+     * Function for hiding the mystery effect
+     * @public
+     * @returns {void}
+     */
     hideMysteryFx(): void;
+    /**
+     * Function that resets the mystery effect coordinates
+     * @private
+     * @returns {void}
+     */
     private resetMysteryFxCoordinates;
+    /**
+     * Function for destroying the mystery effect
+     * @public
+     * @returns {void}
+     */
     destroyMysteryFx(): void;
+    /**
+     * Function for resetting the bonus indicators
+     * @public
+     * @param {BonusIndicatorTypes} _type type of the bonus indicator
+     * @returns {void}
+     */
     resetBonusIndicators(_type: BonusIndicatorTypes): void;
     /**
      * Create win line animation, individual for each game, based on {@link WinLineAnimation}
+     * @protected
+     * @returns {WinLineAnimation | null} - win line animation or null if not implemented
      */
     protected createWinLineAnimation(_animationName: string): WinLineAnimation | null;
+    /**
+     * Function for playing all of the win line animations
+     * @public
+     * @param {string[]} animationNames - names of the animations to play
+     * @returns {Promise<void>}
+     */
     playAllWinLineAnimations(animationNames: string[]): Promise<void>;
     /**
      * Creates and plays win line animation.
+     * @public
      * @param {string} animationName - name of the winning line to play
+     * @returns {Promise<void>}
      */
     playWinLineAnimation(animationName: string): Promise<void>;
+    /**
+     * Function for stopping all of the win line animations
+     * @public
+     * @returns {void}
+     */
     stopPlayingWinLineAnimations(): void;
+    /**
+     * Function for checking if any win line animation is currently playing
+     * @public
+     * @returns {boolean} true if any win line animation is playing, false otherwise
+     */
     isPlayingWinLineAnimation(): boolean;
+    /**
+     * This function is called when the frame orientation changes
+     * This function should be implemented in each game
+     * @protected
+     * @abstract
+     * @returns {void}
+     */
     protected abstract changeFrameForOrientation(): void;
+    /**
+     * Function for setting the frame animation
+     * @protected
+     * @param {string} spineName - name of the spine
+     * @param {string} animationName - name of the animation
+     * @returns {void}
+     */
     protected setFrame(spineName: string, animationName: string): void;
+    /**
+     * Function for resizing the frame
+     * @public
+     * @returns {void}
+     */
     resize(): void;
+    /**
+     * Function for repositioning the frame
+     * This function should be implemented in each game
+     * @protected
+     * @abstract
+     * @returns {void}
+     */
     protected abstract reposition(): void;
     /**
      * This method is use when bonus games are triggered
      * It is used to change the frame animation
      * Remember to change resize for this method
      * @protected
+     * @returns {void}
      */
     protected changeForBonusGame(): void;
     /**
@@ -75,12 +171,31 @@ export declare abstract class AbstractFrame extends ResumableContainer implement
      * It is used to change the frame animation
      * Remember to change resize for this method
      * @abstract
+     * @returns {void}
      */
     protected changeForNormalGame(): void;
+    /**
+     * This should be implemented on each game
+     * This determinate the scale of the {@link AbstractInnerFrame} and columns
+     * The scale should be determine for every device orientation
+     * @protected
+     * @abstract
+     * @returns {{ vertical: number; horizontal: number }} - The scale factors for the inner frame and columns
+     */
     protected abstract getFrameScale(): {
         vertical: number;
         horizontal: number;
     };
+    /**
+     * Function for getting the transformed width of the frame
+     * @private
+     * @returns {number} - The transformed width
+     */
     private transformedWidth;
+    /**
+     * Function for getting the transformed height of the frame
+     * @private
+     * @returns {number} - The transformed height
+     */
     private transformedHeight;
 }

package/dist/components/frame/AbstractFrame.js

@@ -28,20 +28,34 @@ export class AbstractFrame extends ResumableContainer {
         this.parentLayer = FrameLayer;
         this.frameAnimation = new Spine(getSpineData(spineName));
     }
+    /**
+     * Getter for columns container
+     * @public
+     * @returns {AbstractColumnsContainer} - columns container
+     */
     get columnsContainer() {
         return this.innerFrame.columnsContainer;
     }
+    /**
+     * Function for adapting speed of animations and spinning in columns
+     * @public
+     * @param {SpeedLevel} speedLevel new speed level to adapt to
+     * @returns {void}
+     */
     adaptToSpeed(speedLevel) {
         this.velocityMultiplier = this.speedLevelMapper[speedLevel];
     }
     /**
      * Invoke mystery fx on symbol position
+     * @public
      * @param {number} x - x position of reel
      * @param {number} y - y position of reel
+     * @returns {void}
      */
     invokeMysteryFx(x, y) {
-        if (!this.mysteryFxConfig)
+        if (!this.mysteryFxConfig) {
             return;
+        }
         if (this.mysteryFxHighlight) {
             SoundManager.pause(SoundTracks.mysteryFxLoop);
             this.removeChild(this.mysteryFxHighlight);
@@ -59,11 +73,32 @@ export class AbstractFrame extends ResumableContainer {
         });
         this.addChild(this.mysteryFxHighlight);
     }
+    /**
+     * Function for repositioning the mystery FX
+     * This needs to be implemented in games with free spins
+     * If don't you this should not be implemented
+     * @protected
+     * @param {number} _x - x position of the mystery FX
+     * @param {number} _y - y position of the mystery FX
+     * @returns {void}
+     */
     repositionMysteryFx(_x, _y) { }
+    /**
+     * Function for playing jackpot animation
+     * @public
+     * @param {WinTypeId} _type type of the win
+     * @returns {void}
+     */
     playJackpotAnimation(_type) { }
+    /**
+     * Function for hiding the mystery effect
+     * @public
+     * @returns {void}
+     */
     hideMysteryFx() {
-        if (!this.mysteryFxConfig)
+        if (!this.mysteryFxConfig) {
             return;
+        }
         if (!this.mysteryFxConfig.endAnimationName) {
             SoundManager.stop(SoundTracks.mysteryFxLoop);
             return;
@@ -76,9 +111,19 @@ export class AbstractFrame extends ResumableContainer {
             return;
         }
     }
+    /**
+     * Function that resets the mystery effect coordinates
+     * @private
+     * @returns {void}
+     */
     resetMysteryFxCoordinates() {
         this.mysteryFxCoordinates = { x: 0, y: 0 };
     }
+    /**
+     * Function for destroying the mystery effect
+     * @public
+     * @returns {void}
+     */
     destroyMysteryFx() {
         if (this.mysteryFxHighlight) {
             SoundManager.stop(SoundTracks.mysteryFxLoop);
@@ -87,19 +132,35 @@ export class AbstractFrame extends ResumableContainer {
             this.mysteryFxHighlight = null;
         }
     }
+    /**
+     * Function for resetting the bonus indicators
+     * @public
+     * @param {BonusIndicatorTypes} _type type of the bonus indicator
+     * @returns {void}
+     */
     resetBonusIndicators(_type) { }
     /**
      * Create win line animation, individual for each game, based on {@link WinLineAnimation}
+     * @protected
+     * @returns {WinLineAnimation | null} - win line animation or null if not implemented
      */
     createWinLineAnimation(_animationName) {
         return null;
     }
+    /**
+     * Function for playing all of the win line animations
+     * @public
+     * @param {string[]} animationNames - names of the animations to play
+     * @returns {Promise<void>}
+     */
     async playAllWinLineAnimations(animationNames) {
         await Promise.allSettled(animationNames.map((animationName) => this.playWinLineAnimation(animationName)));
     }
     /**
      * Creates and plays win line animation.
+     * @public
      * @param {string} animationName - name of the winning line to play
+     * @returns {Promise<void>}
      */
     async playWinLineAnimation(animationName) {
         const winLineAnimation = this.createWinLineAnimation(animationName);
@@ -114,13 +175,30 @@ export class AbstractFrame extends ResumableContainer {
         this.removeChild(winLineAnimation);
         this.stopPlayingWinLineAnimations();
     }
+    /**
+     * Function for stopping all of the win line animations
+     * @public
+     * @returns {void}
+     */
     stopPlayingWinLineAnimations() {
         this.winLineAnimations.map((winLineAnimation) => winLineAnimation.resolvePlayingPromise());
         this.winLineAnimations = [];
     }
+    /**
+     * Function for checking if any win line animation is currently playing
+     * @public
+     * @returns {boolean} true if any win line animation is playing, false otherwise
+     */
     isPlayingWinLineAnimation() {
         return this.winLineAnimations.length > 0;
     }
+    /**
+     * Function for setting the frame animation
+     * @protected
+     * @param {string} spineName - name of the spine
+     * @param {string} animationName - name of the animation
+     * @returns {void}
+     */
     setFrame(spineName, animationName) {
         this.columnsContainer.doResize();
         this.frameAnimation = new Spine(getSpineData(spineName));
@@ -130,6 +208,11 @@ export class AbstractFrame extends ResumableContainer {
         this.addChild(this.frameAnimation);
         this.addChild(this.innerFrame);
     }
+    /**
+     * Function for resizing the frame
+     * @public
+     * @returns {void}
+     */
     resize() {
         if (this.mysteryFxHighlight) {
             SoundManager.pause(SoundTracks.mysteryFxLoop);
@@ -158,6 +241,7 @@ export class AbstractFrame extends ResumableContainer {
      * It is used to change the frame animation
      * Remember to change resize for this method
      * @protected
+     * @returns {void}
      */
     changeForBonusGame() { }
     /**
@@ -165,11 +249,22 @@ export class AbstractFrame extends ResumableContainer {
      * It is used to change the frame animation
      * Remember to change resize for this method
      * @abstract
+     * @returns {void}
      */
     changeForNormalGame() { }
+    /**
+     * Function for getting the transformed width of the frame
+     * @private
+     * @returns {number} - The transformed width
+     */
     transformedWidth() {
         return RainMan.app.screen.width * this.getFrameScale().horizontal;
     }
+    /**
+     * Function for getting the transformed height of the frame
+     * @private
+     * @returns {number} - The transformed height
+     */
     transformedHeight() {
         return RainMan.app.screen.height * this.getFrameScale().vertical;
     }

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

@@ -11,5 +11,10 @@ export declare abstract class AbstractInnerFrame extends Container {
     static readonly registryName = "innerFrame";
     protected abstract _columnsContainer: AbstractColumnsContainer;
     protected constructor();
+    /**
+     * Getter for columns container
+     * @public
+     * @returns {AbstractColumnsContainer} - The columns container
+     */
     get columnsContainer(): AbstractColumnsContainer;
 }

package/dist/components/frame/AbstractInnerFrame.js

@@ -14,6 +14,11 @@ export class AbstractInnerFrame extends Container {
         this.name = AbstractInnerFrame.registryName;
         this.parentLayer = FrameLayer;
     }
+    /**
+     * Getter for columns container
+     * @public
+     * @returns {AbstractColumnsContainer} - The columns container
+     */
     get columnsContainer() {
         return this._columnsContainer;
     }

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

@@ -11,6 +11,16 @@ export declare class WinLineAnimation extends Spine {
     private readonly velocityMultiplier;
     private resolver?;
     constructor(spineName: string, animationName: string, velocityMultiplier: number);
+    /**
+     * Function for playing the win line animation
+     * @public
+     * @returns {Promise<void>} - A promise that resolves when the animation is complete
+     */
     play(): Promise<void>;
+    /**
+     * Resolves the promise when the animation is complete
+     * @public
+     * @returns {void}
+     */
     resolvePlayingPromise(): void;
 }

package/dist/components/frame/WinLineAnimation.js

@@ -18,6 +18,11 @@ export class WinLineAnimation extends Spine {
         this.animationName = animationName;
         this.velocityMultiplier = velocityMultiplier;
     }
+    /**
+     * Function for playing the win line animation
+     * @public
+     * @returns {Promise<void>} - A promise that resolves when the animation is complete
+     */
     async play() {
         if (this.animationName.length < RainMan.config.numberOfColumns)
             return;
@@ -31,9 +36,15 @@ export class WinLineAnimation extends Spine {
             });
         });
     }
+    /**
+     * Resolves the promise when the animation is complete
+     * @public
+     * @returns {void}
+     */
     resolvePlayingPromise() {
-        if (!this.resolver)
+        if (!this.resolver) {
             return;
+        }
         this.resolver();
         this.resolver = undefined;
     }

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

@@ -9,6 +9,9 @@ export declare const WIN_MULTIPLIER_VALUES: {
     readonly HIGH_WIN_MAX: 15;
     readonly VERY_HIGH_WIN: 15.1;
 };
+/**
+ * Object containing the values for the bonus indicators.
+ */
 export declare const BONUS_INDICATORS: {
     readonly joker: "joker";
     readonly freeSpins: "freeSpins";
@@ -21,4 +24,8 @@ export declare const BONUS_INDICATORS: {
  * @typedef {WinMultiplierValues}
  */
 export type WinMultiplierValues = (typeof WIN_MULTIPLIER_VALUES)[keyof typeof WIN_MULTIPLIER_VALUES];
+/**
+ * Type for the bonus indicator types.
+ * @typedef {BonusIndicatorTypes}
+ */
 export type BonusIndicatorTypes = (typeof BONUS_INDICATORS)[keyof typeof BONUS_INDICATORS];

package/dist/components/frame/constants.js

@@ -9,6 +9,9 @@ export const WIN_MULTIPLIER_VALUES = {
     HIGH_WIN_MAX: 15,
     VERY_HIGH_WIN: 15.1
 };
+/**
+ * Object containing the values for the bonus indicators.
+ */
 export const BONUS_INDICATORS = {
     joker: "joker",
     freeSpins: "freeSpins",

package/dist/components/index.d.ts

@@ -3,6 +3,7 @@ export * from "./AbstractMainContainer";
 export * from "./buttons";
 export * from "./common";
 export * from "./dictionary";
+export * from "./DoubleBorderText";
 export * from "./frame";
 export * from "./GambleGame";
 export * from "./messageBox";

package/dist/components/index.js

@@ -3,6 +3,7 @@ export * from "./AbstractMainContainer";
 export * from "./buttons";
 export * from "./common";
 export * from "./dictionary";
+export * from "./DoubleBorderText";
 export * from "./frame";
 export * from "./GambleGame";
 export * from "./messageBox";

package/dist/components/messageBox/MessageBox.d.ts

@@ -34,31 +34,45 @@ export declare class MessageBox extends Container {
     constructor();
     /**
      * Updates the incentive text displayed in the message box.
+     * @public
      * @param {string} newText - The new text to display.
+     * @returns {void}
      */
     updateIncentiveText(newText: string): void;
     /**
      * Function for hiding current win text
+     * @public
+     * @returns {void}
      */
     hideCurrentWinText(): void;
     /**
      * Function fro hiding possible win text
+     * @public
+     * @returns {void}
      */
     hidePossibleWinText(): void;
     /**
      * Function for hiding free spin text
+     * @public
+     * @returns {void}
      */
     hideFreeSpinText(): void;
     /**
      * Function for hiding auto spin text
+     * @public
+     * @returns {void}
      */
     hideAutoSpinText(): void;
     /**
      * Function for hiding incentive text
+     * @public
+     * @returns {void}
      */
     hideIncentiveText(): void;
     /**
      * Function for hiding win line indicator
+     * @public
+     * @returns {void}
      */
     hideWinLineIndicator(): void;
     /**
@@ -66,24 +80,35 @@ export declare class MessageBox extends Container {
      * It sets the scale of the message box to the global minimum ratio.
      * If the device orientation is mobile and the win line indicator is shown, it repositions
      * the win line indicator to ensure it is displayed correctly.
+     * @public
      * @memberof MessageBox
+     * @returns {void}
      */
     resize(): void;
     /**
      * Getter for the height of the win line animation.
      * If the win line indicator is not defined, it returns 0.
+     * @public
      * @returns {number} The height of the win line animation.
      */
     get winLineAnimationHeight(): number;
     /**
      * Displays the current win text in the message box.
+     * @public
      * @returns {void}
      */
     showCurrentWinText(): void;
+    /**
+     * Displays the possible win text in the message box.
+     * It also checks if the text is already shown.
+     * @public
+     * @returns {void}
+     */
     showPossibleWinText(): void;
     /**
      * Displays the auto spin text in the message box.
      * It checks if auto spins are enabled and if the text is already shown.
+     * @public
      * @returns {void}
      */
     showAutoSpinText(): void;
@@ -91,18 +116,26 @@ export declare class MessageBox extends Container {
      * Displays the free spin text in the message box.
      * It checks if free spins are enabled and if the text is already shown.
      * If free spin text is disabled in the configuration, it does nothing.
+     * @public
      * @returns {void}
      */
     showFreeSpinText(): void;
+    /**
+     * Displays the incentive text in the message box.
+     * @public
+     * @returns {void}
+     */
     showIncentiveText(): void;
     /**
      * Function to center a text component on the X-axis of the message box.
+     * @private
      * @param {Container | undefined} component container component to center
      * @returns {void}
      */
     private centerTextOnX;
     /**
      * Displays the win line indicator in the message box.
+     * @public
      * @param {string} message The message to display.
      * @param {(symbolId: SymbolId, suffix?: string) => string} getImageForSymbolId Function to get the image for a symbol ID.
      * @param {SymbolId[]} symbolIds The symbol IDs to display.