@truelab/truengine 0.0.1-0

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

@@ -0,0 +1,32 @@
+import { TGsapTimeline, TSupportContainer } from '../extends/short.types';
+import { AbstractComponent } from './abstract.component';
+import * as PIXI from 'pixi.js';
+/** */
+export declare class BlackoutComponent extends AbstractComponent {
+    protected _background: PIXI.Sprite;
+    protected _inBackground: PIXI.Sprite;
+    protected _renderer: PIXI.Renderer | PIXI.AbstractRenderer;
+    protected _texture: PIXI.RenderTexture;
+    protected _textureColor: number;
+    protected _textureAlpha: number;
+    protected _crossfadeTl: TGsapTimeline;
+    /** */
+    constructor(name: string, renderer: PIXI.Renderer | PIXI.AbstractRenderer);
+    /**
+     * Создать компонент
+     * @param instance
+     */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** */
+    destroy(): Promise<this>;
+    /** Generate texture for blackout */
+    protected _generateTexture(color?: number, alpha?: number): PIXI.RenderTexture;
+    /** */
+    turnOn(color?: number, alpha?: number, duration?: number): Promise<void>;
+    /** Changes color if blackout is on */
+    turnTo(color?: number, alpha?: number, duration?: number): Promise<void>;
+    /** */
+    turnOff(duration?: number): Promise<void>;
+    /** */
+    draw(): Promise<this>;
+}

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

@@ -0,0 +1,113 @@
+import { TGenericObject, TPixiSprite, TPixiTexture, TSupportContainer } from '../extends/short.types';
+import { AbstractComponent } from './abstract.component';
+import * as PIXI from 'pixi.js';
+/**
+ * Текстуры кнопки
+ */
+export declare class ButtonTextures {
+    origin: TPixiTexture;
+    hover: TPixiTexture;
+    click: TPixiTexture;
+    disable: TPixiTexture;
+    /**
+     * @constructor
+     */
+    constructor(origin: TPixiTexture, hover: TPixiTexture, click: TPixiTexture, disable?: TPixiTexture);
+}
+/**
+ * Компонент кнопки.
+ * Имеет 4 текстуры в зависимости от состояния - оригинальная, ховер, клик, не активная.
+ * Также возможно переключение между двумя режимами (наподобии on/off).
+ *
+ * @example
+ * # для расширения стандартной механики
+ * class RollButton extends ButtonComponent
+ *
+ * @example
+ * this.rollButton = new ButtonComponent('roll', new ButtonTextures(
+ *      btn.sprite.origin,
+ *      btn.sprite.hover, ...)
+ * )
+ * this.rollButton.position.set(x,y)
+ * // in scene | producer | gameplay
+ * this.on('roll:click', async handler => await return)
+ */
+export declare class ButtonComponent extends AbstractComponent {
+    protected _textures: TGenericObject<ButtonTextures>;
+    protected _autoModes: boolean;
+    protected _modeOn: boolean;
+    protected _stateHovered: boolean;
+    protected _stateClicked: boolean;
+    protected _button: TPixiSprite;
+    debug: boolean;
+    emitHovers: boolean;
+    soundClick: string;
+    soundClickOff: string;
+    /**
+     *
+     * @constructor
+     * @param name
+     * @param modeOn
+     * @param modeOff
+     * @param autoModes
+     * @event 'click.[new.button]'
+     * @event 'hover.[new.button]'
+     */
+    constructor(name: string, modeOn: ButtonTextures, modeOff?: ButtonTextures, autoModes?: boolean);
+    /**
+     * Создать компонент
+     * @param instance
+     */
+    create(instance?: TSupportContainer): Promise<this>;
+    /**
+     * Уничтожить компонент
+     */
+    destroy(): Promise<this>;
+    /** Отрисовать компонент */
+    draw(_modeChanged?: boolean): Promise<this>;
+    /**
+     * Установить текстуру на кнопку в зависимости от ее текущего состояния
+     */
+    setTexture(): this;
+    /**
+     * Переключает режим (только если есть текстуры для второго режима)
+     * Сразу же меняет текстуру кнопки на актуальную
+     * @param on
+     */
+    toggleMode(on?: boolean): this;
+    /**
+     * Имитировать клик на кнопку
+     */
+    click(): this;
+    /** Заменяет текстуры кнопки */
+    changeTextures(modeOn: ButtonTextures, modeOff?: ButtonTextures): this;
+    /** */
+    protected _initEvents(): void;
+    /** */
+    protected _offEvents(): void;
+    /**
+     * Событие навёл курсор
+     * @param e
+     */
+    protected _onPointerOver(e?: PIXI.InteractionEvent): void;
+    /**
+     * Событие нажал на кнопке
+     * @param e
+     */
+    protected _onPointerDown(e?: PIXI.InteractionEvent): void;
+    /**
+     * Событие отпустил курсор на кнопке
+     * @param e
+     */
+    protected _onPointerUp(): void;
+    /**
+     * Событие отвёл нажатый курсор
+     * @param e
+     */
+    protected _onPointerUpOutSide(e?: PIXI.InteractionEvent): void;
+    /**
+     * Событие убрал курсор
+     * @param e
+     */
+    protected _onPointerOut(e?: PIXI.InteractionEvent): void;
+}

package/dist/types/src/components/button.faded.component.d.ts

@@ -0,0 +1,29 @@
+import { TGsapTween, TPixiSprite, TSupportContainer } from '../extends/short.types';
+import { ButtonComponent } from './button.component';
+import * as PIXI from 'pixi.js';
+/** Компонент анимированной кнопки */
+export declare class ButtonFadedComponent extends ButtonComponent {
+    protected _faded: TPixiSprite;
+    protected _tweenFade: TGsapTween;
+    protected _stateFaded: boolean;
+    protected _eventType: string;
+    /** in seconds */
+    duration: number;
+    /** @inheritdoc */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /**
+     * Установить текстуру на кнопку в зависимости от ее текущего состояния
+     * @param duration длительность анимации в секундах
+     */
+    setTexture(duration?: number): this;
+    /** */
+    animateFadeToggle(on: boolean, texture: PIXI.Texture, duration?: number): Promise<void>;
+    /** */
+    animateModeToggle(renderable: boolean, state: boolean, texture: PIXI.Texture): Promise<void>;
+    /** */
+    protected _initEvents(): void;
+    /** */
+    protected _offEvents(): void;
+}

package/dist/types/src/components/button.text.component.d.ts

@@ -0,0 +1,49 @@
+import { TSupportContainer } from '../extends/short.types';
+import { ButtonTextures } from './button.component';
+import { ButtonFadedComponent } from './button.faded.component';
+import { TextComponent } from './text.component';
+import * as PIXI from 'pixi.js';
+declare enum EButtonState {
+    origin = "origin",
+    hover = "hover",
+    click = "click",
+    disable = "disable"
+}
+type TChangeStyles = {
+    color: string;
+    shadowColor: string;
+};
+export type TButtonStateStyles = {
+    [EButtonState.origin]: TChangeStyles;
+    [EButtonState.hover]: TChangeStyles;
+    [EButtonState.click]: TChangeStyles;
+    [EButtonState.disable]: TChangeStyles;
+};
+type TButtonTextComponentOptions = {
+    upscale?: boolean;
+};
+/** Компонент анимированной кнопки с текстом */
+export declare class ButtonTextComponent extends ButtonFadedComponent {
+    buttonText: TextComponent;
+    buttonTextStyle: PIXI.TextStyle;
+    buttonStyles: TButtonStateStyles;
+    autoScale: {
+        enabled: boolean;
+        scale: number;
+    };
+    protected _initialText: string;
+    protected _isUpscaleMode: boolean;
+    /** @inheritdoc */
+    constructor(name: string, text: string, modeOn: ButtonTextures, modeOff?: ButtonTextures, autoModes?: boolean, styles?: TButtonStateStyles, options?: TButtonTextComponentOptions);
+    /** @inheritdoc */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** Получить состояние кнопки */
+    getButtonState(): EButtonState;
+    /** Установить текстуру на кнопку в зависимости от ее текущего состояния */
+    setTexture(): this;
+    /** */
+    draw(): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+}
+export {};

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

@@ -0,0 +1,63 @@
+import { Controller, GUI } from 'lil-gui';
+import { TGenericObject } from '../extends/short.types';
+import { AbstractHtmlComponent } from './abstract.html.component';
+export type TCheatSection = {
+    name: string;
+    value: string;
+    values?: string[];
+};
+export type TCheat = TGenericObject<TCheatSection>;
+export type TCustomValue = number | string | boolean;
+export type TCustomCheatParams = {
+    name: string;
+    value: TCustomValue;
+    group?: string;
+};
+/**
+ * Добавляет читинг тул
+ */
+export declare class CheatComponent extends AbstractHtmlComponent {
+    protected _cheat: TCheat;
+    protected _cheatOriginal: string;
+    protected _panel: GUI;
+    protected _cheatFolder: GUI;
+    protected _controllers: TGenericObject<Controller>;
+    customPresets: string[];
+    protected _custom: TGenericObject<TCustomValue>;
+    protected _customFolder: GUI;
+    protected _customGroupDelimiter: string;
+    protected _customGroups: Map<string, GUI>;
+    protected _customPresetNumber: Controller;
+    protected _customPresetValue: Controller;
+    protected _customPresetCopy: Controller;
+    protected _customPresetPaste: Controller;
+    protected _customControllers: Map<string, Controller>;
+    onChange: () => void;
+    /**
+     * Если нужно сделать тонкую настройку какого-то кастомного чита (step, min/max, выпадающий список и тд)
+     *
+     * @example
+     * cheatComponent.customControllers.get('Slot_motion').min(10).max(150).step(1)
+     * cheatComponent.customControllers.get('Slot_intrigue.jingle').options(['intrigue.mp3', 'intrigue_final (03).mp3'])
+     */
+    get customControllers(): Map<string, Controller>;
+    /** */
+    draw(): Promise<this>;
+    /** */
+    setCheat(cheat: TCheat): Promise<this>;
+    /** */
+    getCheat(): string;
+    /**
+     * добавить чит тайминга в панель
+     * функция вызывается через слушатель в любом компоненте
+     * добавить чит - this.emit('cheat.custom:add', { name, value, group })
+     * подписаться на изменение с панели - this.on('cheat.custom:changed', this.name, ({ name, value }) => value )
+     */
+    setCustomCheat(name: string, value: TCustomValue, group?: string): void;
+    /** обновить сгенерированный строковый пресет в поле ввода */
+    protected _updatePreset(): void;
+    /** создать подпапку с читами таймингов */
+    protected _createCustomFolder(): void;
+    /** */
+    protected _updateCustomValues(preset: string): void;
+}

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

@@ -0,0 +1,37 @@
+import { Sprite, Texture } from 'pixi.js';
+import { TSupportContainer } from '../extends/short.types';
+import { AbstractComponent } from './abstract.component';
+export type TFillFrameConfig = {
+    enabled: boolean;
+    color: string;
+    gradientLength?: number;
+    landscape?: {
+        width: number;
+        height: number;
+    };
+    portrait?: {
+        width: number;
+        height: number;
+    };
+};
+export declare class FillFrameComponent extends AbstractComponent {
+    protected config: TFillFrameConfig;
+    protected gradientTexture: Texture;
+    protected fillingTexture: Texture;
+    protected topFilling: Sprite;
+    protected bottomFilling: Sprite;
+    protected leftFilling: Sprite;
+    protected rightFilling: Sprite;
+    protected topGradient: Sprite;
+    protected bottomGradient: Sprite;
+    protected leftGradient: Sprite;
+    protected rightGradient: Sprite;
+    protected enabled: boolean;
+    constructor(config: TFillFrameConfig);
+    enable(): Promise<this>;
+    disable(): Promise<this>;
+    protected getGradientTexture(): Texture;
+    protected getFillingTexture(): Texture;
+    create(instance?: TSupportContainer): Promise<this>;
+    draw(): Promise<this>;
+}

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

@@ -0,0 +1,39 @@
+import { TInterval, TPixiTextStyle, TSupportContainer } from '../extends/short.types';
+import { AbstractComponent } from './abstract.component';
+import { TextComponent } from './text.component';
+import * as PIXI from 'pixi.js';
+type TConfig = {
+    textStyle: TPixiTextStyle;
+    updateIntervalMS: number;
+    width: number;
+    height: number;
+    margin: number;
+};
+/**
+ * On: emit('fps:show', { value: true })
+ * Off: emit('fps:show', { value: false })
+ * debug mode is required.
+ */
+export declare class FPSComponent extends AbstractComponent {
+    protected _config: TConfig;
+    protected _isDebug: boolean;
+    protected _updateInterval: TInterval;
+    protected _ticker: PIXI.Ticker;
+    protected _rect: PIXI.Graphics;
+    protected _text: TextComponent;
+    /** */
+    constructor(name?: string);
+    /** */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** */
+    start(): void;
+    /** */
+    stop(): void;
+    /**
+     * Уничтожить компонент
+     */
+    destroy(): Promise<this>;
+    /** Отрисовать компонент */
+    draw(): Promise<this>;
+}
+export {};

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

@@ -0,0 +1,28 @@
+import { AbstractComponent } from './abstract.component';
+import * as PIXI from 'pixi.js';
+/**
+ * Рисует сетку поверх сцены.
+ * Компонент работает только в режиме setMode('grid')
+ */
+export declare class GridComponent extends AbstractComponent {
+    protected _sections: number;
+    protected _grid: PIXI.Graphics;
+    /**
+     * @constructor
+     * @param name
+     */
+    constructor(name?: string);
+    /**
+     * Создать компонент
+     * @param instance
+     */
+    create(): Promise<this>;
+    /**
+     * Уничтожить компонент
+     */
+    destroy(): Promise<this>;
+    /**
+     * Рисует чернобелую сетку
+     */
+    draw(): Promise<this>;
+}

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

@@ -0,0 +1,78 @@
+import { TSupportContainer } from '../extends/short.types';
+import { AbstractComponent } from './abstract.component';
+import { TextComponent } from './text.component';
+import * as PIXI from 'pixi.js';
+export declare enum ELinkState {
+    origin = "origin",
+    hover = "hover",
+    click = "click",
+    disable = "disable"
+}
+type TChangeStyles = {
+    color: string;
+};
+export type TLinkStateStyles = {
+    [ELinkState.origin]: TChangeStyles;
+    [ELinkState.hover]: TChangeStyles;
+    [ELinkState.click]: TChangeStyles;
+    [ELinkState.disable]: TChangeStyles;
+};
+/**
+ * Компонент кнопки "текст-ссылка"
+ */
+export declare class LinkComponent extends AbstractComponent {
+    protected _stateHovered: boolean;
+    protected _stateClicked: boolean;
+    protected _text: TextComponent;
+    protected _initialText: string;
+    textStyle: PIXI.TextStyle;
+    textStyles: TLinkStateStyles;
+    emitHovers: boolean;
+    soundClick: string;
+    /**
+     * @constructor
+     */
+    constructor(name: string, text: string, styles?: TLinkStateStyles);
+    /**
+     * Создать компонент
+     * @param instance
+     */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** Уничтожить компонент */
+    destroy(): Promise<this>;
+    /** Отрисовать компонент */
+    draw(_modeChanged?: boolean): Promise<this>;
+    /** Получить состояние ссылки */
+    getButtonState(): ELinkState;
+    /** Установить стиль текста в зависимости от её текущего состояния */
+    setTextColor(): this;
+    /** Имитировать клик на ссылку */
+    click(): this;
+    /** */
+    protected _initEvents(): void;
+    /** */
+    protected _offEvents(): void;
+    /**
+     * Событие наведения курсора
+     * @param e
+     */
+    protected _onPointerOver(e?: PIXI.InteractionEvent): void;
+    /**
+     * Событие нажатия на ссылке
+     * @param e
+     */
+    protected _onPointerDown(e?: PIXI.InteractionEvent): void;
+    /** Событие отпустил курсор на ссылке */
+    protected _onPointerUp(): void;
+    /**
+     * Событие отвёл нажатый курсор
+     * @param e
+     */
+    protected _onPointerUpOutSide(e?: PIXI.InteractionEvent): void;
+    /**
+     * Событие убрал курсор
+     * @param e
+     */
+    protected _onPointerOut(e?: PIXI.InteractionEvent): void;
+}
+export {};

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

@@ -0,0 +1,30 @@
+import { Emitter, EmitterConfigV3 } from '@pixi/particle-emitter';
+import { TGsapTimeline } from '../extends/short.types';
+import { AbstractComponent } from './abstract.component';
+/**
+ * #todo
+ * - pause/resume
+ * - stop() слишком резкий. Нужна возможность выключить плавно, чтобы частицы просто закончили свои анимации (задержка на lifetime.max)
+ */
+/** Implements base particles behavior */
+export declare class ParticlesComponent extends AbstractComponent {
+    protected _emitter: Emitter;
+    protected _emitterConfig: EmitterConfigV3;
+    protected _elapsed: number;
+    protected _particlesTL: TGsapTimeline;
+    protected _fps: number;
+    /** returns current amount of particles */
+    get maxParticles(): number;
+    /** sets current amount of particle */
+    set maxParticles(value: number);
+    /** @inheritdoc */
+    draw(): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** Starts particles animation */
+    start(): void;
+    /** Stops particle animation */
+    stop(): void;
+    /** Updates ticker callback */
+    protected _updateParticles(): void;
+}

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

@@ -0,0 +1,42 @@
+import { TGsapTween, TPixiSprite, TSupportContainer } from '../extends/short.types';
+import { AbstractComponent } from './abstract.component';
+export type TConfigProgressComponent = {
+    assetName?: string;
+    total: number;
+    position: number;
+    filler: {
+        width: number;
+        height: number;
+    };
+    fillerOffset: {
+        x: number;
+        y: number;
+    };
+    textures?: {
+        background: string;
+        filler: string;
+        mask: string;
+    };
+};
+/**
+ * Комопнент прогресс бар
+ */
+export declare class ProgressComponent extends AbstractComponent {
+    protected _config: TConfigProgressComponent;
+    protected _background: TPixiSprite;
+    protected _filler: TPixiSprite;
+    protected _mask: TPixiSprite;
+    protected _twin: TGsapTween;
+    /** */
+    get isMin(): boolean;
+    /** */
+    get isMax(): boolean;
+    /** */
+    constructor(name?: string, config?: TConfigProgressComponent);
+    /** */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** */
+    setPosition(position: number): Promise<this>;
+    /** */
+    draw(): Promise<this>;
+}

package/dist/types/src/components/slideshow/slides.reel.component.d.ts

@@ -0,0 +1,65 @@
+import { Graphics, InteractionEvent } from 'pixi.js';
+import { Container } from '../../classes/container.class';
+import { IComponent } from '../../extends/interfaces';
+import { TCallbackAsync, TDeviceOrientationConfig, TGsapTimeline, TNumberArray, TSupportContainer, TSupportMask } from '../../extends/short.types';
+import { AbstractComponent } from '../abstract.component';
+export type ISlideComponent = {
+    onMoveIn: TCallbackAsync;
+    onMoveOut: TCallbackAsync;
+} & IComponent;
+export type TConfigSlidesReel = {
+    slides: ISlideComponent[];
+    swipeLength: number;
+    adaptive: TDeviceOrientationConfig<{
+        slideWidth: number;
+        slideHeight: number;
+    }>;
+};
+/** Slides reel component. Contain slides, manages movement */
+export declare class SlidesReelComponent extends AbstractComponent {
+    protected _config: TConfigSlidesReel;
+    protected _mask: TSupportMask;
+    protected _hitArea: Graphics;
+    protected _slides: Map<number, ISlideComponent>;
+    protected _slidesOrder: TNumberArray;
+    protected _reelContainer: Container;
+    protected _currentSlide: number;
+    protected _slideTl: TGsapTimeline;
+    protected _pressed: boolean;
+    protected _startPosition: number;
+    protected _startPressPosition: number;
+    protected _swipeLastPosition: number;
+    protected _swipeDirection: number;
+    /** Returns index of current slide */
+    get currentIndex(): number;
+    /** Check next slide availability */
+    get isNextAvailable(): boolean;
+    /** Check previous slide availability */
+    get isPrevAvailable(): boolean;
+    /** returns slide width */
+    get slideWidth(): number;
+    /** Returns slide height */
+    get slideHeight(): number;
+    /** @constructor */
+    constructor(config: TConfigSlidesReel);
+    /** @inheritdoc */
+    create(instance: TSupportContainer): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** @inheritdoc */
+    draw(isModeChanged?: boolean): Promise<this>;
+    /** Moves slides reel to show slide */
+    slideTo(slideId: number, animate?: boolean): Promise<void>;
+    /** Moves slides to the next position */
+    slideToNext(): Promise<void>;
+    /** Moves slides to the previous position */
+    slideToPrev(): Promise<void>;
+    /** Sets event listener */
+    protected _addEventListeners(): void;
+    /** */
+    protected _onPointerDown(e: InteractionEvent): void;
+    /** */
+    protected _onPointerMove(e: InteractionEvent): void;
+    /** */
+    protected _onPointerUp(e: InteractionEvent): void;
+}

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

@@ -0,0 +1,27 @@
+import { TSupportContainer } from '../../extends/short.types';
+import { AbstractComponent } from '../abstract.component';
+import { SlidesReelComponent, TConfigSlidesReel } from './slides.reel.component';
+import { SlideshowUi, TConfigSlideshowUI } from './slideshow.ui.component';
+export type TConfigSlideshow = {
+    reel: TConfigSlidesReel;
+    ui?: TConfigSlideshowUI;
+};
+/** Slideshow component */
+export declare class SlideshowComponent extends AbstractComponent {
+    protected _reelComponent: SlidesReelComponent;
+    protected _ui: SlideshowUi;
+    protected _config: TConfigSlideshow;
+    /** Example */
+    /** @constructor */
+    constructor(name: string, config: TConfigSlideshow);
+    /** @inheritdoc */
+    create(instance: TSupportContainer): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** @inheritdoc */
+    draw(isModeChanged?: boolean): Promise<this>;
+    /** Update ui states */
+    protected _updateUiStates(): void;
+    /** Adds listeners */
+    protected _addEventListeners(): void;
+}

package/dist/types/src/components/slideshow/slideshow.ui.component.d.ts

@@ -0,0 +1,28 @@
+import { Point } from 'pixi.js';
+import { TDeviceOrientationConfig, TSupportContainer } from '../../extends/short.types';
+import { AbstractComponent } from '../abstract.component';
+import { ButtonTextures } from '../button.component';
+import { ButtonFadedComponent } from '../button.faded.component';
+import { SlideshowUiPagination, TConfigPagination } from './slideshow.ui.pagination';
+export type TConfigSlideshowUI = {
+    pagination?: TConfigPagination;
+    arrowTextures?: ButtonTextures;
+    adaptive?: TDeviceOrientationConfig<Point>;
+};
+/** Slideshow ui. Control panel, buttons, pagination */
+export declare class SlideshowUi extends AbstractComponent {
+    prevButton: ButtonFadedComponent;
+    nextButton: ButtonFadedComponent;
+    pagination: SlideshowUiPagination;
+    protected _hasArrows: boolean;
+    protected _hasPagination: boolean;
+    protected _config: TConfigSlideshowUI;
+    /** @constructor */
+    constructor(config: TConfigSlideshowUI);
+    /** @inheritdoc */
+    create(instance: TSupportContainer): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** @inheritdoc */
+    draw(modeChanged?: boolean): Promise<this>;
+}