pixi-rainman-game-engine 0.0.4 → 0.0.6

package/LICENSE

@@ -0,0 +1 @@
+ISC

package/README.md

@@ -1,6 +1,6 @@
-# Rainman pixi game engine
+# RainMan pixi game engine
 
-This repository contains all of the mechanics that used in rainman games.
+This repository contains all of the mechanics that used in rainMan games. This library uses pixi and pixi-spine as dependencies.
 
 ### Scripts
 
@@ -18,3 +18,8 @@ This repository contains all of the mechanics that used in rainman games.
 Code for the game engine contains in the `src` directory. For create an feature you should add new directory into `src` directory. For example: `freeSpins` and in this folder contains all of the mechanics.
 
 In utils directory there all of the utility functions and types.
+
+### Test environment
+
+To simulate behavior of game engine mechanics, this repository contains react-pixi app, where you can test features that are included in game engine.
+Test environment uses local built of game engine. To setup test environment go to [README](./src/test-environment/README.md) of test environment.

package/dist/ComponentRegistry/ComponentRegistry.d.ts

@@ -0,0 +1,24 @@
+import { Application, Container } from "pixi.js";
+import { SpeedLevel } from "../application";
+import { RegistryMap } from "./types";
+export declare class ComponentRegistry {
+    private registry;
+    private speedAdaptableComponents;
+    private incentiveJobsManager;
+    private speedLevelHandler;
+    constructor(app: Application);
+    setTemporarySpeedLevel(newSpeedLevel: SpeedLevel): void;
+    revertTemporarySpeedLevel(): void;
+    setSpeedLevel(newSpeedLevel: SpeedLevel): void;
+    nextSpeedLevel(): void;
+    getSpeedLevel(): SpeedLevel;
+    setUserActivityTime(): void;
+    add(component: Container): void;
+    update(oldComponent: Container, newComponent: Container): void;
+    remove(component: Container): void;
+    updateAllSpeedAdaptable(speedLevel: SpeedLevel): void;
+    get<T extends keyof RegistryMap>(componentName: T): RegistryMap[T];
+    has<T extends keyof RegistryMap>(componentName: T): boolean;
+    addMany(components: Container[]): void;
+    removeMany(components: Container[]): void;
+}

package/dist/ComponentRegistry/ComponentRegistry.js

@@ -0,0 +1,101 @@
+import { isIncentiveComponentInterface, isSpeedAdapterInterface, SpeedLevelHandler, TimedIncentiveController, } from "../application";
+import { SpeedControlButton } from "../components";
+import { RainMan } from "../Rainman";
+import { openFullscreen } from "../utils";
+export class ComponentRegistry {
+    registry = new Map();
+    speedAdaptableComponents = new Set();
+    incentiveJobsManager;
+    speedLevelHandler = SpeedLevelHandler.initWithDefaultSpeedLevels();
+    constructor(app) {
+        this.incentiveJobsManager = new TimedIncentiveController();
+        app.renderer.addListener("pointerdown", () => {
+            this.setUserActivityTime();
+            openFullscreen();
+        });
+    }
+    setTemporarySpeedLevel(newSpeedLevel) {
+        this.speedLevelHandler.setSpeed(newSpeedLevel);
+        this.updateAllSpeedAdaptable(this.speedLevelHandler.currentSpeed);
+    }
+    revertTemporarySpeedLevel() {
+        this.speedLevelHandler.setSpeed(RainMan.settingsStore.currentSpeed);
+        this.updateAllSpeedAdaptable(this.speedLevelHandler.currentSpeed);
+    }
+    setSpeedLevel(newSpeedLevel) {
+        this.speedLevelHandler.setSpeed(newSpeedLevel);
+        RainMan.settingsStore.setSpeedLevel(this.speedLevelHandler.currentSpeed);
+        this.updateAllSpeedAdaptable(RainMan.settingsStore.currentSpeed);
+        this.get(SpeedControlButton.registryName).forceTextureUpdate();
+    }
+    nextSpeedLevel() {
+        this.speedLevelHandler.nextSpeed();
+        RainMan.settingsStore.setSpeedLevel(this.speedLevelHandler.currentSpeed);
+        this.updateAllSpeedAdaptable(RainMan.settingsStore.currentSpeed);
+        this.get(SpeedControlButton.registryName).forceTextureUpdate();
+    }
+    getSpeedLevel() {
+        return this.speedLevelHandler.currentSpeed;
+    }
+    setUserActivityTime() {
+        this.incentiveJobsManager.updateLastTimeClicked();
+    }
+    add(component) {
+        if (isSpeedAdapterInterface(component)) {
+            this.speedAdaptableComponents.add(component);
+        }
+        if (isIncentiveComponentInterface(component)) {
+            this.incentiveJobsManager.addComponent(component);
+        }
+        if (component.name == null) {
+            throw new Error("Component must have a name!");
+        }
+        if (this.registry.get(component.name) === undefined) {
+            this.registry.set(component.name, component);
+            return;
+        }
+        throw Error(`Cannot re-add component with the same name: ${component.name}`);
+    }
+    update(oldComponent, newComponent) {
+        if (oldComponent.name !== newComponent.name) {
+            throw new Error(`Cannot update component ${oldComponent.name} to ${newComponent.name}`);
+        }
+        if (isSpeedAdapterInterface(oldComponent)) {
+            this.speedAdaptableComponents.delete(oldComponent);
+            if (isSpeedAdapterInterface(newComponent)) {
+                this.speedAdaptableComponents.add(newComponent);
+            }
+        }
+        if (oldComponent.name)
+            this.registry.set(oldComponent.name, newComponent);
+    }
+    remove(component) {
+        if (component.name)
+            this.registry.delete(component.name);
+    }
+    updateAllSpeedAdaptable(speedLevel) {
+        this.speedAdaptableComponents.forEach((speedAdaptableComponent) => {
+            speedAdaptableComponent.adaptToSpeed(speedLevel);
+        });
+    }
+    get(componentName) {
+        const componentToReturn = this.registry.get(componentName);
+        if (componentToReturn == undefined) {
+            throw new Error(`component with name '${componentName}' does not exist in registry`);
+        }
+        return componentToReturn;
+    }
+    has(componentName) {
+        return this.registry.has(componentName);
+    }
+    addMany(components) {
+        for (const component of components) {
+            this.add(component);
+        }
+    }
+    removeMany(components) {
+        for (const component of components) {
+            this.remove(component);
+        }
+    }
+}

package/dist/ComponentRegistry/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ComponentRegistry";
+export * from "./types";

package/dist/ComponentRegistry/index.js

@@ -0,0 +1,2 @@
+export * from "./ComponentRegistry";
+export * from "./types";

package/dist/ComponentRegistry/types.d.ts

@@ -0,0 +1,25 @@
+import { AbstractColumnsContainer, AbstractFrame, AbstractInnerFrame, AutoplayButton, Background, BaseButton, BUTTONS, COMPONENTS, FreeSpinBox, MessageBox, SpeedControlButton, StylefulUpdatableText, UpdatableTextComponent, UpdatableValueComponent, VolumeButton } from "../components";
+export interface RegistryMap {
+    [MessageBox.autoSpinTextRegistryName]: UpdatableValueComponent;
+    [MessageBox.currentWinTextRegistryName]: UpdatableTextComponent;
+    [MessageBox.freeSpinTextRegistryName]: UpdatableTextComponent;
+    [MessageBox.registryName]: MessageBox;
+    [SpeedControlButton.registryName]: SpeedControlButton;
+    [Background.registryName]: Background;
+    [VolumeButton.registryName]: VolumeButton;
+    [AutoplayButton.registryName]: AutoplayButton;
+    [FreeSpinBox.registryName]: FreeSpinBox;
+    [AbstractFrame.registryName]: AbstractFrame;
+    [AbstractInnerFrame.registryName]: AbstractInnerFrame;
+    [AbstractColumnsContainer.registryName]: AbstractColumnsContainer;
+    [BUTTONS.refresh]: BaseButton;
+    [BUTTONS.plus]: BaseButton;
+    [BUTTONS.neg]: BaseButton;
+    [BUTTONS.info]: BaseButton;
+    [BUTTONS.more]: BaseButton;
+    [BUTTONS.gamble]: BaseButton;
+    [COMPONENTS.betText]: UpdatableTextComponent;
+    [COMPONENTS.creditText]: UpdatableTextComponent;
+    [COMPONENTS.bigWin]: StylefulUpdatableText;
+    [COMPONENTS.mysteryWin]: StylefulUpdatableText;
+}

package/dist/ComponentRegistry/types.js

@@ -0,0 +1 @@
+import { AbstractColumnsContainer, AbstractFrame, AbstractInnerFrame, AutoplayButton, Background, BUTTONS, COMPONENTS, FreeSpinBox, MessageBox, SpeedControlButton, VolumeButton, } from "../components";

package/dist/DescribedPlayableAction/DescribedPlayableAction.d.ts

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

package/dist/DescribedPlayableAction/DescribedPlayableAction.js

@@ -0,0 +1,11 @@
+export class DescribedPlayableAction {
+    type;
+    action;
+    winAmount;
+    isFirstStreak = false;
+    constructor(type, action, winAmount = null) {
+        this.type = type;
+        this.action = action;
+        this.winAmount = winAmount;
+    }
+}

package/dist/DescribedPlayableAction/index.d.ts

@@ -0,0 +1 @@
+export * from "./DescribedPlayableAction";

package/dist/DescribedPlayableAction/index.js

@@ -0,0 +1 @@
+export * from "./DescribedPlayableAction";

package/dist/Money/MoneyText.d.ts

@@ -0,0 +1,5 @@
+export declare class MoneyText {
+    private readonly money;
+    constructor(amount: number);
+    toString(): string;
+}

package/dist/Money/MoneyText.js

@@ -0,0 +1,11 @@
+import { Money } from "ts-money";
+import { RainMan } from "../Rainman";
+export class MoneyText {
+    money;
+    constructor(amount) {
+        this.money = Money.fromDecimal(amount, RainMan.config?.currency, Math.round);
+    }
+    toString() {
+        return `${this.money} ${RainMan.config.currency}`;
+    }
+}

package/dist/Money/index.d.ts

@@ -0,0 +1 @@
+export * from "./MoneyText";

package/dist/Money/index.js

@@ -0,0 +1 @@
+export * from "./MoneyText";

package/dist/Rainman/Rainman.d.ts

@@ -0,0 +1,16 @@
+import "../components/dictionary/i18n";
+import { Application } from "pixi.js";
+import { SpinLogicFactory, SymbolIds, WinTypeIds } from "../application";
+import { ComponentRegistry } from "../ComponentRegistry";
+import { SettingsStore } from "../stores";
+import { AppConfig, OptionalAppConfig, RequiredAppConfig } from "./types";
+export declare class RainMan {
+    static app: Application;
+    static config: RequiredAppConfig & OptionalAppConfig;
+    static symbolIds: SymbolIds;
+    static winTypeIds: WinTypeIds;
+    static settingsStore: SettingsStore;
+    static componentRegistry: ComponentRegistry;
+    static spinLogicFactory: SpinLogicFactory;
+    constructor(app: Application, config: AppConfig, symbolIds: SymbolIds, winTypeIds: WinTypeIds, spinLogicFactory: SpinLogicFactory);
+}

package/dist/Rainman/Rainman.js

@@ -0,0 +1,23 @@
+import "../components/dictionary/i18n";
+import { merge } from "lodash";
+import { ComponentRegistry } from "../ComponentRegistry";
+import { SettingsStore } from "../stores";
+import { defaultAppConfig } from "./appConfig";
+export class RainMan {
+    static app;
+    static config;
+    static symbolIds;
+    static winTypeIds;
+    static settingsStore;
+    static componentRegistry;
+    static spinLogicFactory;
+    constructor(app, config, symbolIds, winTypeIds, spinLogicFactory) {
+        RainMan.app = app;
+        RainMan.config = merge(defaultAppConfig, config);
+        RainMan.symbolIds = symbolIds;
+        RainMan.winTypeIds = winTypeIds;
+        RainMan.settingsStore = new SettingsStore();
+        RainMan.componentRegistry = new ComponentRegistry(app);
+        RainMan.spinLogicFactory = spinLogicFactory;
+    }
+}

package/dist/Rainman/appConfig.d.ts

@@ -0,0 +1,2 @@
+import { OptionalAppConfig } from "./types";
+export declare const defaultAppConfig: OptionalAppConfig;

package/dist/Rainman/appConfig.js

@@ -0,0 +1,41 @@
+import { Color } from "pixi.js";
+import { Currencies } from "ts-money";
+export const defaultAppConfig = {
+    gameHeight: 1920,
+    gameWidth: 1080,
+    idleTimeout: 10000,
+    fontSize: 35,
+    fontColor: new Color(0xfbd400).toHex(),
+    updatableTextValueColor: new Color(0xffffff).toHex(),
+    fontFace: "HelveticaNeueLTStd",
+    currency: Currencies["USD"],
+    durationOfActions: {
+        eachColumnsSpinDelay: [0, 200, 700, 1200, 1800],
+        spinBaseTime: 800,
+        timeToSpeedUp: 200,
+        timeToSlowDown: 10,
+        symbolDropDownTime: 500,
+        wiggleTweenDuration: 1000,
+        balloonFlyUpTime: 500,
+        timeToSetResults: 10,
+        bigWinDuration: 2000,
+        minConfettiTime: 1000,
+        maxConfettiTime: 5000,
+        randomizeSetInterval: 250,
+        randomizeSetDuration: 2000,
+        freeSpinPlateVisibleTime: 2000,
+        freeSpinSummaryVisibleTime: 2000,
+        updatableTextCountingDuration: 500,
+        scatterDelayerTime: 2000,
+        scatterSpinningTime: 9200,
+        mobileSpinTimeout: 300,
+        mysteryWinMinimumTime: 2000,
+        bigWinMinimumTime: 2000,
+        bigWinPhaseTimeout: 2800,
+        speedPopupVisibleTime: 2000,
+        minAnimationTime: 1000,
+    },
+    constants: {
+        bigWinMultiplier: 30,
+    },
+};

package/dist/Rainman/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./appConfig";
+export * from "./Rainman";
+export * from "./types";

package/dist/Rainman/index.js

@@ -0,0 +1,3 @@
+export * from "./appConfig";
+export * from "./Rainman";
+export * from "./types";

package/dist/Rainman/types.d.ts

@@ -0,0 +1,50 @@
+import { Currency } from "ts-money";
+import { DeepPartial } from "../utils";
+export type RequiredAppConfig = {
+    websocketUrl: string;
+    gameInitToken: string;
+    gameInitVendorId: number;
+    gameInitReference: string;
+    numberOfColumns: number;
+    numberOfRows: number;
+};
+export type OptionalAppConfig = {
+    gameWidth: number;
+    gameHeight: number;
+    idleTimeout: number;
+    currency: Currency;
+    fontSize: number;
+    fontColor: string;
+    updatableTextValueColor: string;
+    fontFace: string;
+    durationOfActions: {
+        eachColumnsSpinDelay: number[];
+        spinBaseTime: number;
+        timeToSpeedUp: number;
+        timeToSlowDown: number;
+        symbolDropDownTime: number;
+        wiggleTweenDuration: number;
+        balloonFlyUpTime: number;
+        timeToSetResults: number;
+        bigWinDuration: number;
+        minConfettiTime: number;
+        maxConfettiTime: number;
+        randomizeSetInterval: number;
+        randomizeSetDuration: number;
+        freeSpinPlateVisibleTime: number;
+        freeSpinSummaryVisibleTime: number;
+        updatableTextCountingDuration: number;
+        scatterDelayerTime: number;
+        scatterSpinningTime: number;
+        mobileSpinTimeout: number;
+        mysteryWinMinimumTime: number;
+        bigWinMinimumTime: number;
+        bigWinPhaseTimeout: number;
+        speedPopupVisibleTime: number;
+        minAnimationTime: number;
+    };
+    constants: {
+        bigWinMultiplier: number;
+    };
+};
+export type AppConfig = RequiredAppConfig & DeepPartial<OptionalAppConfig>;

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

@@ -0,0 +1,22 @@
+import { InitDataInterface } from "../../connectivity";
+export declare class ApiConfig {
+    readonly token: string;
+    symbolMap: Map<number, unknown>;
+    private rawData;
+    private bets;
+    private winMap;
+    private transformationMap;
+    constructor(data: InitDataInterface);
+    getNextBet(currentBet: number): number;
+    getPreviousBet(currentBet: number): number;
+    getFirstBet(): number;
+    getHighestBet(limit?: number): number;
+    getSymbolId<T>(number: number): T;
+    getWinId<T>(number: number): T;
+    getTransformationById<T>(transformationNumber: number): T;
+    mapSymbolIdsToSymbolNames<T>(symbols_on_reels: number[][]): T[];
+    private getBetAtPosition;
+    private initSymbolMap;
+    private initWinMap;
+    private initTransformationMap;
+}

package/dist/application/ApiConfig/ApiConfig.js

@@ -0,0 +1,93 @@
+import { RainMan } from "../../Rainman";
+import { debug } from "../../utils";
+export class ApiConfig {
+    token;
+    symbolMap = new Map();
+    rawData;
+    bets;
+    winMap = new Map();
+    transformationMap = new Map();
+    constructor(data) {
+        this.rawData = data;
+        if (data.action !== "init") {
+            throw new Error(`Invalid type "${data.action}" provided, "init" expected`);
+        }
+        this.token = data.token;
+        this.bets = data.bets;
+        this.initSymbolMap(data);
+        this.initWinMap(data);
+        this.initTransformationMap(data);
+    }
+    getNextBet(currentBet) {
+        const currentBetPosition = this.bets.indexOf(currentBet);
+        return this.getBetAtPosition(currentBetPosition + 1, currentBetPosition);
+    }
+    getPreviousBet(currentBet) {
+        const currentBetPosition = this.bets.indexOf(currentBet);
+        return this.getBetAtPosition(currentBetPosition - 1, currentBetPosition);
+    }
+    getFirstBet() {
+        return this.getBetAtPosition(0, 0);
+    }
+    getHighestBet(limit = Number.POSITIVE_INFINITY) {
+        const bet = [...this.bets].reverse().find((bet) => bet <= limit);
+        if (bet === undefined)
+            throw new Error("None of the bets match constraint");
+        return bet;
+    }
+    getSymbolId(number) {
+        if (!this.symbolMap.has(number)) {
+            throw new Error(`'${number}' was not found in symbol map`);
+        }
+        return this.symbolMap.get(number);
+    }
+    getWinId(number) {
+        if (!this.winMap.has(number)) {
+            throw new Error(`'${number}' was not found in win map`);
+        }
+        return this.winMap.get(number);
+    }
+    getTransformationById(transformationNumber) {
+        if (!this.transformationMap.has(transformationNumber)) {
+            throw new Error(`'${transformationNumber}' was not found in transformation map`);
+        }
+        return this.transformationMap.get(transformationNumber);
+    }
+    mapSymbolIdsToSymbolNames(symbols_on_reels) {
+        return symbols_on_reels
+            .map((reel) => {
+            return reel.map((symbolId) => this.getSymbolId(symbolId));
+        })
+            .flat();
+    }
+    getBetAtPosition(primaryPosition, fallbackPosition) {
+        if (typeof this.bets[primaryPosition] == "undefined") {
+            return this.bets[fallbackPosition];
+        }
+        return this.bets[primaryPosition];
+    }
+    initSymbolMap(data) {
+        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!`);
+            }
+            this.symbolMap.set(backendId, name);
+        }
+    }
+    initWinMap(data) {
+        for (const key in data.wins_names) {
+            const name = data.wins_names[key];
+            if (!Object.values(RainMan.winTypeIds).includes(name)) {
+                throw new Error(`🛑 "${name}" was not found in WinTypesIds enum!`);
+            }
+            this.winMap.set(Number(key), name);
+        }
+    }
+    initTransformationMap(data) {
+        for (const [key, name] of data.transformations_names.entries()) {
+            const backendId = data.transformations_types[key];
+            this.transformationMap.set(backendId, name);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,3 @@
+export interface TransformationTypesId {
+}
+export type TransformationTypeId = keyof TransformationTypesId;

package/dist/application/ApiConfig/TransformationTypesId.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,3 @@
+export interface WinTypeIds {
+}
+export type WinTypeId = keyof WinTypeIds;

package/dist/application/ApiConfig/WinTypeId.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,3 @@
+export * from "./ApiConfig";
+export * from "./SymbolId";
+export * from "./WinTypeId";

package/dist/application/ApiConfig/index.js

@@ -0,0 +1,3 @@
+export * from "./ApiConfig";
+export * from "./SymbolId";
+export * from "./WinTypeId";

package/dist/application/ButtonsEventManager/ButtonsEventManager.d.ts

@@ -0,0 +1,30 @@
+import { Nullable } from "../../utils";
+export declare const SPEED_PREFIX = "speed-";
+export declare class ButtonsEventManager {
+    private settingsPlusButton;
+    private settingsMinusButton;
+    private settingsSpeedButton;
+    private settingsSpeedTurtle;
+    private settingsSpeedRabbit;
+    private settingsSpeedCheetah;
+    private lastLayerInvoked;
+    speedPopupShownAt: number;
+    private setButtonAvailability;
+    enableButtons: () => void;
+    disableButtons: () => void;
+    initSettingsEvents(): void;
+    setUpUIElementsInteractivity(): void;
+    initBetPlusButtonEvent(setBetCallback: (strategy: "first" | "increase" | "decrease") => void): void;
+    initBetMinusButtonEvent(setBetCallback: (strategy: "first" | "increase" | "decrease") => void): void;
+    initFreeSpinModal(): void;
+    initVolumeButtonEvent(): void;
+    initInfoButtonEvent(): void;
+    initMoreButtonEvent(): void;
+    initAutoplayButtonEvent(): void;
+    initGambleButton(onClick: () => void, disabled: boolean): void;
+    setSpeedPopupVisibility(displayValue: "flex" | "none"): void;
+    setConfirmAutoplayButton(confirmAutoplayButtonCallback: () => void): void;
+    getInvokedSettingItem(): Nullable<HTMLElement>;
+    disableButtonsForAction(actionToWait: () => Promise<void>): Promise<void>;
+    private handleModalInvocation;
+}