pixi-rainman-game-engine 0.2.4 → 0.2.5

package/dist/application/ButtonsEventManager/ButtonsEventManager.js

@@ -239,7 +239,7 @@ export class ButtonsEventManager {
      * @param {boolean} disabled - flag for enabling/disabling button
      */
     initGambleButton(onClick, disabled) {
-        if (!RainMan.componentRegistry.has(BUTTONS.gamble))
+        if (!RainMan.componentRegistry.has(BUTTONS.gamble) && RainMan.settingsStore.gambleGameUsed)
             return;
         RainMan.componentRegistry.get(BUTTONS.gamble).setOnClick(onClick);
         RainMan.componentRegistry.get(BUTTONS.gamble).flipDisabledFlag(disabled);

package/dist/components/AbstractMainContainer/AbstractMainContainer.js

@@ -330,6 +330,7 @@ export class AbstractMainContainer extends Container {
         });
         if (this.gambleGame) {
             this.removeChild(this.gambleGame);
+            this._controller.updateGambleValues(RainMan.settingsStore.gambleGameWin);
             this.gambleGame = null;
         }
         this._controller.balance = newBalance;

package/dist/components/GambleGame/GambleGame.d.ts

@@ -9,7 +9,7 @@ import { Container } from "pixi.js";
  */
 export declare class GambleGame extends Container {
     private resolver;
-    private bet;
+    private lastWinAmount;
     private balanceValue;
     static gambleCurrentWinRegistryName: string;
     static gambleWinRegistryName: string;
@@ -25,9 +25,11 @@ export declare class GambleGame extends Container {
     private readonly previousGamblesText;
     private readonly previousGamblesContainer;
     private previousGambles;
-    constructor(cardSpineName: string, resolver: (newBalance: number) => void, bet: number, balanceValue: number);
+    constructor(cardSpineName: string, resolver: (newBalance: number) => void, lastWinAmount: number, balanceValue: number);
     private showPreviousGambles;
+    private closeGame;
     private updateDoubleAndWinFields;
+    private loseDoubleAndWinFields;
     private handleGamblePlay;
     resize(): void;
     private initChildPositions;

package/dist/components/GambleGame/GambleGame.js

@@ -4,7 +4,7 @@ import { Spine } from "pixi-spine";
 import { COLOR_BUTTONS_CENTER_OFFSET, COLOR_BUTTONS_SCALE_X, gamblesTextStyle } from "../../constants";
 import { RainMan } from "../../Rainman";
 import { getSpineData, globalMinRatio } from "../../utils";
-import { BlackButton, CollectButton, RedButton } from "../buttons";
+import { BlackButton, BUTTONS, CollectButton, RedButton } from "../buttons";
 import { GambleUpdatableText } from "../updatable";
 /**
  * Class for representing mechanic of gamble
@@ -16,7 +16,7 @@ import { GambleUpdatableText } from "../updatable";
  */
 export class GambleGame extends Container {
     resolver;
-    bet;
+    lastWinAmount;
     balanceValue;
     static gambleCurrentWinRegistryName = "gambleCurrentWin";
     static gambleWinRegistryName = "gambleWin";
@@ -32,10 +32,10 @@ export class GambleGame extends Container {
     previousGamblesText;
     previousGamblesContainer;
     previousGambles = [];
-    constructor(cardSpineName, resolver, bet, balanceValue) {
+    constructor(cardSpineName, resolver, lastWinAmount, balanceValue) {
         super();
         this.resolver = resolver;
-        this.bet = bet;
+        this.lastWinAmount = lastWinAmount;
         this.balanceValue = balanceValue;
         this.eventMode = "static";
         this.background = new Sprite(Texture.from("black-bg.png"));
@@ -50,12 +50,16 @@ export class GambleGame extends Container {
         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("gambleToWin"), this.bet * 2, 2);
+        this.card.state.addAnimation(0, "wait2", true, 0);
+        this.currentWin = new GambleUpdatableText(GambleGame.gambleCurrentWinRegistryName, i18next.t("currentWinGamble"), this.lastWinAmount, 1);
+        this.gambleWin = new GambleUpdatableText(GambleGame.gambleWinRegistryName, i18next.t("gambleToWin"), this.lastWinAmount * 2, 2);
         this.redButton.setOnClick(() => this.handleGamblePlay("red"));
         this.blackButton.setOnClick(() => this.handleGamblePlay("black"));
-        this.collectButton.setOnClick(() => this.resolver(this.balanceValue));
+        this.collectButton.setOnClick(() => {
+            RainMan.settingsStore.gambleGameWin = this.lastWinAmount;
+            RainMan.componentRegistry.get(BUTTONS.gamble).flipDisabledFlag(true);
+            this.resolver(this.balanceValue);
+        });
         this.resize();
     }
     showPreviousGambles(previousGambles) {
@@ -73,16 +77,23 @@ export class GambleGame extends Container {
         this.previousGamblesContainer.y =
             this.previousGamblesText.y + this.previousGamblesText.height + this.previousGamblesContainer.height / 2;
     }
+    closeGame() {
+        RainMan.componentRegistry.get(BUTTONS.gamble).flipDisabledFlag(true);
+        this.resolver(this.balanceValue);
+    }
     async updateDoubleAndWinFields(value) {
-        return Promise.all([this.gambleWin.update(value * 2), this.currentWin.update(value)]);
+        return Promise.all([this.gambleWin.update(value), this.currentWin.update(value / 2)]);
+    }
+    async loseDoubleAndWinFields() {
+        return Promise.all([this.gambleWin.loseUpdate(), this.currentWin.loseUpdate()]);
     }
     async handleGamblePlay(choice) {
-        if (this.bet === 0)
+        if (this.lastWinAmount === 0)
             return;
         this.redButton.flipDisabledFlag(true);
         this.blackButton.flipDisabledFlag(true);
         this.card.state.addAnimation(0, "wait", true, 0);
-        const gambleData = await window.connectionWrapper.fetchGambleData(RainMan.settingsStore.roundNumber, this.bet, choice);
+        const gambleData = await window.connectionWrapper.fetchGambleData(RainMan.settingsStore.roundNumber, this.lastWinAmount, choice);
         this.balanceValue = gambleData.balance + gambleData.win_amount;
         await new Promise((resolve) => {
             this.card.state.clearTracks();
@@ -90,14 +101,25 @@ export class GambleGame extends Container {
             this.card.state.addAnimation(0, gambleData.winning_card, false, 0);
             this.card.state.addListener({ complete: () => resolve() });
         });
-        await this.updateDoubleAndWinFields(Math.max(gambleData.win_amount, 0));
         if (gambleData.win_amount > 0) {
+            await this.updateDoubleAndWinFields(Math.max(gambleData.win_amount, 0));
             this.redButton.flipDisabledFlag(false);
             this.blackButton.flipDisabledFlag(false);
         }
-        this.card.state.addAnimation(0, "idle", true, 0);
-        this.bet = gambleData.win_amount;
+        this.card.state.addAnimation(0, "wait2", true, 0);
+        this.lastWinAmount = gambleData.win_amount;
         this.showPreviousGambles(gambleData.previous_gambles);
+        if (gambleData.win_amount === 0) {
+            this.redButton.flipDisabledFlag(true);
+            this.blackButton.flipDisabledFlag(true);
+            this.card.state.addAnimation(0, "idle", true, 0);
+            Promise.all([
+                this.loseDoubleAndWinFields(),
+                setTimeout(() => {
+                    this.closeGame();
+                }, 2000),
+            ]);
+        }
     }
     resize() {
         const { width, height } = RainMan.app.screen;

package/dist/components/updatable/GambleUpdatableText.js

@@ -31,5 +31,6 @@ export class GambleUpdatableText extends UpdatableValueComponent {
         this.pivot.x = this.frame.width / 2;
         this.pivot.y = this.height / 2;
         this.countingDivider = this.speedLevelMapper[DEFAULT_SPEED];
+        this.set(initialValue);
     }
 }

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

@@ -29,6 +29,7 @@ export declare abstract class UpdatableValueComponent extends Container implemen
     adaptToSpeed(speedLevel: SpeedLevel): void;
     get value(): string;
     update(newValue: number, time?: number): Promise<void>;
+    loseUpdate(time?: number): Promise<void>;
     stopUpdate(): void;
     set(newValue: number): void;
     setStringValue(value: string): void;

package/dist/components/updatable/UpdatableValueComponent.js

@@ -60,6 +60,10 @@ export class UpdatableValueComponent extends Container {
         Ticker.shared.add(() => this.animate());
         await this.initAnimation(newValue, time / this.countingDivider);
     }
+    async loseUpdate(time = RainMan.config.durationOfActions.updatableTextCountingDuration) {
+        Ticker.shared.add(() => this.animate());
+        await this.initAnimation(0, time / this.countingDivider, true);
+    }
     stopUpdate() {
         this.shouldBeUpdated = false;
         this.set(this.finalValue);
@@ -88,9 +92,9 @@ export class UpdatableValueComponent extends Container {
             return this.limitValue;
         return finalValue;
     }
-    initAnimation(newValue, countingDuration) {
+    initAnimation(newValue, countingDuration, shouldDescendToZero = false) {
         this.shouldBeUpdated = true;
-        const finalValue = this.getFinalValue(newValue);
+        const finalValue = shouldDescendToZero ? 0 : this.getFinalValue(newValue);
         return new Promise((resolve) => {
             this.tween = new TWEEN.Tween({ value: this.updatableValue })
                 .onUpdate(({ value }) => {

package/dist/controllers/AbstractController.d.ts

@@ -155,6 +155,7 @@ export declare abstract class AbstractController<T> {
     protected onSpinningStart(): Promise<void>;
     protected onSpinningEnd(_spinLogic: SpinLogic): Promise<void>;
     protected performActionsAfterSpin(): void;
+    protected gambleGameEnabler(winAmount: number): void;
     /**
      * Function for spin logic of the game
      * This function is responsible for:
@@ -225,7 +226,8 @@ export declare abstract class AbstractController<T> {
      * @returns {SymbolId[]} - symbols from streak
      */
     protected getSymbolIdsForStreak(streak: StreakReelsIndexes): SymbolId[];
-    protected updateUiValues(value: number): void;
+    updateUiValues(value: number): void;
+    updateGambleValues(value: number): void;
     /**
      * Function for composing win actions queue based on wins and transformations from {@link transformationTypes} and {@link PossibleWins}
      * @param spinLogic

package/dist/controllers/AbstractController.js

@@ -154,7 +154,10 @@ export class AbstractController {
         this.buttonsEventManager.initInfoButtonEvent();
         this.buttonsEventManager.initMoreButtonEvent();
         this.buttonsEventManager.initAutoplayButtonEvent();
-        this.buttonsEventManager.initGambleButton(() => this.mainContainer.invokeGambleGame(), this.lastWinAmount === 0);
+        this.buttonsEventManager.initGambleButton(() => {
+            RainMan.settingsStore.gambleGameUsed = true;
+            this.mainContainer.invokeGambleGame();
+        }, this.lastWinAmount === 0);
         RainMan.componentRegistry.get(SpeedControlButton.registryName).setOnClick(() => {
             this.quickStopController.speedPopupDisabled = true;
             RainMan.componentRegistry.nextSpeedLevel();
@@ -543,6 +546,13 @@ export class AbstractController {
     async onSpinningStart() { }
     async onSpinningEnd(_spinLogic) { }
     performActionsAfterSpin() { }
+    gambleGameEnabler(winAmount) {
+        if (RainMan.componentRegistry.has(BUTTONS.gamble) && !RainMan.settingsStore.gambleGameUsed) {
+            RainMan.componentRegistry
+                .get(BUTTONS.gamble)
+                .flipDisabledFlag(RainMan.settingsStore.isFreeSpinsPlayEnabled || winAmount === 0);
+        }
+    }
     /**
      * Function for spin logic of the game
      * This function is responsible for:
@@ -614,10 +624,6 @@ export class AbstractController {
             this.invokeFreeSpinSummaryPlateAfterWin = true;
             RainMan.componentRegistry.getIfExists(FreeSpinButton.registryName)?.setInteractivity(true);
         }
-        if (RainMan.componentRegistry.has(BUTTONS.gamble))
-            RainMan.componentRegistry
-                .get(BUTTONS.gamble)
-                .flipDisabledFlag(RainMan.settingsStore.isFreeSpinsPlayEnabled || spinLogic.winTotalAmount === 0);
         RainMan.settingsStore.setTotalNumberOfFreeSpins(availableFreeSpins);
         RainMan.settingsStore.setNumberOfFreeSpin(availableFreeSpins);
         await new Promise((resolveAfterSpins) => {
@@ -915,6 +921,9 @@ export class AbstractController {
             this.uiController.updateShownBalance();
         }
     }
+    updateGambleValues(value) {
+        this.uiController.setDisplayedCurrentWinGamble(value);
+    }
     /**
      * Function will turn off loop while `RainMan.settingsStore.isAutoplayEnabled` is `true`
      */

package/dist/controllers/UiController.d.ts

@@ -56,4 +56,5 @@ export declare class UiController {
     triggerUiElementsUpdate(): void;
     private setDisplayedBalance;
     private setDisplayedCurrentWin;
+    setDisplayedCurrentWinGamble(value: number): void;
 }

package/dist/controllers/UiController.js

@@ -166,4 +166,11 @@ export class UiController {
         }
         RainMan.componentRegistry.get(MessageBox.currentWinTextRegistryName).set(this._recentWin);
     }
+    setDisplayedCurrentWinGamble(value) {
+        if (RainMan.settingsStore.isFreeSpinsPlayEnabled) {
+            RainMan.componentRegistry.get(MessageBox.currentWinTextRegistryName).set(this.totalFreeSpinWinAmount);
+            return;
+        }
+        RainMan.componentRegistry.get(MessageBox.currentWinTextRegistryName).set(value);
+    }
 }

package/dist/stores/SettingsStore.d.ts

@@ -26,6 +26,8 @@ export declare class SettingsStore {
     roundNumber: number;
     HiResolutionFlag: boolean;
     batterySaverFlag: boolean;
+    gambleGameUsed: boolean;
+    gambleGameWin: number;
     containersWithSpines: (ResumableContainer | SpineWithResumableContainer | SpriteWithResumableContainer)[];
     cumulativeWinAmount: number;
     progress: number;

package/dist/stores/SettingsStore.js

@@ -32,6 +32,8 @@ export class SettingsStore {
     roundNumber = 0;
     HiResolutionFlag = getFromLocalStorage(LOCAL_STORAGE.hiResolution, true);
     batterySaverFlag = getFromLocalStorage(LOCAL_STORAGE.batterySaver, false);
+    gambleGameUsed = false;
+    gambleGameWin = 0;
     containersWithSpines = [];
     cumulativeWinAmount = 0;
     progress = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pixi-rainman-game-engine",
-    "version": "0.2.4",
+    "version": "0.2.5",
     "description": "This repository contains all of the mechanics that used in rainman games.",
     "main": "./dist/index.js",
     "module": "./dist/index.js",
@@ -13,7 +13,8 @@
         "lint": "eslint src/** --fix",
         "prepublishOnly": "husky && yarn build",
         "prepare": "husky",
-        "docs": "typedoc --options typedoc.json "
+        "docs": "typedoc --options typedoc.json",
+        "deploy:upload": "rsync -avr docker-compose.yml game-server:ops-casino/"
     },
     "type": "module",
     "author": "@niceguys",