@truelab/truengine 0.0.1-0

package/dist/types/src/extends/interfaces.d.ts

@@ -0,0 +1,74 @@
+import { IEmitter } from '../classes/emitter.class';
+import { IProducer } from '../classes/producer.class';
+import { SettingsService } from '../services/settings.service';
+import { TCallbackVoid, TMixedObject, TSupportContainer, TSupportMask } from './short.types';
+import * as PIXI from 'pixi.js';
+export type INamed = {
+    name: string;
+};
+export type IContainer = {
+    scaleX: number;
+    scaleY: number;
+    link(to: unknown, properties: string[], methods?: string[]): void;
+    disabled(to: unknown, onDisabled: TCallbackVoid, onEnabled: TCallbackVoid): void;
+    hide(): IContainer;
+    show(): IContainer;
+    setMask(graphics: TSupportMask): TSupportMask;
+    removeMask(): IContainer;
+    setBackground(sprite: PIXI.Sprite, offsetX?: number, offsetY?: number, angle?: number): IContainer;
+    setCenterPivot(): IContainer;
+    setPivot(xPos: number, yPos: number): IContainer;
+    centeredTo(toContainer: IContainer, offsetX: number, offsetY: number): IContainer;
+    centered(): IContainer;
+} & INamed & PIXI.Container;
+export type IScene = {
+    instance: IContainer;
+    producer: IProducer;
+    alpha: number;
+    destroyed: boolean;
+    hidden: boolean;
+    create(): Promise<boolean>;
+    destroy(): Promise<boolean>;
+    processing?(response: TMixedObject, isLast: boolean): Promise<TMixedObject>;
+    adaptive?(modeChanged?: boolean): Promise<void>;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+} & INamed & IEmitter;
+export type IComponent = {
+    instance: TSupportContainer;
+    width: number;
+    height: number;
+    alpha: number;
+    rotation: number;
+    position: PIXI.IPoint;
+    x: number;
+    y: number;
+    scale: PIXI.IPoint;
+    scaleX: number;
+    scaleY: number;
+    created: boolean;
+    disabled?: boolean;
+    create(instance?: TSupportContainer): Promise<IComponent>;
+    destroy(): Promise<IComponent>;
+    draw(modeChanged?: boolean): Promise<IComponent>;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+} & INamed;
+export type IComponentHTML = {
+    instance: null;
+    element: HTMLElement;
+    created: boolean;
+    create(): Promise<IComponentHTML>;
+    destroy(): Promise<IComponentHTML>;
+    draw(modeChanged?: boolean): Promise<IComponentHTML>;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+} & INamed;
+export type IPixiEngine = {
+    name: string;
+    start(): PIXI.Application;
+    stop(): PIXI.Application;
+    get<T = string>(name: string, def: T): T;
+    set(name: string, value: unknown): SettingsService;
+};
+export type IService = NonNullable<unknown>;

package/dist/types/src/extends/javascript.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Если шрифт языка не поддерживает верхний регистр, то вызовите эту функцию.
+ * Тогда .toUppercase() не сломает переводы.
+ */
+export declare const langDoesNotSupportUppercase: () => void;

package/dist/types/src/extends/short.types.d.ts

@@ -0,0 +1,68 @@
+import { EDevice, EOrientation } from '../classes/borderview.class';
+import { IComponent, IComponentHTML, IContainer, IPixiEngine, IService } from './interfaces';
+import * as PIXI from 'pixi.js';
+/**
+ * @rules
+ * - файл для наших типов и их сокращений
+ * - если тип используется всего один раз его не нужно объявлять
+ * - если тип используется несколько раз - выносим его сюда
+ * - имя типа всегда делаем с большой буквы T для удобства в подсказках
+ * - если вы видите что уже есть подходящий тип но назначение иное - лучше создайте еще один тип для своего кода
+ */
+/** @aliases */
+export type TEngine = IPixiEngine;
+export type TComponents = IComponent | IComponentHTML;
+export type TSupportContainer = IContainer & PIXI.Container;
+export type TSupportAnimate = IContainer & PIXI.Container & PIXI.Sprite;
+export type TSupportMask = PIXI.Graphics | PIXI.Sprite;
+/** @callbacks */
+export type TCallbackVoid = (...args: any[]) => void;
+export type TCallbackAsync<T = void> = (...args: any[]) => Promise<T>;
+export type TCallbackService = () => IService;
+/** @functions */
+export type TResolve = (value?: void | PromiseLike<void>) => void;
+/** @arrays */
+export type TStringArray = string[];
+export type TNumberArray = number[];
+export type TNumberArrays = TNumberArray[];
+/** @objects */
+export type TGenericObject<T> = Record<string, T>;
+export type TMixedObject = Record<string, any>;
+export type TNumericObject = Record<string, number>;
+export type TLangsReplace = Record<string, string>;
+export type TScenePayload = {
+    scene: string;
+    payload: TMixedObject;
+};
+export type TSceneResponse = TScenePayload[];
+/** @pixi @shorttypes */
+export type TPixiPoint = PIXI.Point;
+export type TPixiEvent = PIXI.InteractionEvent;
+export type TPixiSprite = PIXI.Sprite;
+export type TPixiTexture = PIXI.Texture;
+export type TPixiTextures = PIXI.Texture[];
+export type TPixiText = PIXI.Text;
+export type TPixiTextStyle = PIXI.TextStyle;
+export type TPixiBitmapText = PIXI.BitmapText;
+export type TPixiSpritesheet = PIXI.Spritesheet;
+export type TPixiAnimatedSprite = PIXI.AnimatedSprite;
+export type TPixiDisplayObject = PIXI.DisplayObject;
+export type TPixiFrameObject = PIXI.FrameObject;
+export type TPixiAnimations = TPixiFrameObject[];
+export type TPixiFill = string | number | string[] | number[] | CanvasGradient | CanvasPattern;
+/** @calculated */
+export type TInterval = ReturnType<typeof setInterval>;
+export type TTimeout = ReturnType<typeof setTimeout>;
+/** @gsap @shorttypes */
+export type TGsapTween = gsap.core.Tween;
+export type TGsapTimeline = gsap.core.Timeline;
+export type TDeviceConfig<T> = {
+    [key in EDevice]?: T;
+};
+export type TOrientationConfig<T> = {
+    [key in EOrientation]?: T;
+};
+export type TDeviceOrientationConfig<T> = TDeviceConfig<TOrientationConfig<T>>;
+export type TConstructor<T> = new (...args: any[]) => T;
+export type TGsapEase = string | gsap.EaseFunction;
+export type TTimeScale = [number, number];

package/dist/types/src/extends/struct.types.d.ts

@@ -0,0 +1,260 @@
+import { TCheat } from '../components/cheat.component';
+import { EPromoType } from './enum.types';
+import { TGenericObject, TMixedObject, TResolve } from './short.types';
+import * as PIXI from 'pixi.js';
+export type TAnimateOptions = {
+    duration: number;
+    ease?: string;
+    delay?: number;
+    yoyo?: boolean;
+    repeat?: number;
+    onComplete?: TResolve;
+};
+export type TComponentProperties = {
+    width: number;
+    height: number;
+    alpha: number;
+    position: PIXI.IPoint;
+    x: number;
+    y: number;
+    rotation: number;
+    scale: PIXI.IPoint;
+    scaleX: number;
+    scaleY: number;
+};
+export type TButtonTexturesNames = {
+    disable: string;
+    origin: string;
+    hover: string;
+    click: string;
+};
+export type TAutoButtonTexturesNames = {
+    disable: string;
+    origin: string;
+    hover: string;
+    click: string;
+    icon: string;
+    countdown: string;
+};
+export type TButtonTexturesPair = {
+    on: TButtonTexturesNames;
+    off: TButtonTexturesNames;
+};
+export type TPosition = {
+    x: number;
+    y: number;
+};
+export type TPromo = {
+    type: EPromoType;
+    issued: number;
+    count: number;
+    totalWon: number;
+    failed?: boolean;
+};
+export type TBetPublic = {
+    uuid: string;
+    balance: number;
+    coinValue: number;
+    amount: number;
+    currency: string;
+    session: string;
+    won: number;
+    coefficients: number;
+    gameResponse: TMixedObject;
+    status: number;
+};
+export type TRollResponse = {
+    status: boolean;
+    balance?: number;
+    bet?: TBetPublic;
+    replay?: {
+        betIndex: number;
+        balance: number;
+    };
+    promotools?: TPromo[];
+    code?: number;
+    message?: string;
+    custom?: TMixedObject;
+};
+export type TResponse = {
+    gameResponse: TMixedObject;
+    win: number;
+    balance?: number;
+};
+export type TEngineSettings = {
+    [key: string]: unknown;
+    win?: number;
+    balance?: number;
+    currency?: string;
+    coinLevel?: number;
+    coinValues?: string[];
+    cashBets?: number[];
+    debug?: boolean;
+    cheat?: TCheat;
+    localization?: string;
+    commit?: string;
+    rulesVersion?: string;
+    rulesDate?: string;
+    rtp?: string;
+    limitBets?: number;
+    limitWin?: number;
+    session?: string;
+    casinoUrl?: string;
+    returnUrl?: string;
+    demo?: boolean;
+    sounds?: boolean;
+    soundsAmbience?: boolean;
+    soundsEffects?: boolean;
+    soundsVolume?: number;
+    welcomeModalSupported?: boolean;
+    welcomeModalEnabled?: boolean;
+    skipSupported?: boolean;
+    skipActive?: boolean;
+    fastPlaySupported?: boolean;
+    fastPlayEnabled?: boolean;
+};
+export type TConfigResponse = {
+    settings: TEngineSettings;
+    langs: TGenericObject<string>;
+    status: boolean;
+    message?: string;
+};
+export type TPoint = {
+    x: number;
+    y: number;
+};
+export type TTextParams = {
+    x: number;
+    y: number;
+    text: string;
+    slug?: string;
+    style?: PIXI.TextStyle;
+    pivot?: [number, number];
+    maxWidth?: number;
+};
+export type TBitmapStyle = {
+    fontName: string;
+    fontSize?: number;
+    align?: string;
+    tint?: number;
+    letterSpacing?: number;
+    maxWidth?: number;
+};
+export type TSymbolsPayoutBase = {
+    /** Symbol code, e. g. `11 - wild`, `2 - low#2 (blue gem)` */
+    symbol: number;
+    /** Winning for the symbol combination in coins by pay table */
+    coins: number;
+    /** Line/way length or cluster size */
+    length: number;
+    /** Positions on the field which cause the winning combination */
+    positions: number[];
+};
+export type TSymbolMoveBase = {
+    /** Position where from symbol should move */
+    from: number;
+    /** Destination position */
+    to: number;
+};
+export type TSymbolPositionsBase = {
+    /** Positions of gaps which appeared after disappearance of winning symbols of previous field and moving of hanging symbols */
+    in?: number[];
+    /** All positions which should be disappeared */
+    out?: number[];
+    /** Set of moves of hanging symbols */
+    move?: TSymbolMoveBase[];
+};
+export type TSymbolsBase = {
+    /** Total win amount for all symbols in coins  */
+    coins: number;
+    /** Original symbols codes appeared on the field. Index of array is position */
+    original: number[];
+    /** Final symbol codes after applying all features (`sticky`, `mystery`, etc.) */
+    final: number[];
+    /** Information about symbols movements */
+    positions?: TSymbolPositionsBase;
+    /** Describes winnings of final symbols by pay table (using classic mechanics - `lines`, `ways`, `clusters`)  */
+    payouts: TSymbolsPayoutBase[];
+};
+export type TFeaturePayoutBase = {
+    /** Win amount in coins */
+    coins: number;
+};
+export type TFeatureBase<TValue = number, TPayout = TFeaturePayoutBase> = {
+    /** Positions are used for features which affect symbols on the playground */
+    positions: number[];
+    /** New symbols affected by the feature */
+    previousPositions: number[];
+    /** Previous positions of movable symbols affected by the feature */
+    newPositions: number[];
+    /** Some values provided by feature. (multipliers, cumulative things, gameplay information, etc.) */
+    values: TValue[];
+    /** New values for dynamic count */
+    newValues: TValue[];
+    /** Previous values of dynamic feature */
+    previousValues: TValue[];
+    /** Describe additional winnings of the feature (wheel, total multiplier, etc.) */
+    payouts: TPayout[];
+};
+export type TFieldBase = {
+    /** Total win amount in coins - sum of wins for all symbols and features */
+    coins: number;
+    /** Information about symbols positions and its payouts  */
+    symbols: TSymbolsBase;
+    /** Information about all features on the field */
+    features: Record<string, Partial<TFeatureBase>>;
+};
+export type TSpinBase = {
+    /** Total win amount in coins - sum of wins of fields */
+    coins: number;
+    /** Single field for non-cluster games or list of cascading fields */
+    fields: TFieldBase[];
+    added?: number | number[];
+    addedType?: string | string[];
+};
+export type TGameBase = {
+    /** Type of game, e.g. "regular", "respins", "freespinsSticky", "freespinsRandom" */
+    type: string;
+    /** Total win amount in coins - sum of wins of spins of the game */
+    coins: number;
+    /** List of spins of the game */
+    spins: TSpinBase[];
+};
+export type TStepBase = {
+    /** List of games of the step */
+    games: TGameBase[];
+    /** Final result information */
+    totalResults: {
+        /** Total win amount in coins - sum of wins of all spins */
+        coins: number;
+        /** `true` if max win amount was reached */
+        hasMaxWin: boolean;
+    };
+};
+export type TMetaBase = {
+    /** Service end-to-end data for additional calculations */
+    private: TMixedObject;
+    /** Cumulative progress or state between bets */
+    public: TMixedObject;
+};
+export type TRngBase = {
+    value: number;
+};
+export type TResponseBase = {
+    step: TStepBase;
+    rng: TRngBase[];
+};
+export type TSymbolsPayoutLinesBase = TSymbolsPayoutBase & {
+    /** Positions of full payline */
+    line: number[];
+};
+export type TSymbolsPayoutWaysBase = TSymbolsPayoutBase & {
+    /** Count of ways for the symbol code */
+    ways: number;
+};
+export type TSymbolsPayoutClustersBase = TSymbolsPayoutBase & TMixedObject;
+export type TSymbolsPayoutDynamicBase = TSymbolsPayoutBase & TMixedObject;
+export type TFieldDynamicBase = TFieldBase & {
+    /** Symbols positions presented as matrix - `[iRow, iReel]` */
+    grid: [number, number][];
+};

package/dist/types/src/functions/agent.funcs.d.ts

@@ -0,0 +1,84 @@
+/**
+ * getUserAgent
+ */
+export declare function getUserAgent(): string;
+/**
+ * isMobile
+ */
+export declare function isMobile(): boolean;
+/**
+ * isDesktop
+ */
+export declare function isDesktop(): boolean;
+/**
+ * isIEMobile
+ */
+export declare function isIEMobile(): boolean;
+/**
+ * isTablet
+ */
+export declare function isTablet(): boolean;
+/**
+ * isFirefox
+ */
+export declare function isFirefox(): boolean;
+/**
+ * isEdge
+ */
+export declare function isEdge(): boolean;
+/**
+ * isSafari
+ */
+export declare function isSafari(): boolean;
+/**
+ * isIOS
+ */
+export declare function isIOS(): boolean;
+/**
+ * isMac
+ */
+export declare function isMac(): boolean;
+/**
+ * isIPhone
+ */
+export declare function isIPhone(): boolean;
+/**
+ * isAndroid
+ */
+export declare function isAndroid(): boolean;
+/**
+ * isAndroidTablet
+ */
+export declare function isAndroidTablet(): boolean;
+/**
+ * isNativeApp
+ */
+export declare function isNativeApp(): boolean;
+/**
+ * isPortraitMode
+ */
+export declare function isPortraitMode(): boolean;
+/**
+ * isLandscapeMode
+ */
+export declare function isLandscapeMode(): boolean;
+/** Для определения ориентации платформы (есть проблема на Windows в режиме эмуляции mobile) */
+export declare function isPlatformPortraitMode(): boolean;
+/** Для определения ориентации платформы */
+export declare function isPlatformLandscapeMode(): boolean;
+/**
+ * isSmallScreenSize
+ */
+export declare function isSmallScreenSize(): boolean;
+/**
+ * isRetina
+ */
+export declare function isRetina(): boolean;
+/**
+ * inIframe
+ */
+export declare function inIframe(): boolean;
+/** isWebpSupported */
+export declare function isWebpSupported(): boolean;
+/** isFullscreenSupported */
+export declare function isFullscreenSupported(): boolean;

package/dist/types/src/functions/animate/counter.func.d.ts

@@ -0,0 +1,10 @@
+import { TGsapTween } from '../../extends/short.types';
+/**
+ * Анимация цифр
+ * @param from от значения
+ * @param to к значению
+ * @param onUpdate передаем промежуточное значение
+ * @param duration продолжительность счетчика
+ * @refactoring избавиться от умножения/деления на k
+ */
+export declare function animateCounter(from: number, to: number, onUpdate?: (counter: number) => void, duration?: number): TGsapTween;

package/dist/types/src/functions/animate/fadein.func.d.ts

@@ -0,0 +1,8 @@
+import { IContainer } from '../../extends/interfaces';
+import { TGsapTween } from '../../extends/short.types';
+/**
+ * Показать контейнер (fade in)
+ * @param container
+ * @param duration
+ */
+export declare function animateFadeIn(container: IContainer, duration?: number): TGsapTween;

package/dist/types/src/functions/animate/fadeout.func.d.ts

@@ -0,0 +1,8 @@
+import { IContainer } from '../../extends/interfaces';
+import { TGsapTween } from '../../extends/short.types';
+/**
+ * Скрыть контейнер (fade out)
+ * @param container
+ * @param duration
+ */
+export declare function animateFadeOut(container: IContainer, duration?: number): TGsapTween;

package/dist/types/src/functions/animate/from.func.d.ts

@@ -0,0 +1,10 @@
+import { TGsapTween, TMixedObject } from '../../extends/short.types';
+import { TAnimateOptions } from '../../extends/struct.types';
+/**
+ * Обратный аниматор состояния от указанных свойств до текущего
+ * @param target - анимируемый элемент
+ * @param vars - объект опций начальных значений анимации
+ * @param kill - указать {false}, если нужно параллельно запустить анимацию
+ * на том же объекте, {true} - убивать предыдущий твин на target
+ */
+export declare function animateFrom(target: gsap.TweenTarget, vars: TAnimateOptions | TMixedObject, kill?: boolean): TGsapTween;

package/dist/types/src/functions/animate/fromto.func.d.ts

@@ -0,0 +1,11 @@
+import { TGsapTween, TMixedObject } from '../../extends/short.types';
+import { TAnimateOptions } from '../../extends/struct.types';
+/**
+ * Аниматор с возможностью указать стартовые и конечные свойства
+ * @param target - анимируемый элемент
+ * @param fromVars - объект опций начальных значений анимации
+ * @param toVars - объект опций конечных значений анимации
+ * @param kill - указать {false}, если нужно параллельно запустить анимацию
+ * на том же объекте, {true} - убивать предыдущий твин на target
+ */
+export declare function animateFromTo(target: gsap.TweenTarget, fromVars: TMixedObject, toVars: TAnimateOptions | TMixedObject, kill?: boolean): TGsapTween;

package/dist/types/src/functions/animate/to.func.d.ts

@@ -0,0 +1,10 @@
+import { TGsapTween, TMixedObject } from '../../extends/short.types';
+import { TAnimateOptions } from '../../extends/struct.types';
+/**
+ * Аниматор от текущего состояния до указанных свойств
+ * @param target - анимируемый элемент
+ * @param vars - объект опций конечных значений анимации
+ * @param kill - указать {false}, если нужно параллельно запустить анимацию
+ * на том же объекте, {true} - убивать предыдущий твин на target
+ */
+export declare function animateTo(target: gsap.TweenTarget, vars: TAnimateOptions | TMixedObject, kill?: boolean): TGsapTween;

package/dist/types/src/functions/array/indexofall.func.d.ts

@@ -0,0 +1,2 @@
+/** */
+export declare function arrayIndexOfAll<T>(array: T[], value: unknown): number[];

package/dist/types/src/functions/array/position.func.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Вычисляет позицию в распределении и возвращает элемент из массива
+ * @param value любое число диапазона
+ * @param array элементы распределенные по диапазону
+ */
+export declare function arrayPosition<T = string>(input: number, total: number, array: T[]): T;

package/dist/types/src/functions/array/unique.func.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Вернет массив с уникальными значениями, без повторяющихся
+ * @param values
+ * @returns
+ */
+export declare function arrayUnique<T = number>(values: T[]): T[];

package/dist/types/src/functions/arraysintersect.func.d.ts

@@ -0,0 +1,2 @@
+/** */
+export declare function arraysIntersect(array1: unknown[], array2: unknown[]): boolean;

package/dist/types/src/functions/cache.funcs.d.ts

@@ -0,0 +1,20 @@
+export type TDebounce = {
+    call: () => void;
+    cancel: () => void;
+};
+/**
+ * Закешировать результаты колбека
+ * @param key
+ * @param callback
+ */
+export declare function once<T = string>(key: string, callback: () => T): T;
+/**
+ * Очистить закешированные результаты колбеков
+ */
+export declare function clear(key: string): void;
+/**
+ * @description Ограничить количество вызовов функции за период времени
+ * @_callback {CallableFunction} исполняемая функция
+ * @duration {number} - время в ms, вызывать @callback не чаще чем 1 раз за время @duration
+ */
+export declare function debounce(callback: CallableFunction, duration: number): TDebounce;

package/dist/types/src/functions/cheats.func.d.ts

@@ -0,0 +1,2 @@
+/** */
+export declare const isCheatsAvailable: () => boolean;

package/dist/types/src/functions/convert/tofixed.func.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Приводит входное значение к нормальному округленному числу с нужным количеством знаков после точки.
+ * Если длина вещественной части числа больше 6 символов, то лишние нули справа обрезаются.
+ * + toFixed() 0.00000200
+ * + replace() 0.000002
+ * @param value значение для приведения к нормальному виду
+ * @param decimals длина хвоста
+ */
+export declare function convertToFixed(value: number, decimals: number): string;

package/dist/types/src/functions/debug/container.func.d.ts

@@ -0,0 +1,7 @@
+import { TSupportContainer } from '../../extends/short.types';
+import * as PIXI from 'pixi.js';
+/**
+ * Контейнер
+ * @param instance
+ */
+export declare function debugContainer(instance: TSupportContainer): PIXI.Graphics;

package/dist/types/src/functions/debug/line.func.d.ts

@@ -0,0 +1,10 @@
+import { IContainer } from '../../extends/interfaces';
+import { TPosition } from '../../extends/struct.types';
+import * as PIXI from 'pixi.js';
+/**
+ * Линия
+ * @param from
+ * @param to
+ * @param instance
+ */
+export declare function debugLine(from: TPosition, to: TPosition, instance?: IContainer): PIXI.Graphics;

package/dist/types/src/functions/demotexture.func.d.ts

@@ -0,0 +1,3 @@
+import { TPixiTexture } from '../extends/short.types';
+/** Demo symbol texture  */
+export declare function demoTexture(code: number, height?: number, color?: number, isMotion?: boolean): TPixiTexture;

package/dist/types/src/functions/dom.funcs.d.ts

@@ -0,0 +1,6 @@
+/** */
+export declare const loadResources: (href: string | string[], rel?: string, as?: string, type?: string) => void;
+/** */
+export declare function loadCSS(href: string): Promise<Event>;
+/** */
+export declare function loadJS(src: string): Promise<Event>;

package/dist/types/src/functions/draw/canvasExtract.func.d.ts

@@ -0,0 +1,16 @@
+import * as PIXI from 'pixi.js';
+/** Экспортирует DisplayObject как изображение
+ * @param displayObject - элемент
+ * @returns Тег <img ... />
+ */
+export declare function displayObjectToImage(displayObject: PIXI.DisplayObject): HTMLImageElement;
+/** Экспортирует DisplayObject в base64
+ * @param displayObject - элемент
+ * @returns base64
+ */
+export declare function displayObjectToBase64(displayObject: PIXI.DisplayObject): string;
+/** Экспортирует DisplayObject в base64
+ * @param displayObject - элемент
+ * @returns PIXI.Texture
+ */
+export declare function displayObjectToTexture(displayObject: PIXI.DisplayObject, options: PIXI.IGenerateTextureOptions): PIXI.RenderTexture;