@truelab/truengine 0.0.1-0

package/dist/types/src/classes/emitter.class.d.ts

@@ -0,0 +1,64 @@
+import { EEventPriority } from '../extends/enum.types';
+import { TMixedObject } from '../extends/short.types';
+export type IEmitterListener = (params?: TMixedObject) => unknown;
+export type IEmitterEvent = {
+    group: string;
+    listener: IEmitterListener;
+    priority: EEventPriority;
+    isOnce: boolean;
+};
+export type IEmitter = {
+    on(event: string, group: string, listener: IEmitterListener, priority: EEventPriority, isOnce: boolean): IEmitter;
+    once(event: string, group: string, listener: IEmitterListener, priority: EEventPriority): IEmitter;
+    off(event: string, group?: string): IEmitter;
+    clear(group: string): IEmitter;
+    emit(event: string, params?: TMixedObject): Promise<boolean>;
+};
+/**
+ * Эмиттер для DI
+ *
+ * @rules
+ * - события изменения настроек: this.set('balance', 0) -> emit -> on('settings.balance:set')
+ * - события задаются именем "объект:действие"
+ */
+export declare class Emitter implements IEmitter {
+    protected static events: Map<string, IEmitterEvent[]>;
+    /**
+     * Подписываемся на событие
+     *
+     * @param event - listener event
+     * @param group - listener group
+     * @param listener - callback
+     * @param priority - listener priority (auto sort when adding)
+     * @param isOnce - callable at once
+     */
+    on(event: string, group: string, listener: IEmitterListener, priority?: EEventPriority, isOnce?: boolean): Emitter;
+    /**
+     * Добавляет одноразовый слушатель на событие
+     *
+     * @param event - listener event
+     * @param group - listener group
+     * @param listener - callback
+     * @param priority - listener priority (auto sort when adding)
+     */
+    once(event: string, group: string, listener: IEmitterListener, priority?: EEventPriority): Emitter;
+    /**
+     * Глушим слушателей
+     *
+     * @param event - listener event
+     * @param group - listener group
+     */
+    off(event: string, group?: string): Emitter;
+    /** */
+    clear(group: string): Emitter;
+    /**
+     * Выбрасываем событие
+     *
+     * @example this.emit('animate.balance', {value: 1000}) - если не нужно ждать
+     * @example await this.emit('animate.balance', {value: 1500}); this.sounds.play('win') - если нужно дождаться
+     * @param event - listener event
+     * @param params - listener call payload
+     * @withoutcontext
+     */
+    emit(event: string, params?: TMixedObject): Promise<boolean>;
+}

package/dist/types/src/classes/engine.class.d.ts

@@ -0,0 +1,75 @@
+import { IPixiEngine } from '../extends/interfaces';
+import { TEngineSettings } from '../extends/struct.types';
+import { FocusServise } from '../services/focus.services';
+import { SkipService } from '../services/skip.service';
+import { SoundsService } from '../services/sounds/sounds.service';
+import { StorageService } from '../services/storage.service';
+import { Assets } from './assets.class';
+import { DI } from './di.class';
+import { Producer } from './producer.class';
+import * as PIXI from 'pixi.js';
+/**
+ * mousedown - кнопка мыши нажата
+ * mouseup - отпущена
+ * pointerover - курсор заходит на канвас + первое движение
+ * pointerout - курсор выходит за пределы канваса
+ * pointermove - курсор перемещается по канвасу
+ */
+export declare enum EEngineAllowEvents {
+    mouseDown = "mousedown",
+    mouseUp = "mouseup",
+    pointerUp = "pointerup",
+    pointerDown = "pointerdown",
+    pointerOver = "pointerover",
+    pointerOut = "pointerout",
+    pointerMove = "pointermove"
+}
+/**
+ * Движок для геймплея всех игр (pixi)
+ * @tasks
+ * - обработчики событий
+ * - инициатор событий
+ * - управление общением с сервером
+ */
+export declare class Engine extends DI implements IPixiEngine {
+    producer: Producer;
+    assets: Assets;
+    name: string;
+    sounds: () => SoundsService;
+    storage: () => StorageService;
+    focus: () => FocusServise;
+    skip: () => SkipService;
+    readonly canvas: HTMLElement;
+    readonly preload: Promise<boolean>[];
+    readonly driver: PIXI.Application;
+    protected _tickerInterval: number;
+    protected _processing: boolean;
+    protected _pressedKeys: Map<number, boolean>;
+    /**
+     * @constructor
+     * @param {jQuery} canvas
+     * @param {String} appName
+     */
+    constructor(canvas?: HTMLElement, appName?: string, settings?: TEngineSettings, stage?: PIXI.Container);
+    /**
+     * Старт приложения
+     */
+    start(): PIXI.Application;
+    /**
+     * Остановка приложения
+     */
+    stop(): PIXI.Application;
+    /**
+     * Регистрация событий
+     * @param events
+     */
+    registerRendererEvents(events: EEngineAllowEvents[]): Engine;
+    /**
+     * Регистрация событий нажатия клавиш
+     */
+    registerKeyboardEvents(): Engine;
+    /** Обработка нажатия кнопок */
+    protected _emitKeyDown(keyCode: number): Promise<boolean>;
+    /** Обработка отжатия кнопок */
+    protected _emitKeyUp(keyCode: number): Promise<boolean>;
+}

package/dist/types/src/classes/loaders.class.d.ts

@@ -0,0 +1,28 @@
+import { Sound } from '@pixi/sound';
+import { Emitter } from './emitter.class';
+import * as PIXI from 'pixi.js';
+export type ILoaderResource = {
+    sound: Sound;
+    url: string;
+} & PIXI.LoaderResource;
+/**
+ * Загрузчик ресурсов
+ */
+export declare class Loaders extends Emitter {
+    readonly PIXI_RESOURCES = "pixi.loader";
+    readonly WEBFONT_RESOURCES = "webfont.loader";
+    static resources: Map<string, ILoaderResource>;
+    protected _baseUrl: string;
+    protected _concurrency: number;
+    protected _bindToGPU: string[];
+    protected _queue: Map<string, Set<string>>;
+    /**
+     * Загрузить файловые ресурсы
+     * @param tag ?
+     */
+    protected _pixiLoader(tag?: string): Promise<boolean>;
+    /**
+     * Загрузить веб шрифты (через webfontloader)
+     */
+    protected _webfontLoader(): Promise<boolean>;
+}

package/dist/types/src/classes/preloader.class.d.ts

@@ -0,0 +1,15 @@
+import { Emitter } from './emitter.class';
+/** Preloader class */
+export declare class Preloader extends Emitter {
+    name: string;
+    protected _game: HTMLElement;
+    protected _loader: HTMLElement;
+    protected _filler: HTMLElement;
+    protected _tag: string;
+    /** @constructor */
+    constructor(game: HTMLElement, loader: HTMLElement, filler: HTMLElement, tag: string);
+    /** on loading start */
+    start(): void;
+    /** on loading end */
+    end(): void;
+}

package/dist/types/src/classes/producer.class.d.ts

@@ -0,0 +1,135 @@
+import { IComponent, IComponentHTML, IContainer, IScene } from '../extends/interfaces';
+import { TComponents } from '../extends/short.types';
+import { DI } from './di.class';
+import { IEmitter } from './emitter.class';
+export type IProducer = {
+    instance: IContainer;
+    currentScene: string;
+    init(): IProducer;
+    start(): Promise<boolean>;
+    startScene(name: string): Promise<IScene>;
+    scene<SceneGeneric extends IScene>(name?: string, scene?: IScene): SceneGeneric;
+    panel<PanelGeneric extends TComponents>(name: string, panel?: TComponents): PanelGeneric;
+    component<ComponentGeneric extends TComponents>(name: string, component?: TComponents): ComponentGeneric;
+    create(name: string): Promise<boolean>;
+    show(name: string, redraw?: boolean): Promise<boolean>;
+    destroy(sceneName: string): Promise<void>;
+} & IEmitter;
+/**
+ * Режиссер сцен и механики
+ *
+ * Панели обязательно должны быть IComponent.
+ * Компоненты обязательно должны быть IComponent или IComponentHTML.
+ *
+ * Панели создаются в корневом контейнере продюсера и никогда не уничтожаются.
+ * Компоненты создаются рядом с корневым контейнером продюсера (если это не HTML компоненты) и никогда не уничтожаются.
+ * Сцены создаются в корневом контейнере по запросу, могут уничтожаться и создаваться снова.
+ *
+ * @tasks
+ * - коллекция сцен
+ * - управление переходами между сценами
+ * - управление вызовом механики (процессинг сцены)
+ * - управление звуками
+ * - управление отрисовкой адаптивки
+ *
+ * @example
+ * gameplay constructor: (this.producer)
+ *      super()
+ *      this.producer.scene('regular', new SceneRegular()) // this.registry.get('scene:regular')
+ *      this.producer.scene('freespins, new SceneFreespins())
+ * gameplay:
+ *      await this.producer.start('regular') // on preload
+ * response:
+ *      await this.producer.action(response)
+ */
+export declare class Producer extends DI implements IProducer {
+    /**
+     * Сцены
+     */
+    protected _scenes: Map<string, IScene>;
+    /**
+     * Панели
+     */
+    protected _panels: Map<string, IComponent>;
+    /**
+     * Компоненты
+     */
+    protected _components: Map<string, IComponentHTML | IComponent>;
+    /**
+     * Таймер на ресайз окна
+     */
+    protected _resizeTimeout: number;
+    /**
+     * Корневой контейнер продюсера.
+     * Регистрируется на верхнем уровне в stage канваса
+     */
+    instance: IContainer;
+    /**
+     * Запущен ли продюсер
+     */
+    started: boolean;
+    /**
+     * Текущая сцена
+     */
+    currentScene: string;
+    /**
+     * Инициалиация продюсера.
+     * - вешает событие ресайза.
+     * - добавляет дефолтные компоненты
+     */
+    init(): this;
+    /**
+     * Создает зарегистрированные компоненты по ключу
+     */
+    createComponent(key: string): Promise<this>;
+    /**
+     * Создает зарегистрированные компоненты и панели
+     */
+    start(): Promise<boolean>;
+    /**
+     * Пересчитать состояние borderView и вызвать методы адаптивности у панелей
+     */
+    protected redraw(): Promise<Producer>;
+    /**
+     * Регистрация панели в продюсере (либо ее получение)
+     * @param name
+     * @param panel
+     */
+    panel<PanelGeneric extends TComponents>(name: string, panel?: IComponent): PanelGeneric;
+    /**
+     * Регистрация компонента в продюсере (либо его получение)
+     * @param name
+     * @param component
+     */
+    component<ComponentGeneric extends TComponents>(name: string, component?: TComponents): ComponentGeneric;
+    /**
+     * Регистрация сцены в продюсере (либо ее получение)
+     * @param name
+     * @param scene
+     */
+    scene<SceneGeneric extends IScene>(name?: string, scene?: IScene): SceneGeneric;
+    /**
+     * Создание и отображение сцены.
+     * Если эта сцена уже отображается, ничего не происходит.
+     * Если есть currentScene, то она дестроится.
+     * @param sceneName
+     */
+    startScene(sceneName: string): Promise<IScene>;
+    /**
+     * Создание сцены
+     * @param sceneName
+     */
+    create(sceneName: string): Promise<boolean>;
+    /**
+     * Отображение сцены.
+     * Может перерисовать все сцены, панели, компоненты
+     * @param sceneName
+     * @param redrawAll
+     */
+    show(sceneName: string, redrawAll?: boolean): Promise<boolean>;
+    /**
+     * Уничтожение сцены
+     * @param sceneName
+     */
+    destroy(sceneName: string): Promise<void>;
+}

package/dist/types/src/classes/sequence.class.d.ts

@@ -0,0 +1,30 @@
+import { TPixiAnimations, TPixiTextures } from '../extends/short.types';
+import * as PIXI from 'pixi.js';
+/** */
+export declare class Sequence extends PIXI.AnimatedSprite {
+    /** */
+    get size(): number;
+    /**
+     * @constructor
+     */
+    constructor(name: string, textures: TPixiTextures | TPixiAnimations);
+    /** */
+    play(delay?: number, reset?: boolean): Promise<void>;
+    /** */
+    playto(to: number, from?: number, delay?: number): Promise<void>;
+    /**
+     * await animation.speed(0.7).playto(10, 3)
+     * await animation.speed(1.4)
+     */
+    speed(speed: number): this;
+    /**
+     * protected seq = new Sequence('example', Assets.getSpritesheet)
+     * [point, point, point].forEach(point => {
+     *      const symbol = seq.clone('example' + i)
+     *      container.addChild(symbol)
+     *      symbol.position = point
+     *      symbol.play(i * 20)
+     * })
+     */
+    clone(name?: string): Sequence;
+}

package/dist/types/src/classes/skipable.class.d.ts

@@ -0,0 +1,15 @@
+export type TCallbackFast = (enabled: boolean) => void;
+export type TCallbackSkip = () => void;
+/** */
+export declare class Skipable {
+    protected _fast: boolean;
+    protected _callbacksFast: Set<TCallbackFast>;
+    protected _callbacksSkip: Set<TCallbackSkip>;
+    /** */
+    fast(enabled: boolean): void;
+    /** */
+    skip(): void;
+    /** */
+    wait(callbackPromise: () => Promise<unknown>, callbackFast: TCallbackFast, callbackSkip: TCallbackSkip): Promise<void>;
+}
+export declare const skipable: Skipable;

package/dist/types/src/classes/spine.assets.class.d.ts

@@ -0,0 +1,42 @@
+import { Spine as PixiSpine, TrackEntry } from '@pixi-spine/runtime-4.1';
+import { Assets } from '../classes/assets.class';
+/** */
+export declare class Spine extends PixiSpine {
+    trackSingles: number;
+    trackLoops: number;
+    loopAnimationName: string;
+    mixDuration: number;
+    /** */
+    clone(name: string): Spine;
+    /** */
+    show(): this;
+    /** */
+    hide(): this;
+    /** */
+    animate(name: string, loop?: boolean, autoStartLoop?: boolean, timeScale?: number): Promise<TrackEntry>;
+    /** */
+    getAnimationName(trackIndex?: number): string;
+    /** */
+    isAnimationPlaying(name: string, track?: number): boolean;
+    /** */
+    getDurationMs(name: string): number;
+    /**
+     * Stop spine on the first frame of animation
+     * @param name
+     */
+    toFirstFrame(name: string): void;
+    /**
+     * Stop spine on the last frame of animation
+     * @param name
+     */
+    toLastFrame(name: string): void;
+    /** */
+    timeScale(timeScale: number, track?: number): void;
+    /** */
+    skip(track?: number): void;
+}
+/** */
+export declare class SpineAssets extends Assets {
+    /** */
+    static getSpineAnimation(assetName: string, skeletonScale?: number): Spine;
+}

package/dist/types/src/classes/tile.class.d.ts

@@ -0,0 +1,38 @@
+import * as PIXI from 'pixi.js';
+/**
+ * Класс для создания одной текстуры из нескольких
+ *
+ * ```js
+ * const tile = new Tile()
+ * tile
+ *      .addTexture(Assets.getTexture('test', 'test1.png'))
+ *      .addTexture(Assets.getTexture('test', 'test2.png'), 100, 200)
+ *      .generateTexture()
+ * ```
+ */
+export declare class Tile extends PIXI.Sprite {
+    protected _container: PIXI.Container;
+    /**
+     * @constructor
+     */
+    constructor(name?: string);
+    /**
+     * Сгенерировать текстуру из раннее добавленных текстур и применить ее на данный спрайт
+     */
+    generateTexture(): this;
+    /**
+     * Добавить текстуру в указанную точку
+     * @param texture
+     * @param x
+     * @param y
+     */
+    addTexture(texture: PIXI.Texture, x: number, y: number): this;
+    /**
+     * Расположит текстуры в линию друг за другом
+     * @param textures текстуры и по сколько раз каждую текстуру повторять
+     * @param vertical вертикально или горизонтально
+     * @param x точка начала
+     * @param y точка начала
+     */
+    arrangeInLine(textures: [number, PIXI.Texture][], vertical?: boolean, x?: number, y?: number): this;
+}

package/dist/types/src/components/abstract.component.d.ts

@@ -0,0 +1,52 @@
+import { Emitter } from '../classes/emitter.class';
+import { IComponent, IContainer, INamed } from '../extends/interfaces';
+import { TSupportContainer } from '../extends/short.types';
+import * as PIXI from 'pixi.js';
+/**
+ * Абстрактный компонент
+ *
+ * @rules
+ * - должен отрисовывать свое состояние только по своим внутренним свойствам
+ * - должен только выкидывать события, не реализуя их обработку
+ */
+export declare abstract class AbstractComponent extends Emitter implements INamed, IComponent {
+    name: string;
+    instance: IContainer;
+    width: number;
+    height: number;
+    alpha: number;
+    visible: boolean;
+    position: PIXI.IPoint;
+    x: number;
+    y: number;
+    rotation: number;
+    scale: PIXI.IPoint;
+    scaleX: number;
+    scaleY: number;
+    created: boolean;
+    destroyed: boolean;
+    disabled?: boolean;
+    show: () => Promise<void>;
+    hide: () => Promise<void>;
+    /**
+     * @constructor
+     * @param name
+     */
+    constructor(name?: string);
+    /**
+     * Создать компонент
+     * @param instance
+     */
+    create(instance?: TSupportContainer): Promise<this>;
+    /**
+     * Уничтожить компонент
+     */
+    destroy(): Promise<this>;
+    /**
+     * Отрисовать компонент
+     *
+     * @rules
+     * - не создавать никаких переменных в draw
+     */
+    abstract draw(modeChanged?: boolean): Promise<this>;
+}

package/dist/types/src/components/abstract.html.component.d.ts

@@ -0,0 +1,43 @@
+import { Emitter } from '../classes/emitter.class';
+import { IComponentHTML, INamed } from '../extends/interfaces';
+import { TCallbackVoid } from '../extends/short.types';
+/** */
+export declare abstract class AbstractHtmlComponent extends Emitter implements INamed, IComponentHTML {
+    name: string;
+    instance: any;
+    element: HTMLElement;
+    created: boolean;
+    protected _createdDynamically: boolean;
+    /**
+     * @constructor
+     * @param name
+     */
+    constructor(name?: string);
+    /**
+     * Добавить свойство компоненту с колбеками на запись.
+     * @param name
+     * @param def
+     * @param onTrue
+     * @param onFalse
+     */
+    addProperty(name: string, def: unknown, onTrue: TCallbackVoid, onFalse?: TCallbackVoid): void;
+    /**
+     * Создать компонент
+     * @param element
+     */
+    create(element?: HTMLElement): Promise<this>;
+    /**
+     * Уничтожить компонент
+     */
+    destroy(): Promise<this>;
+    /** Отрисовать компонент */
+    draw(_isModeChanged?: boolean): Promise<this>;
+    /**
+     * Показать компонент
+     */
+    show(): Promise<void>;
+    /**
+     * Скрыть компонент
+     */
+    hide(): Promise<void>;
+}

package/dist/types/src/components/bigwin.component.d.ts

@@ -0,0 +1,109 @@
+import { Container } from '../classes/container.class';
+import { IComponent } from '../extends/interfaces';
+import { TGsapTimeline, TNumberArray, TPixiTextStyle, TSupportContainer } from '../extends/short.types';
+import { AbstractComponent } from './abstract.component';
+import { BlackoutComponent } from './blackout.component';
+import { TextComponent } from './text.component';
+export declare enum EBigWinLabels {
+    big = "big",
+    bigLoop = "bigLoop",
+    super = "super",
+    superLoop = "superLoop",
+    epic = "epic",
+    epicLoop = "epicLoop",
+    complete = "complete",
+    end = "end"
+}
+/** Component to build and control Big Win animation */
+export declare class BigWinComponent extends AbstractComponent {
+    protected _components: IComponent[];
+    protected _hasLabel: boolean;
+    protected _isDebug: boolean;
+    protected _timeline: TGsapTimeline;
+    protected _counterTl: TGsapTimeline;
+    protected _easeCounter: string;
+    protected _coins: number;
+    protected _coinsFinal: number;
+    protected _blackoutComponent: BlackoutComponent;
+    protected _bigWinContainer: Container;
+    protected _promises: Promise<unknown>[];
+    protected _volatilityLevels: {
+        low: number[];
+        medium: number[];
+        high: number[];
+        veryHigh: number[];
+    };
+    protected _volatilityOdds: TNumberArray;
+    protected _winLevels: {
+        big: number;
+        super: number;
+        epic: number;
+    };
+    protected _coinsTextComponent: TextComponent;
+    protected _coinsTextStyle: TPixiTextStyle;
+    protected _currencyTextComponent: TextComponent;
+    protected _currencyTextStyle: TPixiTextStyle;
+    protected _labelTextComponent: TextComponent;
+    protected _durations: {
+        [key in EBigWinLabels]: number;
+    };
+    protected _blackoutParams: {
+        color: number;
+        alpha: number;
+        duration: number;
+    };
+    /** @constructor */
+    constructor(name?: string);
+    /** Returns current coins */
+    get coins(): number;
+    /** Puts coins to the labels */
+    set coins(value: number);
+    /** Shows debug log */
+    protected _debug(log: string): void;
+    /** Checks enough amount of coins for big win */
+    isBigWin(coins?: number): boolean;
+    /** Checks enough amount of coins for super win */
+    isSuperWin(coins?: number): boolean;
+    /** Checks enough amount of coins for epic win  */
+    isEpicWin(coins?: number): boolean;
+    /** @inheritdoc */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** Creates and add container for big win */
+    protected _addBigWinContainer(): void;
+    /** Adds blackout component */
+    protected _addBlackout(): Promise<void>;
+    /** Adds "Biw win" title */
+    protected _addTitle(): Promise<void>;
+    /** Add coins label */
+    protected _addCoinsLabel(): Promise<void>;
+    /** Add currency text component */
+    protected _addCurrencyLabel(): Promise<void>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** @inheritdoc */
+    draw(): Promise<this>;
+    /** Start Big Win animation */
+    animate(coins: number): Promise<void>;
+    /** Creates animations timeline with labels */
+    protected _createTimeline(): void;
+    /** Makes win counter animation */
+    protected _animateCounter(coinsFrom: number, consTo: number, duration: number, delay?: number): TGsapTimeline;
+    /** Starts Big Win callback */
+    protected _big(): Promise<void>;
+    /** Starts Big Win Loop callback */
+    protected _bigLoop(): Promise<void>;
+    /** Starts Super Win callback */
+    protected _super(): Promise<void>;
+    /** Starts Super Win Loop callback */
+    protected _superLoop(): Promise<void>;
+    /** Starts Epic Win callback */
+    protected _epic(): Promise<void>;
+    /** Starts Epic Win Loop callback */
+    protected _epicLoop(): Promise<void>;
+    /** Starts Big Win Complete callback */
+    protected _complete(): Promise<void>;
+    /** Starts Big Win End callback */
+    protected _end(): Promise<void>;
+    /** Jumps timeline to nex available label */
+    skip(): void;
+}