pixi-rainman-game-engine 0.1.9 → 0.1.10

package/dist/DescribedPlayableAction/DescribedPlayableAction.d.ts

@@ -3,6 +3,7 @@ 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/Rainman/appConfig.js

@@ -43,5 +43,6 @@ export const defaultAppConfig = {
     },
     constants: {
         bigWinMultiplier: 30,
+        bigWinTextOffset: 0,
     },
 };

package/dist/Rainman/types.d.ts

@@ -50,9 +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/application/ApiConfig/ApiConfig.js

@@ -51,6 +51,7 @@ export class ApiConfig {
             symbolsOnReels: blindsConfiguredByResponse,
             finalBlindsConfiguration: finalSpinPositionOnReels,
             winAmountTotal: spinLogicResponse.win_amount_total,
+            extraData: spinLogicResponse.extra_data,
         };
     }
     /**

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,6 +18,7 @@ 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;
@@ -28,4 +29,5 @@ export declare class SpinLogic {
     get hasMysteryWin(): boolean;
     get winScenarios(): WinScenarios[];
     get standaloneTransformations(): TransformationDetails[][];
+    get extraData(): ExtraData;
 }

package/dist/application/SpinLogic/SpinLogic.js

@@ -17,6 +17,7 @@ export class SpinLogic {
     _hasMysteryWin;
     _winScenarios;
     _standaloneTransformations;
+    _extraData;
     constructor(spinConfig, gameConfig) {
         const spinLogicReader = new SpinLogicDTO(spinConfig, gameConfig);
         this._postSpinBalance = spinLogicReader.updatedBalance;
@@ -27,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() {
@@ -57,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)

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/components/AbstractMainContainer/AbstractMainContainer.d.ts

@@ -26,6 +26,8 @@ export declare abstract class AbstractMainContainer extends Container {
     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;
@@ -36,9 +38,9 @@ export declare abstract class AbstractMainContainer extends Container {
     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,7 @@ 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;

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";
@@ -20,6 +21,8 @@ export class AbstractMainContainer extends Container {
     portraitPlayButtons = null;
     landscapePlayButtons = null;
     bottomPanel = null;
+    gambleGame = null;
+    gambleGameSpineName = null;
     _freeSpinPlate = null;
     _freeSpinSummary = null;
     _bigWinInvokedAt = null;
@@ -40,11 +43,16 @@ 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(async (resolve) => {
             this._freeSpinPlate = this.createFreeSpinPlate(resolve, freeSpinCount, isAdditionalFreeSpin);
+            if (this._freeSpinPlate === null)
+                return resolve();
             this._freeSpinPlate.resize();
             this.showOverlay();
             this.addChild(this._freeSpinPlate);
@@ -57,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);
@@ -152,7 +165,21 @@ 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);
@@ -299,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;

package/dist/components/GambleGame/GambleGame.js

@@ -39,25 +39,26 @@ export class GambleGame extends Container {
         this.resolver = resolver;
         this.bet = bet;
         this.balanceValue = balanceValue;
-        this.interactive = true;
+        this.eventMode = "static";
         this.background = new Sprite(Texture.from("black-bg.png"));
         this.frame = new Sprite(Texture.from("frame-v2.png"));
-        this.previousGamblesText = new Text(i18next.t("previousCards"), gamblesTextStyle);
+        this.previousGamblesText = new Text(i18next.t("previousCards"), gamblesTextStyle());
         this.previousGamblesContainer = new Container();
         this.collectButton = new CollectButton();
         this.redButton = new RedButton();
         this.blackButton = new BlackButton();
         this.collectButton.pivot.x = this.collectButton.width / 2;
-        this.collectText = new Text(i18next.t("collect"), gamblesTextStyle);
+        this.collectText = new Text(i18next.t("collect"), gamblesTextStyle());
         this.collectText.pivot.x = this.collectText.width / 2;
         this.collectText.pivot.y = this.collectText.height / 2;
         this.card = new Spine(getSpineData(cardSpineName));
         this.card.state.addAnimation(0, "idle", true, 0);
         this.currentWin = new GambleUpdatableText(GambleGame.gambleCurrentWinRegistryName, i18next.t("currentWinGamble"), this.bet, 1);
-        this.gambleWin = new GambleUpdatableText(GambleGame.gambleWinRegistryName, i18next.t("currentWinGamble"), this.bet * 2, 2);
+        this.gambleWin = new GambleUpdatableText(GambleGame.gambleWinRegistryName, i18next.t("gambleToWin"), this.bet * 2, 2);
         this.redButton.setOnClick(() => this.handleGamblePlay("red"));
         this.blackButton.setOnClick(() => this.handleGamblePlay("black"));
         this.collectButton.setOnClick(() => this.resolver(this.balanceValue));
+        this.resize();
     }
     showPreviousGambles(previousGambles) {
         const { width } = RainMan.app.screen;
@@ -138,8 +139,8 @@ export class GambleGame extends Container {
         this.collectButton.scale.set(globalMinRatio() * 0.8);
         this.collectButton.x = CENTER;
         this.collectButton.y = this.collectText.y - this.collectButton.height - 30;
-        const COLOR_BUTTONS_Y = this.card.y - this.redButton.height / 2;
         this.redButton.scale.set(globalMinRatio() * COLOR_BUTTONS_SCALE_X);
+        const COLOR_BUTTONS_Y = this.card.y - this.redButton.height / 2;
         this.redButton.x = CENTER - COLOR_BUTTONS_CENTER_OFFSET - this.redButton.width;
         this.redButton.y = COLOR_BUTTONS_Y;
         this.blackButton.scale.set(globalMinRatio() * COLOR_BUTTONS_SCALE_X);

package/dist/components/buttons/buttonGroups/LeftButtons.d.ts

@@ -7,7 +7,7 @@ export declare class LeftButtons extends ResponsiveContainer {
     protected readonly infoButton: InfoButton;
     protected readonly credit: UpdatableTextComponent;
     protected readonly bet: UpdatableTextComponent;
-    constructor();
+    constructor(scaleMultiplier?: number);
     removeChildrenFromRegistry(): void;
     protected reposition(): void;
 }

package/dist/components/buttons/buttonGroups/LeftButtons.js

@@ -11,8 +11,8 @@ export class LeftButtons extends ResponsiveContainer {
     infoButton = new InfoButton();
     credit = new UpdatableTextComponent(COMPONENTS.creditText, i18next.t("credit"), UPDATABLE_MODES.money);
     bet = new UpdatableTextComponent(COMPONENTS.betText, i18next.t("bet"), UPDATABLE_MODES.money);
-    constructor() {
-        super();
+    constructor(scaleMultiplier) {
+        super(scaleMultiplier);
         this.name = REGISTRY.leftButtons;
         this.parentLayer = UXLayer;
         this.volumeButton.anchor.set(0, 0);

package/dist/components/common/AnimatedBackground.js

@@ -1,4 +1,5 @@
 import { Spine } from "pixi-spine";
+import { BackgroundLayer } from "../../layers";
 import { RainMan } from "../../Rainman";
 import { getDeviceOrientation, getSpineData } from "../../utils";
 import { ResumableContainer } from "./ResumableContainers";
@@ -23,6 +24,7 @@ export class AnimatedBackground extends ResumableContainer {
         this.animationName = animationName;
         this.mobileSpineName = mobileSpineName;
         this.name = AnimatedBackground.registryName;
+        this.parentLayer = BackgroundLayer;
     }
     resize() {
         this.changeSpineForOrientation();

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

@@ -1,6 +1,7 @@
 import { Container, Graphics } from "pixi.js";
 import { SoundTrack, SpeedAdapterInterface, SpeedLevel, SymbolId } from "../../application";
 import { DropTransformationDetails, StreakReelsIndexes, SymbolReels } from "../../connectivity";
+import { PlayableAction } from "../../utils";
 import { AbstractSymbolsColumn } from "../symbols";
 /**
  * Class represents columns container in game
@@ -70,5 +71,5 @@ export declare abstract class AbstractColumnsContainer extends Container impleme
     handleDestroyTransformations(transformations: DropTransformationDetails[], skipAnimations?: boolean, isStandalone?: boolean): Promise<void>;
     protected createMask(): Graphics;
     fixSymbolsColumnsPosition(): void;
-    private prepareConfiguringReelsEnd;
+    protected prepareConfiguringReelsEnd(finalSymbolReels: SymbolReels): PlayableAction[];
 }

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

@@ -34,7 +34,7 @@ export declare abstract class AbstractFrame extends ResumableContainer implement
     get columnsContainer(): AbstractColumnsContainer;
     adaptToSpeed(speedLevel: SpeedLevel): void;
     invokeMysteryFx(x: number, y: number): void;
-    protected abstract repositionMysteryFx(x: number, y: number): void;
+    protected repositionMysteryFx(_x: number, _y: number): void;
     hideMysteryFx(): Promise<void>;
     destroyMysteryFx(): void;
     protected createWinLineAnimation(_animationName: string): WinLineAnimation | null;

package/dist/components/frame/AbstractFrame.js

@@ -49,6 +49,7 @@ export class AbstractFrame extends ResumableContainer {
             complete: () => this.mysteryFxHighlight?.state.setAnimation(0, this.mysteryFxConfig.loopAnimationName, true),
         });
     }
+    repositionMysteryFx(_x, _y) { }
     async hideMysteryFx() {
         return new Promise((resolve) => {
             if (!this.mysteryFxConfig)

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

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

package/dist/components/symbols/AbstractSymbolBase.js

@@ -75,7 +75,7 @@ export class AbstractSymbolBase extends Container {
         return;
     }
     async handleMultiplierAnimation(multiplier) {
-        if (multiplier === 1 || this.multiplierSpineName === null)
+        if (multiplier <= 1 || this.multiplierSpineName === null)
             return;
         const symbolMultiplier = new Spine(getSpineData(this.multiplierSpineName));
         this.addChild(symbolMultiplier);

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

@@ -17,7 +17,7 @@ import { AnimationTimeSettings } from "./types";
  */
 export declare abstract class AbstractSymbolsColumn extends Container implements SpeedAdapterInterface<number> {
     protected columnsContainer: AbstractColumnsContainer;
-    protected allSymbols: SymbolId[];
+    allSymbols: SymbolId[];
     spinning: boolean;
     speedLevelMapper: import("../../application").SpeedLevelDirectory<number>;
     protected symbols: Array<AbstractSymbolBase>;

package/dist/components/updatable/GambleUpdatableText.js

@@ -7,7 +7,7 @@ export class GambleUpdatableText extends UpdatableValueComponent {
     frame;
     icon;
     constructor(registryName, baseText, initialValue, icon, updateCallback) {
-        super(registryName, baseText, gamblesTextStyle, gamblesTextStyle, UPDATABLE_MODES.money, updateCallback);
+        super(registryName, baseText, gamblesTextStyle(24), gamblesTextStyle(), UPDATABLE_MODES.money, updateCallback);
         this.name = registryName;
         this.finalValue = initialValue;
         this.frame = new Sprite(Texture.from("black-button-n.png"));

package/dist/components/updatable/UpdatableValueComponent.d.ts

@@ -28,4 +28,5 @@ export declare abstract class UpdatableValueComponent extends Container implemen
     private getFinalValue;
     private initAnimation;
     private setResultAndClearTween;
+    updateBaseTextStyle(style: Partial<ITextStyle>): void;
 }

package/dist/components/updatable/UpdatableValueComponent.js

@@ -115,4 +115,7 @@ export class UpdatableValueComponent extends Container {
         Ticker.shared.remove(() => this.animate());
         this.changeCurrentWin(finalValue);
     }
+    updateBaseTextStyle(style) {
+        this.baseTextComponent.style = { ...this.baseTextComponent.style, ...style };
+    }
 }

package/dist/components/winLineIndicator/WinLineIndicator.js

@@ -16,6 +16,7 @@ export class WinLineIndicator extends Container {
             const previous = this.symbols[i - 1];
             const current = this.symbols[i];
             current.scale.set(RainMan.config.winLineIndicatorSymbolScale);
+            current.anchor.set(0);
             if (previous)
                 current.x += previous.x + previous.width;
             current.y -= current.height / 2;

package/dist/connectivity/spinData.js

@@ -6,8 +6,8 @@ export class SpinData {
         this.rawData = data;
         this.config = config;
         this.balance = data.balance;
-        if (data.action !== "spin") {
-            throw new Error(`Invalid type "${data.action}" provided, "spin" expected`);
+        if (data.action !== "spin" && data.action !== "buy-free-spins") {
+            throw new Error(`Invalid type "${data.action}" provided, "spin" or "buy-free-spins" expected`);
         }
     }
     getRawData() {

package/dist/connectivity/wins.d.ts

@@ -32,7 +32,22 @@ export type MysteryWin = BaseWin & {
 export type EggWin = BaseWin & {
     type: typeof PossibleWins.egg;
 };
-export type Win = StreakWin | FreeSpinWin | GambleWin | MysteryWin | EggWin;
+export type GoldWin = BaseWin & {
+    type: typeof PossibleWins.gold;
+};
+export type BigWin = BaseWin & {
+    type: typeof PossibleWins.bigWin;
+};
+export type BonusWin = BaseWin & {
+    type: typeof PossibleWins.bonus;
+};
+export type SuperBonusWin = BaseWin & {
+    type: typeof PossibleWins.superBonus;
+};
+export type ScatterWin = BaseWin & {
+    type: typeof PossibleWins.scatter;
+};
+export type Win = StreakWin | FreeSpinWin | GambleWin | MysteryWin | EggWin | GoldWin | BigWin | BonusWin | SuperBonusWin | ScatterWin;
 /**
  * Type represents data that come from backend
  *

package/dist/constants/gamble.d.ts

@@ -2,8 +2,8 @@ import { TextStyle } from "pixi.js";
 export declare const BOTTOM_BUTTONS_SCALE_X = 0.3;
 export declare const BOTTOM_BUTTONS_Y = 800;
 export declare const BOTTOM_BUTTONS_CENTER_OFFSET = 80;
-export declare const COLOR_BUTTONS_SCALE_X = 0.3;
+export declare const COLOR_BUTTONS_SCALE_X = 0.8;
 export declare const COLOR_BUTTONS_CENTER_OFFSET = 200;
 export declare const MONEY_Y = 700;
 export declare const MONEY_CENTER_OFFSET = 300;
-export declare const gamblesTextStyle: TextStyle;
+export declare const gamblesTextStyle: (fontSize?: number) => TextStyle;

package/dist/constants/gamble.js

@@ -2,13 +2,13 @@ import { TextStyle } from "pixi.js";
 export const BOTTOM_BUTTONS_SCALE_X = 0.3;
 export const BOTTOM_BUTTONS_Y = 800;
 export const BOTTOM_BUTTONS_CENTER_OFFSET = 80;
-export const COLOR_BUTTONS_SCALE_X = 0.3;
+export const COLOR_BUTTONS_SCALE_X = 0.8;
 export const COLOR_BUTTONS_CENTER_OFFSET = 200;
 export const MONEY_Y = 700;
 export const MONEY_CENTER_OFFSET = 300;
-export const gamblesTextStyle = new TextStyle({
+export const gamblesTextStyle = (fontSize = 40) => new TextStyle({
     fill: "#fff",
     fontWeight: "bold",
     align: "center",
-    fontSize: 40,
+    fontSize,
 });

package/dist/controllers/AbstractController.d.ts

@@ -57,19 +57,20 @@ export declare abstract class AbstractController<T> {
     private setRefreshButtonBasedOnPhase;
     private setMessageBoxBasedOnPhase;
     private getReelIndexesToShowMysteryFx;
-    private handleSpinLogic;
+    protected handleSpinLogic(): void;
     protected throttledSpin(): void;
     private getBoughtNumberOfFreeSpins;
     private autoplaySpin;
     protected clearAndDestroyActions(): void;
     private disableAutoplay;
+    protected onDataFetch(_spinData: SpinData, _spinLogic: SpinLogic): void;
     private fetchAndPrepareSpinData;
     protected abstract canSkipActions(): boolean;
     protected onSpinningStart(): Promise<void>;
     protected onSpinningEnd(_data: SpinData): Promise<void>;
     private spin;
     private handleFreeSpinPlateInvocation;
-    private handleFreeSpinSummaryPlateInvocation;
+    protected handleFreeSpinSummaryPlateInvocation(): Promise<void>;
     private handleAutoplayLogic;
     private lockLogicWhileSpinning;
     private unlockLogicAfterSpinning;

package/dist/controllers/AbstractController.js

@@ -51,6 +51,7 @@ export class AbstractController {
         const initData = this.connection.initData();
         this.config = new ApiConfig(initData);
         RainMan.settingsStore.initPaytableMap(initData);
+        RainMan.globals.throttledSpin = this.throttledSpin.bind(this);
         this.connection.subscribeForConfigChanges(this.reinitializeUserBalanceData.bind(this));
         this.uiController.updateBet("first");
         this.uiController.currentBalance = initData.balance;
@@ -74,6 +75,7 @@ export class AbstractController {
         this.config = new ApiConfig(initData);
         RainMan.settingsStore.initPaytableMap(initData);
         this.roundNumber = 0;
+        this.uiController.updateBet("first");
         this.uiController.triggerUiElementsUpdate();
     }
     reinitializeAllButtons() {
@@ -354,6 +356,7 @@ export class AbstractController {
         RainMan.componentRegistry.get(BUTTONS.plus).flipDisabledFlag(false);
         RainMan.componentRegistry.get(BUTTONS.neg).flipDisabledFlag(false);
     }
+    onDataFetch(_spinData, _spinLogic) { }
     async fetchAndPrepareSpinData() {
         this.changeGamePhase(gamePhases.DATA_FETCH);
         const data = RainMan.settingsStore.buyFreeSpinsData ||
@@ -361,6 +364,7 @@ export class AbstractController {
         debugSpinData(data);
         const spinLogic = RainMan.spinLogicFactory(data.getRawData(), this.config);
         this._lastWinAmount = this.mysteryWinSymbol ? spinLogic.winTotalAmountWithoutMystery : spinLogic.winTotalAmount;
+        this.onDataFetch(data, spinLogic);
         if (spinLogic.winTotalAmount !== 0) {
             this.uiController.recentWin = ceilToDecimal(spinLogic.winTotalAmount);
             if (RainMan.settingsStore.onAnyWin) {

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

@@ -1,4 +1,5 @@
 import { Spine } from "pixi-spine";
+import { Point } from "../../connectivity";
 export declare const ceilToDecimal: (value: number, decimalPlaces?: number) => number;
 export declare const wait: (ms: number) => Promise<void>;
 export declare const range: (start: number, stop: number, step: number) => number[];
@@ -11,3 +12,4 @@ export declare const waitForAnimationToEnd: (spine: Spine, animationName: string
 export declare const setTimeScale: (spine: Spine, flag: boolean) => void;
 export declare const changeResolution: (high: boolean) => void;
 export declare const notNullish: <T>(x: T | null | undefined) => x is T;
+export declare const areCoordinatesEqual: (firstCoordinates: Point, secondCoordinates: Point) => boolean;

package/dist/utils/common/functions.js

@@ -73,3 +73,6 @@ export const changeResolution = (high) => {
 export const notNullish = (x) => {
     return x !== null && x !== undefined;
 };
+export const areCoordinatesEqual = (firstCoordinates, secondCoordinates) => {
+    return firstCoordinates.x === secondCoordinates.x && firstCoordinates.y === secondCoordinates.y;
+};

package/dist/winComponents/UpdatableSpineContainer.d.ts

@@ -12,9 +12,9 @@ import { PositioningFrame } from "./PositioningFrame";
  * @extends {Container}
  */
 export declare class UpdatableSpineContainer extends Container {
-    private text;
-    private spine;
-    private frame;
+    protected text: StylefulUpdatableText;
+    protected spine: ScalableSpine;
+    protected frame: PositioningFrame;
     private emitters;
     private spineScale;
     constructor(text: StylefulUpdatableText, spine: ScalableSpine, frame: PositioningFrame, emitters: AnimableParticlesEmitter[], spineScale?: number);

package/dist/winComponents/UpdatableSpineContainer.js

@@ -35,7 +35,7 @@ export class UpdatableSpineContainer extends Container {
         Ticker.shared.add(this.animateBox, this);
     }
     positionText() {
-        this.text.y = this.spine.height / 3;
+        this.text.y = this.spine.height / 3 + RainMan.config.constants.bigWinTextOffset;
         this.text.x = 0 - this.text.width / 2;
     }
     resize() {

package/dist/winComponents/winFactory.d.ts

@@ -1,4 +1,4 @@
 import { ITextStyle } from "pixi.js";
 import { AnimableParticlesEmitter } from "./AnimableParticlesEmitter";
 import { UpdatableSpineContainer } from "./UpdatableSpineContainer";
-export declare const winFactory: (textRegistryName: string, defaultText: string, spineName: string, animationName: string, emitters?: AnimableParticlesEmitter[], textStyleOverrides?: Partial<ITextStyle>) => UpdatableSpineContainer;
+export declare const winFactory: (textRegistryName: string, defaultText: string, spineName: string, animationName: string, emitters?: AnimableParticlesEmitter[], textStyleOverrides?: Partial<ITextStyle>, spineScale?: number) => UpdatableSpineContainer;

package/dist/winComponents/winFactory.js

@@ -2,10 +2,10 @@ import { ScalableSpine, StylefulUpdatableText, UPDATABLE_MODES } from "../compon
 import { RainMan } from "../Rainman";
 import { PositioningFrame } from "./PositioningFrame";
 import { UpdatableSpineContainer } from "./UpdatableSpineContainer";
-export const winFactory = (textRegistryName, defaultText, spineName, animationName, emitters = [], textStyleOverrides = {}) => {
+export const winFactory = (textRegistryName, defaultText, spineName, animationName, emitters = [], textStyleOverrides = {}, spineScale) => {
     const textStyle = {
         fontFamily: RainMan.config.fontFace,
-        fill: ["#FCD784", "#AE6119", "#FEE391"], // gradient
+        fill: ["#FCD784", "#AE6119", "#FEE391"], // gradientnu
         stroke: "#4a1850",
         strokeThickness: 5,
         dropShadow: true,
@@ -20,5 +20,5 @@ export const winFactory = (textRegistryName, defaultText, spineName, animationNa
     const bigWinSpine = new ScalableSpine(spineName, animationName);
     const { width, height } = RainMan.app.screen;
     const bigWinShadow = new PositioningFrame(width, height, 0x000000);
-    return new UpdatableSpineContainer(bigWinText, bigWinSpine, bigWinShadow, emitters);
+    return new UpdatableSpineContainer(bigWinText, bigWinSpine, bigWinShadow, emitters, spineScale);
 };

package/package.json

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