pixi-rainman-game-engine 0.1.8 → 0.1.10

package/dist/DescribedPlayableAction/DescribedPlayableAction.d.ts

@@ -1,8 +1,9 @@
 import { Nullable, PlayableAction } from "../utils";
-export declare class DescribedPlayableAction<T = number> {
+export declare class DescribedPlayableAction<T> {
     readonly type: T;
     action: PlayableAction;
     winAmount: Nullable<number>;
+    skipLooping: boolean;
     isFirstStreak: boolean;
-    constructor(type: T, action: PlayableAction, winAmount?: Nullable<number>);
+    constructor(type: T, action: PlayableAction, winAmount?: Nullable<number>, skipLooping?: boolean);
 }

package/dist/DescribedPlayableAction/DescribedPlayableAction.js

@@ -2,10 +2,12 @@ export class DescribedPlayableAction {
     type;
     action;
     winAmount;
+    skipLooping;
     isFirstStreak = false;
-    constructor(type, action, winAmount = null) {
+    constructor(type, action, winAmount = null, skipLooping = false) {
         this.type = type;
         this.action = action;
         this.winAmount = winAmount;
+        this.skipLooping = skipLooping;
     }
 }

package/dist/Money/MoneyText.js

@@ -10,9 +10,9 @@ import { RainMan } from "../Rainman";
 export class MoneyText {
     money;
     constructor(amount) {
-        this.money = Money.fromDecimal(amount, RainMan.currency, Math.round);
+        this.money = Money.fromDecimal(amount, RainMan.globals.currency, Math.round);
     }
     toString() {
-        return `${this.money} ${RainMan.currency.symbol_native}`;
+        return `${this.money} ${RainMan.globals.currency.symbol_native}`;
     }
 }

package/dist/Rainman/Rainman.d.ts

@@ -1,10 +1,9 @@
 import "../components/dictionary/i18n";
 import { Application } from "pixi.js";
-import { Currency } from "ts-money";
 import { SpinLogicFactory, SymbolIds, WinTypeIds } from "../application";
 import { ComponentRegistry } from "../ComponentRegistry";
 import { SettingsStore } from "../stores";
-import { AppConfig, OptionalAppConfig, RequiredAppConfig } from "./types";
+import { AppConfig, Globals, OptionalAppConfig, RequiredAppConfig } from "./types";
 export declare class RainMan {
     static app: Application;
     static config: RequiredAppConfig & OptionalAppConfig;
@@ -13,6 +12,6 @@ export declare class RainMan {
     static settingsStore: SettingsStore;
     static componentRegistry: ComponentRegistry;
     static spinLogicFactory: SpinLogicFactory;
-    static currency: Currency;
+    static globals: Globals;
     constructor(app: Application, config: AppConfig, symbolIds: SymbolIds, winTypeIds: WinTypeIds, spinLogicFactory: SpinLogicFactory);
 }

package/dist/Rainman/Rainman.js

@@ -12,7 +12,7 @@ export class RainMan {
     static settingsStore;
     static componentRegistry;
     static spinLogicFactory;
-    static currency;
+    static globals;
     constructor(app, config, symbolIds, winTypeIds, spinLogicFactory) {
         RainMan.app = app;
         RainMan.config = merge(defaultAppConfig, config);
@@ -21,6 +21,8 @@ export class RainMan {
         RainMan.settingsStore = settingStore;
         RainMan.componentRegistry = new ComponentRegistry(app);
         RainMan.spinLogicFactory = spinLogicFactory;
-        RainMan.currency = Currencies["USD"];
+        RainMan.globals = {
+            currency: Currencies["USD"],
+        };
     }
 }

package/dist/Rainman/appConfig.js

@@ -12,9 +12,9 @@ export const defaultAppConfig = {
     fontSize: 35,
     mobileFontSize: 45,
     updatableSpineContainerFontSize: 50,
-    fontColor: new Color(0xfbd400).toHex(),
     updatableTextValueColor: new Color(0xffffff).toHex(),
     fontFace: ["HelveticaNeueLTStd"],
+    winLineIndicatorSymbolScale: 0.75,
     durationOfActions: {
         eachColumnsSpinDelay: [0, 200, 700, 1200, 1800],
         spinBaseTime: 800,
@@ -43,5 +43,6 @@ export const defaultAppConfig = {
     },
     constants: {
         bigWinMultiplier: 30,
+        bigWinTextOffset: 0,
     },
 };

package/dist/Rainman/types.d.ts

@@ -1,3 +1,4 @@
+import { Currency } from "ts-money";
 import { DeepPartial } from "../utils";
 export type RequiredAppConfig = {
     websocketUrl: string;
@@ -6,6 +7,8 @@ export type RequiredAppConfig = {
     gameInitReference: string;
     numberOfColumns: number;
     numberOfRows: number;
+    fontColor: string;
+    autoplayGlowColor: number;
 };
 export type OptionalAppConfig = {
     gameWidth: number;
@@ -14,9 +17,11 @@ export type OptionalAppConfig = {
     fontSize: number;
     updatableSpineContainerFontSize: number;
     mobileFontSize: number;
-    fontColor: string;
+    mobileFontColor?: string;
     updatableTextValueColor: string;
     fontFace: string[];
+    mobileFontFace?: string[];
+    winLineIndicatorSymbolScale: number;
     durationOfActions: {
         eachColumnsSpinDelay: number[];
         spinBaseTime: number;
@@ -45,6 +50,11 @@ export type OptionalAppConfig = {
     };
     constants: {
         bigWinMultiplier: number;
+        bigWinTextOffset: number;
     };
 };
 export type AppConfig = RequiredAppConfig & DeepPartial<OptionalAppConfig>;
+export interface Globals {
+    currency: Currency;
+    throttledSpin?: () => void;
+}

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

@@ -1,6 +1,7 @@
 import i18next from "i18next";
 import { upperFirst } from "lodash";
 import React from "react";
+import { RainMan } from "../../../Rainman";
 import { UI_ITEMS } from "../../../utils";
 import { useStores } from "../../hooks";
 import { closeModal } from "../CloseModalButton";
@@ -22,6 +23,7 @@ export const OptionButton = ({ option, currency, setMessage }) => {
             settingStore.setIsFreeSpinBought(true, data);
             settingStore.setRoundNumber(data.getRawData().round_number);
             settingStore.setFreeSpinNumberBought(option.amount);
+            RainMan.globals.throttledSpin?.();
             closeModal(UI_ITEMS.freeSpin);
         }
         catch (err) {

package/dist/SettingsUI/index.css

@@ -131,7 +131,7 @@ body {
     position: fixed;
     width: 100%;
     height: 100%;
-    background: url("../assets/images/swipe-up.png") no-repeat 50% 50%;
+    background: url("../assets/images/materials/swipe-up.png") no-repeat 50% 50%;
     background-size: 150px;
     animation: iosAnimMove 1.5s ease-out infinite;
 }

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

@@ -1,4 +1,5 @@
-import { InitDataInterface } from "../../connectivity";
+import { InitDataInterface, SpinDataInterface } from "../../connectivity";
+import { AdaptedSpinResponse } from "../SpinLogic";
 import { SymbolId } from "./SymbolId";
 import { TransformationTypeId } from "./TransformationTypesId";
 import { WinTypeId } from "./WinTypeId";
@@ -22,14 +23,23 @@ export declare class ApiConfig {
      * @param {InitDataInterface} data
      */
     constructor(data: InitDataInterface);
+    /**
+     * Function to generate metadata for a particular spin
+     *
+     * @public
+     * @param {SpinDataInterface} spinLogicResponse
+     * @returns AdaptedSpinResponse without results and standalone results, these should be created in each game
+     */
+    generateMetadata(spinLogicResponse: SpinDataInterface): Omit<AdaptedSpinResponse, "results" | "standaloneTransformations">;
     /**
      * Getter for win line number
      *
      * @public
      * @param winLineAnimationName
+     * @param defaultNumber
      * @returns {string | number}
      */
-    getWinLineNumber(winLineAnimationName: string): number | string;
+    getWinLineNumber(winLineAnimationName: string, defaultNumber?: string): number | string;
     /**
      * Function for getting next bet from config
      *
@@ -91,9 +101,9 @@ export declare class ApiConfig {
      *
      * @public
      * @param {number[][]} symbols_on_reels
-     * @returns {SymbolId[]}
+     * @returns {SymbolId[][]}
      */
-    mapSymbolIdsToSymbolNames(symbols_on_reels: number[][]): SymbolId[];
+    mapSymbolIdsToSymbolNames(symbols_on_reels: number[][]): SymbolId[][];
     /**
      * Getter for bet that placed in current position
      *

package/dist/application/ApiConfig/ApiConfig.js

@@ -1,5 +1,6 @@
 import { RainMan } from "../../Rainman";
 import { logError } from "../../utils";
+import { isBlindsConfiguredByTransformations } from "../SpinLogic";
 /**
  * Class representing config for connection to API
  *
@@ -30,15 +31,39 @@ export class ApiConfig {
         this.initStreakMap(data);
         this.initTransformationMap(data);
     }
+    /**
+     * Function to generate metadata for a particular spin
+     *
+     * @public
+     * @param {SpinDataInterface} spinLogicResponse
+     * @returns AdaptedSpinResponse without results and standalone results, these should be created in each game
+     */
+    generateMetadata(spinLogicResponse) {
+        const blindsConfiguredByResponse = this.mapSymbolIdsToSymbolNames(spinLogicResponse.symbols_on_reels);
+        const blindsConfiguredByTransformation = isBlindsConfiguredByTransformations(spinLogicResponse.results);
+        const finalSpinPositionOnReels = blindsConfiguredByTransformation !== null
+            ? this.mapSymbolIdsToSymbolNames(blindsConfiguredByTransformation)
+            : blindsConfiguredByResponse;
+        return {
+            action: spinLogicResponse.action,
+            balance: spinLogicResponse.balance,
+            availableFreeSpins: spinLogicResponse.available_free_spins,
+            symbolsOnReels: blindsConfiguredByResponse,
+            finalBlindsConfiguration: finalSpinPositionOnReels,
+            winAmountTotal: spinLogicResponse.win_amount_total,
+            extraData: spinLogicResponse.extra_data,
+        };
+    }
     /**
      * Getter for win line number
      *
      * @public
      * @param winLineAnimationName
+     * @param defaultNumber
      * @returns {string | number}
      */
-    getWinLineNumber(winLineAnimationName) {
-        return this.streakMap.get(winLineAnimationName) ?? "unknown";
+    getWinLineNumber(winLineAnimationName, defaultNumber = "unknown") {
+        return this.streakMap.get(winLineAnimationName) ?? defaultNumber;
     }
     /**
      * Function for getting next bet from config
@@ -129,14 +154,12 @@ export class ApiConfig {
      *
      * @public
      * @param {number[][]} symbols_on_reels
-     * @returns {SymbolId[]}
+     * @returns {SymbolId[][]}
      */
     mapSymbolIdsToSymbolNames(symbols_on_reels) {
-        return symbols_on_reels
-            .map((reel) => {
+        return symbols_on_reels.map((reel) => {
             return reel.map((symbolId) => this.getSymbolId(symbolId));
-        })
-            .flat();
+        });
     }
     /**
      * Getter for bet that placed in current position

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

@@ -42,5 +42,5 @@ export type SoundTrack = SoundTracks[keyof SoundTracks];
  * @property {string} start - on start spinning
  * @property {string} symbol - on symbol click and show paytable popup
  */
-export type GameSoundAssets = Record<SoundTrack, string> & Record<string, string>;
+export type GameSoundAssets = Record<SoundTrack, string>;
 export type SoundOverrides = Partial<Record<SoundTrack, SoundTrack>>;

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

@@ -1,4 +1,4 @@
-import { SymbolReels, TransformationDetails } from "../../connectivity";
+import { ExtraData, SymbolReels, TransformationDetails } from "../../connectivity";
 import { ApiConfig } from "../ApiConfig";
 import { AdaptedSpinResponse } from "./types";
 import { WinScenarios } from "./WinScenarios";
@@ -18,13 +18,16 @@ export declare class SpinLogic {
     private readonly _hasMysteryWin;
     private readonly _winScenarios;
     private readonly _standaloneTransformations;
+    private readonly _extraData;
     constructor(spinConfig: AdaptedSpinResponse, gameConfig: ApiConfig);
     get postSpinBalance(): number;
     get winTotalAmount(): number;
+    get winTotalAmountWithoutMystery(): number;
     get onStopBlindsConfiguration(): SymbolReels;
     get finalBlindsConfiguration(): SymbolReels;
     get availableFreeSpins(): number;
     get hasMysteryWin(): boolean;
     get winScenarios(): WinScenarios[];
     get standaloneTransformations(): TransformationDetails[][];
+    get extraData(): ExtraData;
 }

package/dist/application/SpinLogic/SpinLogic.js

@@ -1,3 +1,4 @@
+import { PossibleWins } from "../../constants";
 import { logInfo } from "../../utils";
 import { SpinLogicDTO } from "./SpinLogicDTO";
 /**
@@ -16,6 +17,7 @@ export class SpinLogic {
     _hasMysteryWin;
     _winScenarios;
     _standaloneTransformations;
+    _extraData;
     constructor(spinConfig, gameConfig) {
         const spinLogicReader = new SpinLogicDTO(spinConfig, gameConfig);
         this._postSpinBalance = spinLogicReader.updatedBalance;
@@ -26,6 +28,7 @@ export class SpinLogic {
         this._hasMysteryWin = spinLogicReader.hasMysteryWin;
         this._winScenarios = spinLogicReader.winScenarios;
         this._standaloneTransformations = spinLogicReader.standaloneTransformations;
+        this._extraData = spinLogicReader.extraData;
         logInfo("Spin logic", JSON.parse(JSON.stringify(this)));
     }
     get postSpinBalance() {
@@ -34,6 +37,10 @@ export class SpinLogic {
     get winTotalAmount() {
         return this._winTotalAmount;
     }
+    get winTotalAmountWithoutMystery() {
+        return this._winScenarios.reduce((accumulator, scenario) => accumulator +
+            scenario.wins.reduce((winAccumulator, currentWin) => currentWin.type === PossibleWins.mystery ? winAccumulator : winAccumulator + currentWin.amount, 0), 0);
+    }
     get onStopBlindsConfiguration() {
         return this._onStopBlindsConfiguration;
     }
@@ -52,4 +59,7 @@ export class SpinLogic {
     get standaloneTransformations() {
         return this._standaloneTransformations;
     }
+    get extraData() {
+        return this._extraData;
+    }
 }

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

@@ -11,6 +11,7 @@ export declare class SpinLogicDTO {
     get totalWonAmount(): number;
     get finalBlindsConfiguration(): SymbolReels;
     get onStopBlindsConfiguration(): SymbolReels;
+    get extraData(): import("../../connectivity").ExtraData;
     get winScenarios(): WinScenarios[];
     get standaloneTransformations(): TransformationDetails[][];
     get hasMysteryWin(): boolean;

package/dist/application/SpinLogic/SpinLogicDTO.js

@@ -38,6 +38,9 @@ export class SpinLogicDTO {
     get onStopBlindsConfiguration() {
         return this.rawData.symbolsOnReels.map((reel) => reel.map((symbol) => this.stringToSymbolId(symbol)));
     }
+    get extraData() {
+        return this.rawData.extraData;
+    }
     get winScenarios() {
         const { results, availableFreeSpins } = this.rawData;
         if (results === undefined)
@@ -65,8 +68,8 @@ export class SpinLogicDTO {
             symbolId: this.gameConfig.getSymbolId(singleWin.symbolId),
             positionOnReels: singleWin.positionOnReels,
             quantity: singleWin.quantity,
-            spinId: singleWin.spinId,
             multiplier: singleWin.multiplier,
+            winIndex: singleWin.winIndex,
             typeId: singleWin.typeId,
         };
         if (rawWin.type === PossibleWins.freeSpins) {

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

@@ -1,4 +1,4 @@
-import { SpinDataInterface, SymbolReels, TransformationDetails, WinWithTransformation } from "../../connectivity";
+import { ExtraData, SpinDataInterface, SymbolReels, TransformationDetails, WinWithTransformation } from "../../connectivity";
 import { ApiConfig } from "../ApiConfig";
 import { SpinLogic } from "./SpinLogic";
 export type AdaptedSpinResponse = {
@@ -10,5 +10,6 @@ export type AdaptedSpinResponse = {
     winAmountTotal: number;
     results: WinWithTransformation[];
     standaloneTransformations: TransformationDetails[][];
+    extraData: ExtraData;
 };
 export type SpinLogicFactory = (spinLogicResponse: SpinDataInterface, gameConfig: ApiConfig) => SpinLogic;

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

@@ -1,8 +1,7 @@
 import { DropTransformationDetails, FreezeTransformationDetails, RawFreezeTransformationDetails, RawWin, Result, SpinAndFreezeTransformationDetails, SpinDataInterface, SymbolReels, TransformationDetails, WinWithTransformation } from "../../connectivity";
 import { ApiConfig } from "../ApiConfig";
 export declare const concatenateDestroyAndSetTransformations: (spinLogicResponse: SpinDataInterface, currentIndexOfRootTransformation: number, gameConfig: ApiConfig) => [DropTransformationDetails[], number];
-export declare const mapSymbolIdsToSymbolNames: (symbols_on_reels: number[][], gameConfig: ApiConfig) => never[][];
 export declare const getFreezeTransformationFromRawResponse: (transformations: RawFreezeTransformationDetails[]) => FreezeTransformationDetails[];
 export declare const concatenateFreezeAndSpinTransformations: (freezeTransformations: FreezeTransformationDetails[], onStopBlindsConfiguration: SymbolReels) => SpinAndFreezeTransformationDetails;
-export declare const isBlindsConfiguredByTransformations: (results: Result[]) => number[][] | null;
-export declare const collectWinDetailsWithTransformation: (winIndex: string | null, winsDetails: RawWin | null, transformations: TransformationDetails[]) => WinWithTransformation;
+export declare const isBlindsConfiguredByTransformations: (results: Result[], transformationTypeId?: number) => number[][] | null;
+export declare const collectWinDetailsWithTransformation: (winsDetails: RawWin | null, transformations: TransformationDetails[], winIndex?: string | null) => WinWithTransformation;

package/dist/application/SpinLogic/util.js

@@ -5,10 +5,10 @@ const getWinFromRawResponse = (rawWin, winIndex) => {
         multiplier: rawWin.multiplier,
         positionOnReels: rawWin.position_on_reels,
         quantity: rawWin.quantity,
-        spinId: winIndex,
         symbolId: rawWin.symbol_id,
         typeId: rawWin.type_id,
         amount: rawWin.amount,
+        winIndex,
     };
 };
 const joinTransformationsIntoDropTransformation = (destroyTransformations, symbolsOnReel, gameConfig) => {
@@ -62,9 +62,6 @@ export const concatenateDestroyAndSetTransformations = (spinLogicResponse, curre
     const parsedDropTransformations = joinTransformationsIntoDropTransformation(destroyTransformations, symbolsIdsOnReelsAfterSet, gameConfig);
     return [parsedDropTransformations, setTransformationsIndex];
 };
-export const mapSymbolIdsToSymbolNames = (symbols_on_reels, gameConfig) => {
-    return symbols_on_reels.map((reel) => reel.map((symbolId) => gameConfig.getSymbolId(symbolId)));
-};
 export const getFreezeTransformationFromRawResponse = (transformations) => {
     return transformations.map((freezeTransformation) => {
         return {
@@ -81,17 +78,17 @@ export const concatenateFreezeAndSpinTransformations = (freezeTransformations, o
         symbolsOnReels: onStopBlindsConfiguration,
     };
 };
-export const isBlindsConfiguredByTransformations = (results) => {
-    // make copy of results because reverse is made in place
+export const isBlindsConfiguredByTransformations = (results, transformationTypeId = 16) => {
     const reversedResults = [...results].reverse();
     for (const rawTransformation of reversedResults) {
-        if (rawTransformation.transformation_type === 16 && rawTransformation.symbols_on_reels !== null) {
+        if (rawTransformation.transformation_type === transformationTypeId &&
+            rawTransformation.symbols_on_reels !== null) {
             return rawTransformation.symbols_on_reels;
         }
     }
     return null;
 };
-export const collectWinDetailsWithTransformation = (winIndex, winsDetails, transformations) => {
+export const collectWinDetailsWithTransformation = (winsDetails, transformations, winIndex = "") => {
     const wins = winsDetails ? [getWinFromRawResponse(winsDetails, winIndex ?? "")] : [];
     return {
         wins,

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

@@ -11,12 +11,13 @@ import { Spine } from "pixi-spine";
  */
 export declare abstract class AbstractFreeSpinContainer extends Container {
     protected abstract freeSpinPlate: Sprite | Spine;
-    shownAt: number;
+    shownAt: number | null;
     protected scaleMultiplier: number;
     protected constructor();
     abstract get onClick(): () => void;
+    onStart(): Promise<void>;
     resize(): void;
-    private reposition;
+    protected reposition(): void;
     protected centerComponent(component: Text | Container): void;
     protected abstract initChildPositions(): void;
 }

package/dist/components/AbstractFreeSpinContainer/AbstractFreeSpinContainer.js

@@ -20,6 +20,7 @@ export class AbstractFreeSpinContainer extends Container {
         this.shownAt = performance.now();
         this.parentLayer = UXLayer;
     }
+    async onStart() { }
     resize() {
         this.scale.set(globalMinRatio() * this.scaleMultiplier);
         this.reposition();

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

@@ -19,26 +19,28 @@ export declare abstract class AbstractMainContainer extends Container {
     protected logo: Nullable<Logo>;
     protected abstract background: IResizableContainer;
     protected animatedFront: Nullable<IResizableContainer>;
-    protected abstract freeSpinBox: Nullable<FreeSpinBox>;
-    protected underFramePanel: Nullable<Graphics>;
+    protected freeSpinBox: Nullable<FreeSpinBox>;
+    protected underFramePanel: Nullable<Graphics | Sprite>;
     protected portraitPlayButtons: Nullable<MiddleButtons>;
     protected landscapePlayButtons: Nullable<MiddleButtons>;
     protected abstract leftButtons: ResponsiveContainer;
     protected abstract rightButtons: ResponsiveContainer;
     protected bottomPanel: Nullable<Sprite>;
+    private gambleGame;
+    protected gambleGameSpineName: Nullable<string>;
     protected _freeSpinPlate: Nullable<AbstractFreeSpinContainer>;
     protected _freeSpinSummary: Nullable<AbstractFreeSpinContainer>;
     private _bigWinInvokedAt;
     private _mysteryWinInvokedAt;
     protected abstract _frame: AbstractFrame;
-    protected _controller: Nullable<AbstractController>;
+    protected _controller: Nullable<AbstractController<unknown>>;
     protected constructor();
     protected abstract triggerStoreInitState(): void;
     get freeSpinPlate(): Nullable<AbstractFreeSpinContainer>;
     get freeSpinSummary(): Nullable<AbstractFreeSpinContainer>;
-    protected abstract createFreeSpinPlate(resolver: () => void, freeSpinCount: number, isAdditionalFreeSpin: boolean): AbstractFreeSpinContainer;
+    protected createFreeSpinPlate(_resolver: () => void, _freeSpinCount: number, _isAdditionalFreeSpin: boolean): AbstractFreeSpinContainer | null;
     invokeFreeSpinPlate(freeSpinCount: number, isAdditionalFreeSpin?: boolean): Promise<void>;
-    protected abstract createFreeSpinSummary(resolver: () => void, freeSpinCount: number, winAmount: number): AbstractFreeSpinContainer;
+    protected createFreeSpinSummary(_resolver: () => void, _freeSpinCount: number, _winAmount: number): AbstractFreeSpinContainer | null;
     invokeFreeSpinSummary(freeSpinCount: number, winAmount: number): Promise<void>;
     hideFreeSpinSummary(): void;
     private showOverlay;
@@ -51,7 +53,8 @@ export declare abstract class AbstractMainContainer extends Container {
     invokeMysteryWin(): void;
     destroyBigWin(): void;
     destroyMysteryWin(): void;
-    invokeGambleGame(): void;
+    invokeGambleGame(): Promise<void>;
+    protected createUnderFramePanel(): Graphics | Sprite;
     enableForMobile(): void;
     enableForLandscape(): void;
     disableForMobile(): void;

package/dist/components/AbstractMainContainer/AbstractMainContainer.js

@@ -5,6 +5,7 @@ import { RainMan } from "../../Rainman";
 import { settingStore } from "../../SettingsUI/hooks";
 import { getDeviceOrientation, globalMinRatio } from "../../utils";
 import { BUTTONS, LeftButtons, LeftButtonsLandscape, LeftButtonsMobile, MiddleButtons, RefreshButton, RightButtons, RightButtonsLandscape, RightButtonsMobile, } from "../buttons";
+import { GambleGame } from "../GambleGame";
 import { MessageBox } from "../messageBox";
 export class AbstractMainContainer extends Container {
     static registryName = "mainContainer";
@@ -15,10 +16,13 @@ export class AbstractMainContainer extends Container {
     buttonsEventManager;
     logo = null;
     animatedFront = null;
+    freeSpinBox = null;
     underFramePanel = null;
     portraitPlayButtons = null;
     landscapePlayButtons = null;
     bottomPanel = null;
+    gambleGame = null;
+    gambleGameSpineName = null;
     _freeSpinPlate = null;
     _freeSpinSummary = null;
     _bigWinInvokedAt = null;
@@ -39,14 +43,20 @@ export class AbstractMainContainer extends Container {
     get freeSpinSummary() {
         return this._freeSpinSummary;
     }
+    createFreeSpinPlate(_resolver, _freeSpinCount, _isAdditionalFreeSpin) {
+        return null;
+    }
     async invokeFreeSpinPlate(freeSpinCount, isAdditionalFreeSpin = false) {
         const refreshButton = RainMan.componentRegistry.get(RefreshButton.registryName);
         refreshButton.flipDisabledFlag(true);
-        await new Promise((resolve) => {
+        await new Promise(async (resolve) => {
             this._freeSpinPlate = this.createFreeSpinPlate(resolve, freeSpinCount, isAdditionalFreeSpin);
+            if (this._freeSpinPlate === null)
+                return resolve();
             this._freeSpinPlate.resize();
             this.showOverlay();
             this.addChild(this._freeSpinPlate);
+            await this._freeSpinPlate.onStart();
         });
         if (this._freeSpinPlate !== null) {
             this.removeChild(this._freeSpinPlate);
@@ -55,11 +65,16 @@ export class AbstractMainContainer extends Container {
         this.hideOverlay();
         refreshButton.flipDisabledFlag(false);
     }
+    createFreeSpinSummary(_resolver, _freeSpinCount, _winAmount) {
+        return null;
+    }
     async invokeFreeSpinSummary(freeSpinCount, winAmount) {
         const refreshButton = RainMan.componentRegistry.get(BUTTONS.refresh);
         refreshButton.flipDisabledFlag(true);
         await new Promise((resolve) => {
             this._freeSpinSummary = this.createFreeSpinSummary(resolve, freeSpinCount, winAmount);
+            if (this._freeSpinSummary === null)
+                return resolve();
             this._freeSpinSummary.resize();
             this.showOverlay();
             this.addChild(this._freeSpinSummary);
@@ -150,13 +165,31 @@ export class AbstractMainContainer extends Container {
         this.mysteryWinContainer = null;
         this._mysteryWinInvokedAt = null;
     }
-    invokeGambleGame() { }
+    async invokeGambleGame() {
+        if (!this.gambleGameSpineName)
+            return;
+        const newBalance = await new Promise((resolve) => {
+            this.gambleGame = new GambleGame(this.gambleGameSpineName, resolve, this._controller.lastWinAmount, this._controller.balance);
+            this.showOverlay();
+            this.addChild(this.gambleGame);
+        });
+        if (this.gambleGame) {
+            this.removeChild(this.gambleGame);
+            this.gambleGame = null;
+        }
+        this._controller.balance = newBalance;
+        this.hideOverlay();
+    }
+    createUnderFramePanel() {
+        const underFramePanel = new Graphics();
+        underFramePanel.beginFill(0x0, 0.5);
+        underFramePanel.drawRect(0, 0, 800, 100);
+        return underFramePanel;
+    }
     enableForMobile() {
         if (this.logo)
             this.logo.renderable = true;
-        this.underFramePanel = new Graphics();
-        this.underFramePanel.beginFill(0x0, 0.5);
-        this.underFramePanel.drawRect(0, 0, 800, 100);
+        this.underFramePanel = this.createUnderFramePanel();
         this.underFramePanel.name = "underFramePanel";
         this.underFramePanel.parentLayer = UXLayer;
         this.addChild(this.underFramePanel);
@@ -269,6 +302,7 @@ export class AbstractMainContainer extends Container {
     resizeDependentComponents() {
         const resizingHelper = globalMinRatio();
         this._frame.resize();
+        this.logo?.resize();
         this.leftButtons.resize();
         this.rightButtons.resize();
         if (this.landscapePlayButtons !== null)
@@ -292,6 +326,9 @@ export class AbstractMainContainer extends Container {
             this.addChild(this.mysteryWinContainer);
             this.mysteryWinContainer.resize();
         }
+        if (this.gambleGame) {
+            this.gambleGame.resize();
+        }
         if (this.bottomPanel) {
             this.bottomPanel.scale.set(resizingHelper);
             this.bottomPanel.width = RainMan.app.screen.width;