@truelab/truengine 0.0.1-0

package/dist/types/src/components/slot/slot.cheats.d.ts

@@ -0,0 +1,22 @@
+import { TSlotConfig } from './slot.config';
+/** Use only from components */
+declare class SlotCheats {
+    [x: string]: any;
+    protected _config: TSlotConfig;
+    /** */
+    addGeneral(): void;
+    /** */
+    addSlot(): void;
+    /** */
+    addCascadeGeneral(): void;
+    /** */
+    addCascade(): void;
+    /** */
+    addIntrigue(): void;
+    /** */
+    addIntrigueSpineComponent(): void;
+    /** */
+    addCascadeBounce(): void;
+}
+export declare const slotCheats: SlotCheats;
+export {};

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

@@ -0,0 +1,132 @@
+import { Container } from '../../classes/container.class';
+import { TGsapTimeline, TGsapTween, TNumberArray, TPixiPoint, TStringArray, TSupportContainer } from '../../extends/short.types';
+import { TSymbolMoveBase, TSymbolsPayoutBase } from '../../extends/struct.types';
+import { AbstractComponent } from '../abstract.component';
+import { ICoefficientComponent } from './coefficient/coefficient.component';
+import { IFramesComponent } from './frames/frames.component';
+import { IHintsComponent } from './hints/hints.component';
+import { IIntrigueComponent } from './intrigue/intrigue.component';
+import { ILinesComponent } from './lines/lines.component';
+import { IReelComponent } from './reel.component';
+import { ISlotComponent, TLineDataLike, TSlotConfig, TSlotVector, TSoundEventOptions } from './slot.config';
+import { ISymbolComponent } from './symbol/symbol.component';
+/** Slot component */
+export declare class FWSlotComponent extends AbstractComponent implements ISlotComponent {
+    protected _config: TSlotConfig;
+    protected _reels: IReelComponent[];
+    protected _layers: Map<string, Container>;
+    protected _framesComponent: IFramesComponent;
+    protected _coefficientComponent: ICoefficientComponent;
+    protected _linesComponent: ILinesComponent;
+    protected _intrigueComponent: IIntrigueComponent;
+    protected _hintsComponent: IHintsComponent;
+    protected _timelineLines: TGsapTimeline;
+    protected _breakableSleep: TGsapTween;
+    protected _playingSounds: TSoundEventOptions[];
+    protected _isMotion: boolean;
+    protected _startPromises: Promise<void>[];
+    /** Gets slot width */
+    get slotWidth(): number;
+    /** Gets slot height */
+    get slotHeight(): number;
+    /** Calc min stop time (ms) */
+    get minSpinTime(): number;
+    /** @constructor */
+    constructor(config?: TSlotConfig);
+    /** @inheritdoc */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** @inheritdoc */
+    draw(): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** Creates reels components */
+    createReelsComponents(): Promise<void>;
+    /** Creates frames component */
+    createFramesComponent(): Promise<void>;
+    /** Creates coefficient component */
+    createCoefficientComponent(): Promise<void>;
+    /** Creates lines component */
+    createLinesComponent(): Promise<void>;
+    /** Creates intrigue component */
+    createIntrigueComponent(): Promise<void>;
+    /** Creates hints component */
+    createHintsComponent(): Promise<void>;
+    /** Starts spin */
+    start(): Promise<void>;
+    /** Stops spin */
+    stop(playground?: TNumberArray): Promise<void>;
+    /** Stops spin force */
+    stopForce(playground?: TNumberArray): Promise<void>;
+    /** */
+    refill(playground: TNumberArray, positionsIn?: TNumberArray, positionsMove?: TSymbolMoveBase[]): Promise<void>;
+    /** */
+    protected _animateMoveAndRefill(playground: TNumberArray, positionsIn: TNumberArray, positionsMove: TSymbolMoveBase[]): Promise<void>;
+    /** */
+    protected _animateMove(positions: TSymbolMoveBase[]): Promise<void>;
+    /** */
+    protected _animateRefill(playground: TNumberArray, positionsIn: TNumberArray): Promise<void>;
+    /** */
+    animateWin(payouts: TSymbolsPayoutBase[], coefficient: number): Promise<void>;
+    /** Find and play one sounds sample for whole line */
+    playSoundWin(positions: TNumberArray): void;
+    /** */
+    getIntrigueReels(playground: TNumberArray, positionsIn?: TNumberArray): TNumberArray;
+    /** Stop all started in the component sounds */
+    stopSounds(): void;
+    /** Starts animates lines */
+    startLines(lines: TLineDataLike[]): Promise<void>;
+    /** Stops lines */
+    stopLines(): void;
+    /** Animates symbols */
+    animateWinSymbols(positions: TNumberArray, coefficient?: number, frames?: boolean): Promise<void>;
+    /** */
+    animateHideSymbols(positions: TNumberArray): Promise<void>;
+    /** Animate symbols with custom animation */
+    animateSymbolsWith(positions: TNumberArray, animationName: string): Promise<void>;
+    /** Animates single line */
+    animateLine(lineData: TLineDataLike): Promise<void>;
+    /** Получить все позиции */
+    getAllPositions(): TNumberArray;
+    /** Получить коды символов */
+    getSymbols(): TNumberArray;
+    /** Получить компоненты символов */
+    getSymbolsComponents(): ISymbolComponent[];
+    /** Задать символы на поле */
+    setSymbols(symbols: TNumberArray): void;
+    /** Sets layers order */
+    setLayersOrder(order?: TStringArray): void;
+    /** enable / disable hints component */
+    toggleHints(on: boolean): void;
+    /** Gets unique positions of wins symbols */
+    getWinsPositions(lines: TSymbolsPayoutBase[]): TNumberArray;
+    /** Gets reel component */
+    getReel(iReel: number): IReelComponent;
+    /** Gets symbol component (two dimensional coords) */
+    getSymbolByVector(iReel: number, iRow: number): ISymbolComponent;
+    /** Gets symbol component (one dimensional coords) */
+    getSymbolByPosition(position: number): ISymbolComponent;
+    /** Gets reel position */
+    getReelPosition(iReel: number): number;
+    /** Gets row position */
+    getRowPosition(iRow: number): number;
+    /** Gets iReel by position (one dimensional coords) */
+    getReelByPosition(position: number): number;
+    /** Gets iRow by position (one dimensional coords) */
+    getRowByPosition(position: number): number;
+    /** Gets position by iReel, iRow */
+    getPositionByVector(iReel: number, iRow: number): number;
+    /** Gets iReel, iRow by position (one dimensional coords) */
+    getVectorByPosition(position: number): TSlotVector;
+    /** Gets point (x, y) by vector */
+    getPointByVector(iReel: number, iRow: number): TPixiPoint;
+    /** Gets point (x, y) by position */
+    getPointByPosition(position: number): TPixiPoint;
+    /** */
+    protected _getIReelsFromPositions(positions: TNumberArray): TNumberArray;
+    /** Sets default dynamic configs */
+    protected _setDefaultConfig(): void;
+    /** Sets textures */
+    protected _setTextures(): void;
+    /** add cheats to the cheat panel */
+    protected _runCheats(): void;
+}

package/dist/types/src/components/slot/slot.config.d.ts

@@ -0,0 +1,82 @@
+import { IComponent } from '../../extends/interfaces';
+import { TNumberArray, TNumberArrays, TStringArray } from '../../extends/short.types';
+import { TSymbolMoveBase, TSymbolsPayoutBase } from '../../extends/struct.types';
+import { ICoefficientComponent, TConfigCoefficientComponent } from './coefficient/coefficient.component';
+import { IFramesComponent, TConfigFramesComponent } from './frames/frames.component';
+import { IHintsComponent, TConfigHintsComponent } from './hints/hints.component';
+import { IIntrigueComponent, TConfigIntrigueComponent } from './intrigue/intrigue.component';
+import { ILinesComponent, TConfigLinesComponent } from './lines/lines.component';
+import { IReelComponent, TConfigReelComponent } from './reel.component';
+import { ISymbolComponent, TConfigSymbolComponent } from './symbol/symbol.component';
+export type ISlotComponent = {
+    start: () => Promise<void>;
+    stop: (playground?: TNumberArray, intrigueReels?: TNumberArray) => Promise<void>;
+    stopForce: (playground?: TNumberArray) => Promise<void>;
+    refill: (symbolCodes: TNumberArray, positionsIn?: TNumberArray, positionsMove?: TSymbolMoveBase[], intrigueReels?: TNumberArray) => Promise<void>;
+    animateWin: (payouts: TSymbolsPayoutBase[], coefficient: number) => Promise<void>;
+    animateHideSymbols: (positions: TNumberArray) => Promise<void>;
+} & IComponent;
+export type ISlotFactory = {
+    getReelComponent: (iReel: number, config: TConfigReelComponent) => IReelComponent;
+    getSymbolComponent: (iReel: number, iRow: number, config: TConfigSymbolComponent) => ISymbolComponent;
+    getFramesComponent?: (config: TConfigFramesComponent) => IFramesComponent;
+    getCoefficientComponent?: (config: TConfigCoefficientComponent) => ICoefficientComponent;
+    getLinesComponent?: (config: TConfigLinesComponent) => ILinesComponent;
+    getIntrigueComponent?: (config: TConfigIntrigueComponent) => IIntrigueComponent;
+    getHintsComponent?: (config: TConfigHintsComponent) => IHintsComponent;
+};
+export type TLineDataLike = {
+    line: TNumberArray;
+    coins: number;
+    length: number;
+};
+export type TSlotConfig = {
+    factory?: ISlotFactory;
+    numReels?: number;
+    order?: {
+        reels?: TNumberArray;
+        start?: TNumberArrays;
+        stop?: TNumberArrays;
+        layers?: TStringArray;
+    };
+    assetsName?: {
+        static?: string;
+        motion?: string;
+    };
+    texturesNames?: {
+        static?: [number, string][];
+        motion?: [number, string][];
+    };
+    slowStopReel?: number;
+    spinDelay?: {
+        start?: [number, number];
+        stop?: [number, number];
+        slowStop?: [number, number];
+        slowStopWin?: [number, number];
+    };
+    events?: {
+        start?: boolean;
+        stop?: boolean;
+    };
+    components?: {
+        reel: TConfigReelComponent;
+        frames?: TConfigFramesComponent;
+        coefficient?: TConfigCoefficientComponent;
+        lines?: TConfigLinesComponent;
+        intrigue?: TConfigIntrigueComponent;
+        hints?: TConfigHintsComponent;
+    };
+    sounds?: {
+        symbolsWin: Map<number, string>;
+    };
+};
+export type TSlotVector = {
+    iReel: number;
+    iRow: number;
+};
+export type TSoundEventOptions = {
+    name: string;
+    tag?: string;
+    delay?: number;
+};
+export declare const slotComponentConfig: TSlotConfig;

package/dist/types/src/components/slot/symbol/symbol.component.d.ts

@@ -0,0 +1,84 @@
+import { Sequence } from '../../../classes/sequence.class';
+import { Spine } from '../../../classes/spine.assets.class';
+import { IComponent } from '../../../extends/interfaces';
+import { TCallbackAsync, TCallbackVoid, TPixiSprite, TPixiTexture, TSupportContainer } from '../../../extends/short.types';
+import { AbstractComponent } from '../../abstract.component';
+export type ISymbolComponent = {
+    iReel: number;
+    iRow: number;
+    code: number;
+    setTextureByCode: (code: number, isMotion?: boolean) => void;
+    animateName: TCallbackAsync;
+    animateWin: TCallbackAsync;
+    animateStop: TCallbackAsync;
+    animateIdle: TCallbackVoid;
+    animateShow: TCallbackAsync;
+    animateHide: TCallbackAsync;
+    destroyAnimation: TCallbackVoid;
+} & IComponent;
+export type TConfigSymbolComponent = {
+    size?: {
+        width?: number;
+        height?: number;
+        indentTop?: number;
+        indentLeft?: number;
+        motionScale?: number;
+    };
+    textures?: {
+        static?: Map<number, TPixiTexture>;
+        motion?: Map<number, TPixiTexture>;
+    };
+    animationAssets?: Map<number, string>;
+    animationNames?: {
+        win?: Map<number, string>;
+        idle?: Map<number, string>;
+        stop?: Map<number, string>;
+    };
+    fastModeTimeScale?: {
+        win?: number;
+        bounce?: number;
+    };
+    vanish?: {
+        enabled?: boolean;
+        assetName?: string;
+        animationName?: string;
+        hideDelay?: [number, number];
+        hideDuration?: [number, number];
+        timeScale?: [number, number];
+    };
+};
+/** Symbol component */
+export declare abstract class FWAbstractSymbolComponent extends AbstractComponent implements ISymbolComponent {
+    iReel: number;
+    iRow: number;
+    code: number;
+    protected _config: TConfigSymbolComponent;
+    protected _sprite: TPixiSprite;
+    protected _animation: Sequence | Spine;
+    /** @constructor */
+    constructor(iReel: number, iRow: number, config: TConfigSymbolComponent);
+    /** @inheritdoc */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** @inheritdoc */
+    draw(): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** Sets symbol's texture */
+    setTextureByCode(code: number, isMotion?: boolean): void;
+    /** Toggles cacheAsBitmap for animation */
+    toggleBitmap(on?: boolean): void;
+    /** */
+    animateHide(): Promise<void>;
+    /** */
+    animateShow(): Promise<void>;
+    /** Animate by name */
+    abstract animateName(name: string, timeScale: [number, number]): Promise<void>;
+    /** Animates stop */
+    abstract animateStop(): Promise<void>;
+    /** Animates win */
+    abstract animateWin(): Promise<void>;
+    /** Starts idle animation */
+    abstract animateIdle(): void;
+    /** Destroys animation */
+    abstract destroyAnimation(): void;
+}

package/dist/types/src/components/slot/symbol/symbol.sequence.component.d.ts

@@ -0,0 +1,18 @@
+import { Sequence } from '../../../classes/sequence.class';
+import { FWAbstractSymbolComponent } from './symbol.component';
+/** Symbol component with sequence animations */
+export declare class FWSymbolSequenceComponent extends FWAbstractSymbolComponent {
+    protected _animation: Sequence;
+    /** @inheritdoc */
+    animateName(): Promise<void>;
+    /** @inheritdoc */
+    animateWin(): Promise<void>;
+    /** @inheritdoc */
+    animateStop(): Promise<void>;
+    /** @inheritdoc */
+    animateIdle(): void;
+    /** @inheritdoc */
+    stopAnimation(): void;
+    /** @inheritdoc */
+    destroyAnimation(): void;
+}

package/dist/types/src/components/slot/symbol/symbol.spine.component.d.ts

@@ -0,0 +1,18 @@
+import { Spine } from '../../../classes/spine.assets.class';
+import { FWAbstractSymbolComponent } from './symbol.component';
+/** Symbol component */
+export declare class FWSymbolSpineComponent extends FWAbstractSymbolComponent {
+    protected _animation: Spine;
+    /** Inits animation */
+    protected initAnimation(): boolean;
+    /** @inheritdoc */
+    animateName(name: string, timeScale: [number, number]): Promise<void>;
+    /** @inheritdoc */
+    animateWin(): Promise<void>;
+    /** @inheritdoc */
+    animateStop(): Promise<void>;
+    /** @inheritdoc */
+    animateIdle(): void;
+    /** @inheritdoc */
+    destroyAnimation(): void;
+}

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

@@ -0,0 +1,62 @@
+import { EPivot } from '../extends/enum.types';
+import { TPixiSprite, TPixiTexture, TSupportContainer } from '../extends/short.types';
+import { AbstractComponent } from './abstract.component';
+import { TextComponent } from './text.component';
+import * as PIXI from 'pixi.js';
+export type TSwitchConfig = {
+    backgroundOnTexture: TPixiTexture;
+    backgroundOffTexture?: TPixiTexture;
+    checked: boolean;
+    handleOnTexture: TPixiTexture;
+    handleOffTexture?: TPixiTexture;
+    handlePositionOn?: {
+        x: number;
+        y: number;
+    };
+    handlePositionOff?: {
+        x: number;
+        y: number;
+    };
+    handleAnimationDuration?: number;
+    labelText?: string;
+    labelStyle?: PIXI.TextStyle;
+    labelPivot?: {
+        x: EPivot;
+        y: EPivot;
+    };
+    labelPosition?: {
+        x: number;
+        y: number;
+    };
+    initEvents?: boolean;
+};
+/** Компонент свитчера */
+export declare class SwitchComponent extends AbstractComponent {
+    protected _config: TSwitchConfig;
+    protected _background: TPixiSprite;
+    protected _handle: TPixiSprite;
+    protected _label?: TextComponent;
+    protected _checked: boolean;
+    /** Состояние переключателя */
+    get checked(): boolean;
+    /** Переключить свитчер */
+    set checked(checked: boolean);
+    /** @constructor */
+    constructor(name: string, config: TSwitchConfig);
+    /** @inheritdoc */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** @inheritdoc */
+    draw(): Promise<this>;
+    /** Задать текст для лейбла */
+    setLabelText(text: string): void;
+    /** */
+    setLabelMaxWidth(width: number): void;
+    /** Установить текстуры в зависимости от состояния */
+    protected _setTextures(): void;
+    /** Передвинуть свитчер в нужное положение */
+    protected _animateSwitch(duration?: number): Promise<void>;
+    /** Пользователь нажал на переключатель */
+    protected _onPointerDown(e?: PIXI.InteractionEvent): void;
+}

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

@@ -0,0 +1,101 @@
+import { TMixedObject, TPixiPoint, TSupportContainer } from '../extends/short.types';
+import { AbstractComponent } from './abstract.component';
+import * as PIXI from 'pixi.js';
+export type TTextSizeOptions = {
+    width?: number;
+    height?: number;
+    isWordWrapMode?: boolean;
+};
+type TTextComponentOptions = {
+    upscale?: boolean;
+};
+/**
+ * Компонент текст
+ */
+export declare class TextComponent extends AbstractComponent {
+    static defaultStyle: PIXI.TextStyle;
+    protected _text: string;
+    protected _style: TMixedObject | PIXI.TextStyle;
+    protected _styleUpscaleDefault: Record<string, string | number>;
+    protected _label: PIXI.Text;
+    protected _container: PIXI.Container;
+    protected _autopivot: {
+        xPos: number;
+        yPos: number;
+    };
+    protected _maxWidth: number;
+    protected _maxHeight: number;
+    protected _isWordWrapScaleMode: boolean;
+    protected _isUpscaleMode: boolean;
+    /**
+     * Установить текст и отрисовать с новым текстом
+     * @param text
+     */
+    set text(text: string);
+    /**
+     * Получить текущий текст
+     */
+    get text(): string;
+    /** Returns current scale of label */
+    get textScale(): TPixiPoint;
+    /**
+     * @constructor
+     * @param name
+     * @param text
+     * @param style
+     */
+    constructor(name: string, text: string, style?: TMixedObject | PIXI.TextStyle, options?: TTextComponentOptions);
+    /**
+     * Создать компонент
+     * @param instance
+     */
+    create(instance?: TSupportContainer): Promise<this>;
+    /**
+     * Уничтожить компонент
+     */
+    destroy(): Promise<this>;
+    /**
+     * Отрисовать компонент
+     */
+    draw(): Promise<this>;
+    /**
+     * Установить новое число.
+     * Работает как счетчик от текущего значения в текстовом поле до нового.
+     * @param value
+     * @param decimals
+     * @param after
+     */
+    setNumber(value: number, decimals: number, after?: string): Promise<this>;
+    /**
+     * Заменить/добавить часть стилей
+     * @param name
+     * @param value - значение конкретного стиля для подмены
+     */
+    setStyle(name: string, value: string | number): Promise<this>;
+    /**
+     * Полностью заменить все стили
+     * @param styles
+     */
+    setStyles(styles: PIXI.TextStyle): Promise<this>;
+    /**
+     * Установить пивот текста.
+     * Он сохранится и при каждом обновлении текста будет обновляться автоматически.
+     * @param xPos
+     * @param yPos
+     * @deprecated Use `textComponent.setAnchor(0, 0.5)`
+     */
+    setPivot(xPos: number, yPos: number): void;
+    /** Установить anchor текста */
+    setAnchor(x?: number, y?: number): this;
+    /**
+     * Установить ограничения для размера компонента
+     * Одновременная установка width и height возможна только при isWordWrapMode=true
+     * Чтобы работал перенос текста в стили к нему необходимо добавить wordWrap=true
+     */
+    setMaxSize(options?: TTextSizeOptions): void;
+    /** */
+    protected _upscaleProperties(): void;
+    /** */
+    protected _saveUpscaleStyles(style: TMixedObject | PIXI.TextStyle): void;
+}
+export {};

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

@@ -0,0 +1,55 @@
+import { Container } from '../../classes/container.class';
+import { TDeviceOrientationConfig, TPixiTextStyle, TSupportContainer } from '../../extends/short.types';
+import { AbstractComponent } from '../abstract.component';
+import { TextComponent } from '../text.component';
+import { VolatilitySymbolComponent } from './volatility.symbol.component';
+import * as PIXI from 'pixi.js';
+export declare enum EConfigLabelPos {
+    top = "top",
+    bottom = "bottom",
+    right = "right",
+    left = "left"
+}
+export type TAdaptiveSettings = {
+    labelPaddingTop?: number;
+    labelPaddingLeft?: number;
+    labelPosition?: EConfigLabelPos;
+    labelMaxWidth?: number;
+};
+export type TVolatilityConfig = {
+    assetName?: string;
+    emptyTexture?: string;
+    fullTexture?: string;
+    textStyle?: TPixiTextStyle;
+    symbolsMargin?: number;
+    labelPaddingTop?: number;
+    labelPaddingLeft?: number;
+    labelPosition?: EConfigLabelPos;
+    labelMaxWidth?: number;
+    isMaskVertical?: boolean;
+    adaptive?: TDeviceOrientationConfig<TAdaptiveSettings>;
+};
+/** Component displays game volatility by icons */
+export declare class VolatilityComponent extends AbstractComponent {
+    protected _text: string;
+    protected _volatility: number;
+    protected _maxVolatility: number;
+    protected _config: TVolatilityConfig;
+    protected _symbolsContainer: Container;
+    protected _labelComponent: TextComponent;
+    protected _symbols: VolatilitySymbolComponent[];
+    /** returns current adaptive settings */
+    get adaptive(): TAdaptiveSettings;
+    /** @constructor */
+    constructor(_text: string, _volatility: number, _maxVolatility: number, config?: TVolatilityConfig);
+    /** @inheritdoc */
+    create(instance: TSupportContainer): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** Calculate position of label by settings */
+    protected _getLabelPosition(): PIXI.Point;
+    /** @inheritdoc */
+    draw(modeChanged?: boolean): Promise<this>;
+    /** */
+    setLabelMaxWidth(width: number): void;
+}

package/dist/types/src/components/volatility/volatility.symbol.component.d.ts

@@ -0,0 +1,20 @@
+import { TPixiSprite, TSupportContainer } from '../../extends/short.types';
+import { AbstractComponent } from '../abstract.component';
+/** Creates Volatility symbol component */
+export declare class VolatilitySymbolComponent extends AbstractComponent {
+    protected _assetName: string;
+    protected _empty: string;
+    protected _full: string;
+    protected _filling: number;
+    protected _isVertical: boolean;
+    protected _emptySprite: TPixiSprite;
+    protected _fullSprite: TPixiSprite;
+    /** @constructor */
+    constructor(_assetName: string, _empty: string, _full: string, _filling?: number, _isVertical?: boolean);
+    /** @inheritdoc */
+    create(instance: TSupportContainer): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** @inheritdoc */
+    draw(): Promise<this>;
+}

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

@@ -0,0 +1,36 @@
+export declare enum EEventPriority {
+    LOW = 0,
+    MEDIUM = 100,
+    HIGH = 200
+}
+export declare enum EPivot {
+    TOP = 0,
+    BOTTOM = 1,
+    CENTER = 2,
+    LEFT = 3,
+    RIGHT = 4
+}
+export declare enum EAssetType {
+    bitmapfont = 0,
+    dragonbones = 1,
+    sound = 2,
+    spritesheet = 3,
+    texture = 4,
+    webfont = 5,
+    spine = 6
+}
+export declare enum EPromoType {
+    freerounds = "freerounds"
+}
+/**
+ * Заготовки функций плавности
+ */
+export declare enum ease {
+    none = "none",
+    in = "power2.in",
+    out = "power2.out",
+    inOut = "power2.inOut",
+    backOut = "back.out(1.4)",
+    bounceOut = "bounce.out",
+    elasticOut = "elastic.out(1, 0.4)"
+}