pixi-rainman-game-engine 0.1.5 → 0.1.6

package/dist/Rainman/appConfig.js

@@ -6,6 +6,7 @@ export const defaultAppConfig = {
     idleTimeout: 10000,
     fontSize: 35,
     mobileFontSize: 45,
+    updatableSpineContainerFontSize: 50,
     fontColor: new Color(0xfbd400).toHex(),
     updatableTextValueColor: new Color(0xffffff).toHex(),
     fontFace: "HelveticaNeueLTStd",

package/dist/Rainman/types.d.ts

@@ -14,6 +14,7 @@ export type OptionalAppConfig = {
     idleTimeout: number;
     currency: Currency;
     fontSize: number;
+    updatableSpineContainerFontSize: number;
     mobileFontSize: number;
     fontColor: string;
     updatableTextValueColor: string;

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

@@ -4,7 +4,7 @@ import React from "react";
 export const SlidingSwitch = observer(({ flag, setFlag }) => {
     return (<label className="switch">
             <span className={`switch-round-box round ${flag ? "switch-round-box--active" : ""}`}/>
-            <input type="checkbox" defaultChecked={flag} onChange={(event) => setFlag(event.target.checked)}/>
+            <input type="checkbox" checked={flag} onChange={(event) => setFlag(event.target.checked)}/>
             <p className={`switch__text ${flag ? "switch__text--active" : ""}`}>{flag ? "ON" : "OFF"}</p>
         </label>);
 });

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

@@ -5,41 +5,32 @@ import Slider from "rc-slider";
 import React from "react";
 import { RainMan } from "../../../Rainman";
 import { useStores } from "../../hooks";
-const handleStyle = { width: "7px", height: "24px", bottom: "-6px", borderRadius: "4px" };
 const onChange = (newVolumeLevel) => {
     RainMan.settingsStore.setVolumeLevel(newVolumeLevel);
-    RainMan.settingsStore.setIsSoundEnabled(newVolumeLevel > 0);
+    RainMan.settingsStore.flipSoundsEnabled(newVolumeLevel);
 };
 export const VolumeSettings = observer(() => {
     const { settingStore } = useStores();
+    const COLOR = settingStore.isSoundEnabled() ? "#2FC408" : "#FA5F27";
     return (<div className="volume-control">
             <div className="volume-control__volume-icon"></div>
-            <Slider className="volume-control__slider" step={1} min={0} max={100} value={settingStore.volumeLevel} handleStyle={settingStore.volumeLevel === 0
-            ? {
-                backgroundColor: "#FA5F27",
-                borderColor: "#FA5F27",
-                ...handleStyle,
-            }
-            : {
-                backgroundColor: "#2FC408",
-                borderColor: "#2FC408",
-                ...handleStyle,
-            }} railStyle={{
+            <Slider className="volume-control__slider" step={1} min={0} max={100} value={settingStore.volumeLevel} handleStyle={{
+            backgroundColor: COLOR,
+            borderColor: COLOR,
+            width: "7px",
+            height: "24px",
+            bottom: "-6px",
+            borderRadius: "4px",
+        }} railStyle={{
             backgroundColor: "#fff",
         }} trackStyle={{
-            backgroundColor: "#fff",
+            backgroundColor: COLOR,
             height: "5px",
             borderRadius: "1px",
-        }} dotStyle={{
-            borderColor: "#2FC408",
         }} onChange={onChange}/>
-            <p className="volume-control__text" style={settingStore.volumeLevel === 0
-            ? {
-                color: "#FA5F27",
-            }
-            : {
-                color: "#2FC408",
-            }}>
+            <p className="volume-control__text" style={{
+            color: COLOR,
+        }}>
                 {settingStore.volumeLevel}
             </p>
         </div>);

package/dist/application/ApiConfig/ApiConfig.js

@@ -1,5 +1,5 @@
 import { RainMan } from "../../Rainman";
-import { debug } from "../../utils";
+import { logError } from "../../utils";
 export class ApiConfig {
     token;
     symbolMap = new Map();
@@ -73,7 +73,7 @@ export class ApiConfig {
         for (const [key, name] of data.symbols_names.entries()) {
             const backendId = data.symbols[key];
             if (!Object.values(RainMan.symbolIds).includes(name)) {
-                debug(`🛑 "${name}" was not found in SymbolIds enum!`);
+                logError(`🛑 "${name}" was not found in SymbolIds enum!`);
             }
             this.symbolMap.set(backendId, name);
         }

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

@@ -1,3 +1,3 @@
 export interface SymbolIds {
 }
-export type SymbolId = keyof SymbolIds;
+export type SymbolId = SymbolIds[keyof SymbolIds];

package/dist/application/ButtonsEventManager/ButtonsEventManager.js

@@ -112,7 +112,7 @@ export class ButtonsEventManager {
     initVolumeButtonEvent() {
         RainMan.settingsStore.setUpdateVolumeButtonTexture(() => RainMan.componentRegistry.get(VolumeButton.registryName).changeTextureDependOnVolume());
         RainMan.componentRegistry.get(VolumeButton.registryName).setOnClick(() => {
-            RainMan.settingsStore.setIsSoundEnabled(!RainMan.settingsStore.isSoundEnabled);
+            RainMan.settingsStore.flipSoundsEnabled();
             RainMan.componentRegistry.get(VolumeButton.registryName).changeTextureDependOnVolume();
             this.handleModalInvocation(UI_ITEMS.volume);
         });

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

@@ -10,7 +10,7 @@ export declare class SoundManagerInstance implements SpeedAdapterInterface<Sound
     constructor();
     loadSounds(assets: Record<string, string>): Promise<void>;
     setVolume(volumeLevel: number): void;
-    setFxSoundsVolume(volumeLevel: number): void;
+    stopPlayingFxSounds(): void;
     setPlayStatus(soundName: SoundTrack, flag: boolean): void;
     play(soundName: SoundTrack): void;
     pause(soundName: SoundTrack): void;

package/dist/application/SoundManager/SoundManager.js

@@ -1,7 +1,7 @@
 import { Sound } from "@pixi/sound";
 import { RainMan } from "../../Rainman";
 import { SoundTracks } from "./types";
-const soundsToLoop = [SoundTracks.bonusWaitingLoop, SoundTracks.music];
+const soundsToLoop = [SoundTracks.mysteryFxLoop, SoundTracks.music];
 export class SoundManagerInstance {
     static instance;
     static getInstance() {
@@ -23,46 +23,51 @@ export class SoundManagerInstance {
     async loadSounds(assets) {
         const loadingSoundsPromises = [];
         for (const [soundName, url] of Object.entries(assets)) {
-            const loadingPromise = new Promise((resolve) => {
+            if (!url)
+                continue;
+            loadingSoundsPromises.push(new Promise((resolve) => {
                 const sound = Sound.from({
                     url,
                     autoPlay: false,
                     preload: true,
-                    loaded: () => {
-                        resolve();
-                    },
+                    loop: soundsToLoop.includes(soundName),
+                    loaded: () => resolve(),
                 });
                 this.musicCatalogue.set(soundName, sound);
-            });
-            loadingSoundsPromises.push(loadingPromise);
+            }));
         }
         await Promise.all(loadingSoundsPromises);
     }
     setVolume(volumeLevel) {
         this.musicCatalogue.forEach((sound) => (sound.volume = volumeLevel));
     }
-    setFxSoundsVolume(volumeLevel) {
-        if (!RainMan.settingsStore.isSoundEnabled)
-            return;
+    stopPlayingFxSounds() {
         for (const [soundName, sound] of this.musicCatalogue.entries()) {
             if (soundName === SoundTracks.music)
                 continue;
-            sound.volume = volumeLevel;
+            sound.pause();
         }
     }
     setPlayStatus(soundName, flag) {
         flag ? this.play(soundName) : this.pause(soundName);
     }
     play(soundName) {
-        if (!RainMan.settingsStore.isSoundEnabled)
-            return;
+        if (soundName === "music") {
+            if (!RainMan.settingsStore.ambientMusicFlag)
+                return;
+        }
+        else {
+            if (!RainMan.settingsStore.soundFxFlag)
+                return;
+        }
         const overrideSoundName = this.overrides[soundName];
         const sound = overrideSoundName
             ? this.musicCatalogue.get(overrideSoundName)
             : this.musicCatalogue.get(soundName);
         if (!sound)
             return;
-        sound.loop = soundsToLoop.includes(soundName);
+        if (soundName === "music" && sound.isPlaying)
+            return;
         sound.play();
     }
     pause(soundName) {

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

@@ -1,21 +1,45 @@
-export declare const SoundTracks: {
-    readonly button: "button";
-    readonly deactivationAutostart: "deactivationAutostart";
-    readonly increaseRate: "increaseRate";
-    readonly music: "music";
-    readonly reductionRate: "reductionRate";
-    readonly allRollStops: "allRollStops";
-    readonly bigWin: "bigWin";
-    readonly bonus: "bonus";
-    readonly bonusExtra: "bonusExtra";
-    readonly bonusWaitingEnd: "bonusWaitingEnd";
-    readonly bonusWaitingLoop: "bonusWaitingLoop";
-    readonly line: "line";
-    readonly mystery: "mystery";
-    readonly mysteryDrawLoop: "mysteryDrawLoop";
-    readonly rollStop: "rollStop";
-    readonly start: "start";
-    readonly wild: "wild";
-    readonly symbol: "symbol";
-};
-export type SoundTrack = (typeof SoundTracks)[keyof typeof SoundTracks];
+export declare const SoundTracks: SoundTracks;
+export interface SoundTracks {
+    button: "button";
+    deactivationAutostart: "deactivationAutostart";
+    increaseRate: "increaseRate";
+    music: "music";
+    reductionRate: "reductionRate";
+    allRollStops: "allRollStops";
+    bigWin: "bigWin";
+    boom: "boom";
+    standaloneBoom: "standaloneBoom";
+    symbolsFalling: "symbolsFalling";
+    mysteryFxEnd: "mysteryFxEnd";
+    mysteryFxLoop: "mysteryFxLoop";
+    line: "line";
+    mysteryDrawLoop: "mysteryDrawLoop";
+    rollStop: "rollStop";
+    specialSymbolOnReel: "specialSymbolOnReel";
+    start: "start";
+    symbol: "symbol";
+}
+export type SoundTrack = SoundTracks[keyof SoundTracks];
+/**
+ * Object for mapping SoundTracks to appropriate asset.
+ * All properties must be set, if no sound should be played set empty string
+ * @property {string} button - default click button sound
+ * @property {string} deactivationAutostart - click on autostart button
+ * @property {string} increaseRate - click on plus button
+ * @property {string} music - ambient music in loop
+ * @property {string} reductionRate - click on neg button
+ * @property {string} allRollStops - skipping rolling reels, on end
+ * @property {string} bigWin - on show big win popup
+ * @property {string} boom - symbol destroy
+ * @property {string} standaloneBoom - symbol destroy for standalone
+ * @property {string} symbolsFalling - dropping symbols after destroy
+ * @property {string} mysteryFxEnd - on mystery fx hides
+ * @property {string} mysteryFxLoop - when mystery fx in visible in loop
+ * @property {string} line - default win line sound, for both single and multiple lines
+ * @property {string} mysteryDrawLoop - on show mystery popup, play during randomizing win
+ * @property {string} rollStop - single reel stopping
+ * @property {string} specialSymbolOnReel - single reel stopping with special symbol like bonus or mystery
+ * @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>;

package/dist/application/SoundManager/types.js

@@ -6,15 +6,15 @@ export const SoundTracks = {
     reductionRate: "reductionRate",
     allRollStops: "allRollStops",
     bigWin: "bigWin",
-    bonus: "bonus",
-    bonusExtra: "bonusExtra",
-    bonusWaitingEnd: "bonusWaitingEnd",
-    bonusWaitingLoop: "bonusWaitingLoop",
+    boom: "boom",
+    standaloneBoom: "standaloneBoom",
+    symbolsFalling: "symbolsFalling",
+    mysteryFxEnd: "mysteryFxEnd",
+    mysteryFxLoop: "mysteryFxLoop",
     line: "line",
-    mystery: "mystery",
     mysteryDrawLoop: "mysteryDrawLoop",
     rollStop: "rollStop",
+    specialSymbolOnReel: "specialSymbolOnReel",
     start: "start",
-    wild: "wild",
     symbol: "symbol",
 };

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

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

package/dist/application/SpinLogic/SpinLogic.js

@@ -1,4 +1,4 @@
-import { debug } from "../../utils";
+import { logInfo } from "../../utils";
 import { SpinLogicDTO } from "./SpinLogicDTO";
 export class SpinLogic {
     _postSpinBalance;
@@ -6,7 +6,9 @@ export class SpinLogic {
     _onStopBlindsConfiguration;
     _finalBlindsConfiguration;
     _availableFreeSpins;
+    _hasMysteryWin;
     _winScenarios;
+    _standaloneTransformations;
     constructor(spinConfig, gameConfig) {
         const spinLogicReader = new SpinLogicDTO(spinConfig, gameConfig);
         this._postSpinBalance = spinLogicReader.updatedBalance;
@@ -14,8 +16,10 @@ export class SpinLogic {
         this._onStopBlindsConfiguration = spinLogicReader.onStopBlindsConfiguration;
         this._finalBlindsConfiguration = spinLogicReader.finalBlindsConfiguration;
         this._availableFreeSpins = spinLogicReader.freeSpinsRemaining;
+        this._hasMysteryWin = spinLogicReader.hasMysteryWin;
         this._winScenarios = spinLogicReader.winScenarios;
-        debug(JSON.stringify(this));
+        this._standaloneTransformations = spinLogicReader.standaloneTransformations;
+        logInfo("Spin logic", JSON.parse(JSON.stringify(this)));
     }
     get postSpinBalance() {
         return this._postSpinBalance;
@@ -32,7 +36,13 @@ export class SpinLogic {
     get availableFreeSpins() {
         return this._availableFreeSpins;
     }
+    get hasMysteryWin() {
+        return this._hasMysteryWin;
+    }
     get winScenarios() {
         return this._winScenarios;
     }
+    get standaloneTransformations() {
+        return this._standaloneTransformations;
+    }
 }

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

@@ -1,4 +1,4 @@
-import { SymbolReels } from "../../connectivity";
+import { SymbolReels, TransformationDetails } from "../../connectivity";
 import { ApiConfig } from "../ApiConfig";
 import { AdaptedSpinResponse } from "./types";
 import { WinScenarios } from "./WinScenarios";
@@ -12,6 +12,8 @@ export declare class SpinLogicDTO {
     get finalBlindsConfiguration(): SymbolReels;
     get onStopBlindsConfiguration(): SymbolReels;
     get winScenarios(): WinScenarios[];
+    get standaloneTransformations(): TransformationDetails[][];
+    get hasMysteryWin(): boolean;
     private getSingleWin;
     private getWinsFromRawData;
     private stringToSymbolId;

package/dist/application/SpinLogic/SpinLogicDTO.js

@@ -1,4 +1,3 @@
-import { invert } from "lodash";
 import { PossibleWins } from "../../constants";
 import { RainMan } from "../../Rainman";
 import { WinScenarios } from "./WinScenarios";
@@ -48,6 +47,17 @@ export class SpinLogicDTO {
             return new WinScenarios(win, result.transformations);
         });
     }
+    get standaloneTransformations() {
+        const { standaloneTransformations } = this.rawData;
+        if (!standaloneTransformations)
+            return [];
+        return standaloneTransformations;
+    }
+    get hasMysteryWin() {
+        return this.winScenarios.some((winScenario) => {
+            return winScenario.wins.some((win) => win.type === PossibleWins.mystery);
+        });
+    }
     getSingleWin(singleWin, availableFreeSpins) {
         const rawWin = {
             type: this.gameConfig.getWinId(singleWin.typeId),
@@ -57,7 +67,7 @@ export class SpinLogicDTO {
             quantity: singleWin.quantity,
             spinId: singleWin.spinId,
             multiplier: singleWin.multiplier,
-            typeId: singleWin.typeId
+            typeId: singleWin.typeId,
         };
         if (rawWin.type === PossibleWins.freeSpins) {
             const remainingFreeSpins = Math.max(RainMan.settingsStore.howManyFreeSpinsLeft - 1, 0);
@@ -69,6 +79,6 @@ export class SpinLogicDTO {
         return rawData.wins.map((win) => this.getSingleWin(win, availableFreeSpins));
     }
     stringToSymbolId(symbol) {
-        return invert(RainMan.symbolIds)[symbol];
+        return symbol;
     }
 }

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

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

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

@@ -3,4 +3,4 @@ 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 isBlindsConfiguredByTransformations: (results: Result[]) => number[][] | null;
-export declare const collectWinDetailsWithTransformation: (winIndex: string, winsDetails: RawWin, transformations: TransformationDetails[]) => WinWithTransformationInterface;
+export declare const collectWinDetailsWithTransformation: (winIndex: string | null, winsDetails: RawWin, transformations: TransformationDetails[]) => WinWithTransformationInterface;

package/dist/application/SpinLogic/util.js

@@ -77,7 +77,7 @@ export const isBlindsConfiguredByTransformations = (results) => {
 };
 export const collectWinDetailsWithTransformation = (winIndex, winsDetails, transformations) => {
     return {
-        wins: [getWinFromRawResponse(winsDetails, winIndex)],
+        wins: [getWinFromRawResponse(winsDetails, winIndex ?? "")],
         transformations,
     };
 };

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

@@ -1,25 +1,27 @@
-import { Container, Graphics, ITextStyle, Sprite } from "pixi.js";
+import { Container, Graphics, Sprite } from "pixi.js";
 import { ButtonsEventManager } from "../../application";
 import { AbstractController } from "../../controllers";
 import { Nullable } from "../../utils";
 import { UpdatableSpineContainer } from "../../winComponents";
 import { AbstractFreeSpinContainer } from "../AbstractFreeSpinContainer";
-import { AbstractMiddleButtons } from "../buttons";
-import { Background, Logo, ResponsiveContainer } from "../common";
+import { LeftButtons, LeftButtonsLandscape, LeftButtonsMobile, MiddleButtons, RightButtons, RightButtonsLandscape, RightButtonsMobile } from "../buttons";
+import { AnimatedBackground, Background, FreeSpinBox, Logo, ResponsiveContainer } from "../common";
 import { AbstractFrame } from "../frame";
 import { MessageBox } from "../messageBox";
 export declare abstract class AbstractMainContainer extends Container {
     static readonly registryName = "mainContainer";
-    private bigWinContainer;
-    private mysteryWinContainer;
+    protected bigWinContainer: Nullable<UpdatableSpineContainer>;
+    protected mysteryWinContainer: Nullable<UpdatableSpineContainer>;
     private overlay;
     messageBox: MessageBox;
     protected readonly buttonsEventManager: ButtonsEventManager;
     protected logo: Nullable<Logo>;
-    protected abstract background: Background;
+    protected background: Nullable<Background>;
+    protected animatedBackground: Nullable<AnimatedBackground>;
+    protected abstract freeSpinBox: Nullable<FreeSpinBox>;
     protected underFramePanel: Nullable<Graphics>;
-    protected portraitPlayButtons: Nullable<AbstractMiddleButtons>;
-    protected landscapePlayButtons: Nullable<AbstractMiddleButtons>;
+    protected portraitPlayButtons: Nullable<MiddleButtons>;
+    protected landscapePlayButtons: Nullable<MiddleButtons>;
     protected abstract leftButtons: ResponsiveContainer;
     protected abstract rightButtons: ResponsiveContainer;
     protected abstract bottomPanel: Sprite;
@@ -29,7 +31,7 @@ export declare abstract class AbstractMainContainer extends Container {
     private _mysteryWinInvokedAt;
     protected abstract _frame: AbstractFrame;
     protected _controller: Nullable<AbstractController>;
-    protected constructor(messageBoxTextStyle: Partial<ITextStyle>);
+    protected constructor();
     get freeSpinPlate(): Nullable<AbstractFreeSpinContainer>;
     get freeSpinSummary(): Nullable<AbstractFreeSpinContainer>;
     protected abstract createFreeSpinPlate(resolver: () => void, freeSpinCount: number, isAdditionalFreeSpin: boolean): AbstractFreeSpinContainer;
@@ -48,20 +50,20 @@ export declare abstract class AbstractMainContainer extends Container {
     destroyBigWin(): void;
     destroyMysteryWin(): void;
     invokeGambleGame(): void;
-    protected abstract createPortraitPlayButtons(): AbstractMiddleButtons;
     enableForMobile(): void;
-    protected abstract createLandscapePlayButtons(): AbstractMiddleButtons;
     enableForLandscape(): void;
     disableForMobile(): void;
     disableForLandscape(): void;
     protected abstract repositionComponentsForScreenRatio(): void;
     resize(): void;
-    protected abstract createLeftButtons(): ResponsiveContainer;
-    protected abstract createRightButtons(): ResponsiveContainer;
-    protected abstract createLeftButtonsMobile(): ResponsiveContainer;
-    protected abstract createRightButtonsMobile(): ResponsiveContainer;
-    protected abstract createLeftButtonsLandscape(): ResponsiveContainer;
-    protected abstract createRightButtonsLandscape(): ResponsiveContainer;
+    protected createLeftButtons(): LeftButtons;
+    protected createRightButtons(): RightButtons;
+    protected createLeftButtonsMobile(): LeftButtonsMobile;
+    protected createRightButtonsMobile(): RightButtonsMobile;
+    protected createLeftButtonsLandscape(): LeftButtonsLandscape;
+    protected createRightButtonsLandscape(): RightButtonsLandscape;
+    protected createPortraitPlayButtons(): MiddleButtons;
+    protected createLandscapePlayButtons(): MiddleButtons;
     private initComponentsForScreenRatio;
     private resizeDependentComponents;
     protected refreshLayers(): void;