@truelab/truengine 0.0.1-0

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

@@ -0,0 +1,30 @@
+import { Sprite } from 'pixi.js';
+import { TPixiTexture, TSupportContainer } from '../../extends/short.types';
+import { AbstractComponent } from '../abstract.component';
+export type TConfigPagination = {
+    assetName: string;
+    textureActive: string;
+    textureOrigin: string;
+    offset: number;
+    pagesAmount: number;
+};
+/** Component pagination for slideshow */
+export declare class SlideshowUiPagination extends AbstractComponent {
+    protected _config: TConfigPagination;
+    protected _buttons: Sprite[];
+    protected _activePagination: number;
+    protected _textureActive: TPixiTexture;
+    protected _textureOrigin: TPixiTexture;
+    /** Gets index active button */
+    get activeButton(): number;
+    /** Sets index of active button */
+    set activeButton(value: number);
+    /** @constructor */
+    constructor(config: TConfigPagination);
+    /** @inheritdoc */
+    create(instance: TSupportContainer): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** @inheritdoc */
+    draw(modeChanged?: boolean): Promise<this>;
+}

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

@@ -0,0 +1,66 @@
+import { BitmapText, TBitmapTextOptions } from '../../../classes/bitmap.text.class';
+import { IComponent } from '../../../extends/interfaces';
+import { TGsapTimeline, TPixiPoint, TSupportContainer } from '../../../extends/short.types';
+import { TPoint } from '../../../extends/struct.types';
+import { AbstractComponent } from '../../abstract.component';
+import { TextComponent } from '../../text.component';
+import * as PIXI from 'pixi.js';
+export type ICoefficientComponent = {
+    total: (coefficient: number) => Promise<void>;
+    line: (coefficient: number, position: number) => Promise<void>;
+    break: () => void;
+} & IComponent;
+export type TConfigCoefficientComponent = {
+    enabled?: boolean;
+    grid?: Map<number, TPixiPoint>;
+    bitmap?: boolean;
+    fastModeTimeScale?: number;
+    total?: {
+        style?: PIXI.TextStyle | TBitmapTextOptions;
+        position?: TPixiPoint;
+        offset?: TPoint;
+        durationDisplay?: number;
+        initial?: gsap.TweenVars;
+        animateShow?: gsap.TweenVars;
+        animateHide?: gsap.TweenVars;
+    };
+    line?: {
+        style?: PIXI.TextStyle | TBitmapTextOptions;
+        position?: TPixiPoint;
+        iReel?: number;
+        offset?: TPoint;
+        durationDisplay?: number;
+        initial?: gsap.TweenVars;
+        animateShow?: gsap.TweenVars;
+        animateHide?: gsap.TweenVars;
+    };
+};
+/** Win coefficient component */
+export declare class FWCoefficientComponent extends AbstractComponent implements ICoefficientComponent {
+    protected _config: TConfigCoefficientComponent;
+    protected _textFont: TextComponent;
+    protected _textBitmap: BitmapText;
+    protected _timeline: TGsapTimeline;
+    /** Gets text object */
+    protected get _text(): TextComponent | BitmapText;
+    /** @constructor */
+    constructor(config: TConfigCoefficientComponent);
+    /** @inheritdoc */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** Sets style */
+    protected setStyle(style: PIXI.TextStyle | TBitmapTextOptions): void;
+    /** Prepares text object to total animation */
+    protected prepareTotal(coefficient: number): void;
+    /** Prepares text object to line animation */
+    protected prepareLine(coefficient: number, position: number): void;
+    /** Animates total coefficient */
+    total(coefficient: number): Promise<void>;
+    /** Animates line coefficient */
+    line(coefficient: number, position: number): Promise<void>;
+    /** Breaks animation */
+    break(): void;
+    /** @inheritdoc */
+    draw(): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+}

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

@@ -0,0 +1,39 @@
+import { Sequence } from '../../../classes/sequence.class';
+import { Spine } from '../../../classes/spine.assets.class';
+import { IComponent } from '../../../extends/interfaces';
+import { TNumberArray, TPixiPoint } from '../../../extends/short.types';
+import { AbstractComponent } from '../../abstract.component';
+export type IFramesComponent = {
+    start: (positions: TNumberArray) => Promise<void>;
+    break: () => void;
+} & IComponent;
+export type TConfigFramesComponent = {
+    enabled?: boolean;
+    grid?: Map<number, TPixiPoint>;
+    assetName?: string;
+    animationName?: string;
+    scale?: number;
+    timeScale?: [number, number];
+};
+/** Frames components */
+export declare abstract class FWFramesComponent extends AbstractComponent {
+    protected _config: TConfigFramesComponent;
+    protected _frames: Map<number, Spine | Sequence>;
+    /** @constructor */
+    constructor(config: TConfigFramesComponent);
+    /** Destroys frames */
+    protected destroyFrames(): void;
+    /** @inheritdoc */
+    draw(): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /**
+     * Animates single frame
+     * Calculates duration
+     */
+    protected animateFrame(_position: number): void;
+    /** Starts animations */
+    abstract start(_positions: TNumberArray): Promise<void>;
+    /** Breaks animations */
+    abstract break(): void;
+}

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

@@ -0,0 +1,17 @@
+import { Sequence } from '../../../classes/sequence.class';
+import { TGsapTimeline, TNumberArray } from '../../../extends/short.types';
+import { FWFramesComponent, IFramesComponent } from './frames.component';
+/** Frames component with sequence animations */
+export declare class FWFramesSequenceComponent extends FWFramesComponent implements IFramesComponent {
+    protected _frames: Map<number, Sequence>;
+    protected _duration: number;
+    protected _breakableSleep: TGsapTimeline;
+    /** Starts frames animations */
+    start(positions: TNumberArray): Promise<void>;
+    /** @inheritdoc */
+    break(): void;
+    /** @inheritdoc */
+    animateFrame(position: number): void;
+    /** Stops animations  */
+    stop(): void;
+}

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

@@ -0,0 +1,21 @@
+import { Spine } from '../../../classes/spine.assets.class';
+import { TNumberArray, TSupportContainer } from '../../../extends/short.types';
+import { FWFramesComponent, IFramesComponent } from './frames.component';
+/** Frames spine component */
+export declare class FWFramesSpineComponent extends FWFramesComponent implements IFramesComponent {
+    protected _spines: Spine[];
+    protected _animation: Spine;
+    protected _durationMS: number;
+    protected _promise: Promise<void>;
+    protected _resolve: CallableFunction;
+    /** @inheritdoc */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** @inheritdoc */
+    start(positions: TNumberArray): Promise<void>;
+    /** */
+    break(): void;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** */
+    protected _destroyAnimations(): void;
+}

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

@@ -0,0 +1,102 @@
+import { IComponent } from '../../../extends/interfaces';
+import { TMixedObject, TNumberArrays, TPixiPoint, TPixiSprite, TPixiTexture, TSupportContainer } from '../../../extends/short.types';
+import { TPoint } from '../../../extends/struct.types';
+import { AbstractComponent } from '../../abstract.component';
+import * as PIXI from 'pixi.js';
+export type IHintsComponent = {
+    open: (iReel: number, iRow: number, code: number) => Promise<void>;
+    close: () => Promise<void>;
+} & IComponent;
+export declare enum EHintPropertyStyle {
+    lengths = "styleLengths",
+    bets = "styleBets",
+    description = "styleDescription"
+}
+export declare enum EHintPropertyPosition {
+    plate = "plate",
+    lengths = "lengths",
+    bets = "bets",
+    description = "description"
+}
+export declare enum EHintSort {
+    asc = 0,
+    desc = 1
+}
+export type THintTransform = {
+    position?: {
+        plate?: TPoint;
+        lengths?: TPoint;
+        bets?: TPoint;
+        description?: TPoint;
+    };
+    styleLengths?: PIXI.TextStyle;
+    styleBets?: PIXI.TextStyle;
+    styleDescription?: PIXI.TextStyle;
+};
+export type TConfigHintsComponent = {
+    enabled?: boolean;
+    grid?: TPixiPoint[][];
+    width?: number;
+    height?: number;
+    shouldReflect?: boolean;
+    events?: boolean;
+    assetsName?: {
+        plate?: string;
+        symbols?: string;
+    };
+    texturesNames?: {
+        plate?: string;
+        symbols?: [number, string][];
+    };
+    textures?: {
+        symbols?: Map<number, TPixiTexture>;
+    };
+    paytable?: TNumberArrays;
+    startLength?: number;
+    numReels?: number;
+    sort?: EHintSort;
+    descriptions?: Map<number, string>;
+    betsSuffix?: string;
+    styleLengths?: TMixedObject;
+    styleBets?: TMixedObject;
+    styleDescription?: TMixedObject;
+    transform?: {
+        left?: THintTransform;
+        right?: THintTransform;
+    };
+    transformSymbols?: {
+        left?: Map<number, THintTransform>;
+        right?: Map<number, THintTransform>;
+    };
+};
+/** Hints component */
+export declare class FWHintsComponent extends AbstractComponent implements IHintsComponent {
+    protected _config: TConfigHintsComponent;
+    protected _hintContainer: PIXI.Container;
+    protected _spritePlate: TPixiSprite;
+    protected _spriteSymbol: TPixiSprite;
+    protected _textLengths: PIXI.Text;
+    protected _textBets: PIXI.Text;
+    protected _textDescription: PIXI.Text;
+    protected _current: {
+        iReel: number;
+        iRow: number;
+        code: number;
+    };
+    /** @constructor */
+    constructor(config: TConfigHintsComponent);
+    /** @inheritdoc */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** @inheritdoc */
+    draw(): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** Opens hint */
+    open(iReel: number, iRow: number, code: number): Promise<void>;
+    /** Get actual property position */
+    protected _getPosition(property: EHintPropertyPosition, iReel: number, code: number): TPoint;
+    /** Get actual property style */
+    protected _getStyle(property: EHintPropertyStyle, iReel: number, code: number): PIXI.TextStyle | TMixedObject;
+    /** Closes hint */
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,41 @@
+import { IComponent } from '../../../extends/interfaces';
+import { TPixiPoint } from '../../../extends/short.types';
+import { TPoint } from '../../../extends/struct.types';
+import { AbstractComponent } from '../../abstract.component';
+export type IIntrigueComponent = {
+    start(reel: number): void;
+    stop(reel?: number): void;
+} & IComponent;
+export type TConfigIntrigueComponent = {
+    enabled?: boolean;
+    enabledFastMode?: boolean;
+    grid?: Map<number, TPixiPoint>;
+    assetName?: string;
+    animationName?: string;
+    scale?: TPoint;
+    offset?: TPoint;
+    durationFadeIn?: [number, number];
+    durationFadeOut?: [number, number];
+    events?: {
+        start?: boolean;
+        stop?: boolean;
+    };
+    motion?: {
+        timeScale?: [number, number];
+        duration?: [number, number];
+        delay?: [number, number];
+        ease?: string;
+    };
+};
+/** Intrigue component */
+export declare abstract class FWIntrigueComponent extends AbstractComponent implements IIntrigueComponent {
+    protected _config: TConfigIntrigueComponent;
+    /** @constructor */
+    constructor(config: TConfigIntrigueComponent);
+    /** @inheritdoc */
+    draw(): Promise<this>;
+    /** Starts intrigue */
+    abstract start(_reel: number): void;
+    /** Stops intrigue */
+    abstract stop(): void;
+}

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

@@ -0,0 +1,18 @@
+import { Spine } from '../../../classes/spine.assets.class';
+import { TGsapTween, TSupportContainer } from '../../../extends/short.types';
+import { FWIntrigueComponent } from './intrigue.component';
+/** Intrigue component with spine animation */
+export declare class FWIntrigueSpineComponent extends FWIntrigueComponent {
+    protected _animation: Spine;
+    protected _tweenFade: TGsapTween;
+    protected _iReel: number;
+    protected _isProcessing: boolean;
+    /** @inheritdoc */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** @inheritdoc */
+    start(iReel: number): Promise<void>;
+    /** @inheritdoc */
+    stop(_iReel?: number): Promise<void>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+}

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

@@ -0,0 +1,29 @@
+import { IComponent } from '../../../extends/interfaces';
+import { TNumberArray, TPixiPoint } from '../../../extends/short.types';
+import { AbstractComponent } from '../../abstract.component';
+import { TLinesStaticConfig } from './lines.static.component';
+export type ILinesComponent = {
+    animate: (line: TNumberArray) => Promise<void>;
+    break: () => void;
+} & IComponent;
+export type TConfigLinesComponent = {
+    enabled?: boolean;
+    grid?: Map<number, TPixiPoint>;
+    frames?: boolean;
+    coefficient?: boolean;
+    static?: TLinesStaticConfig;
+};
+/** Lines component */
+export declare abstract class FWLinesComponent extends AbstractComponent {
+    protected _config: TConfigLinesComponent;
+    /** @constructor */
+    constructor(config: TConfigLinesComponent);
+    /** @inheritdoc */
+    draw(): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** Animates line */
+    animate(_line: TNumberArray): Promise<void>;
+    /** Brakes animation */
+    break(): void;
+}

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

@@ -0,0 +1,38 @@
+import { Container } from '../../../classes/container.class';
+import { TGsapTimeline, TNumberArray, TPixiSprite, TStringArray, TSupportContainer } from '../../../extends/short.types';
+import { TPoint } from '../../../extends/struct.types';
+import { FWLinesComponent } from './lines.component';
+export type TLineSprite = TPixiSprite & {
+    length?: number;
+};
+export type TLinesStaticConfig = {
+    assetName?: string;
+    textures?: TStringArray;
+    numRows?: number;
+    offset?: TPoint;
+    duration?: {
+        display?: number;
+        fadeIn?: number;
+        fadeOut?: number;
+    };
+};
+/** Lines static component */
+export declare class FWLinesStaticComponent extends FWLinesComponent {
+    protected _container: Container;
+    protected _sprites: TLineSprite[][];
+    protected _timeline: TGsapTimeline;
+    /** @inheritdoc */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** Animates line */
+    animate(line: TNumberArray): Promise<void>;
+    /** Returns sprites with calculated angles and positions */
+    protected _getSprites(line: TNumberArray): TLineSprite[];
+    /** Sprite factory method */
+    protected _getSprite(length: number): TPixiSprite;
+    /** Brakes animation */
+    break(): void;
+    /** Gets iRow by position  */
+    getRowByPosition(position: number): number;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+}

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

@@ -0,0 +1,253 @@
+import { Container } from '../../classes/container.class';
+import { IComponent } from '../../extends/interfaces';
+import { TGsapTimeline, TGsapTween, TNumberArray, TNumberArrays, TPixiSprite, TSupportContainer } from '../../extends/short.types';
+import { TSymbolMoveBase } from '../../extends/struct.types';
+import { AbstractComponent } from '../abstract.component';
+import { TConfigIntrigueComponent } from './intrigue/intrigue.component';
+import { ISlotFactory, TSoundEventOptions } from './slot.config';
+import { ISymbolComponent, TConfigSymbolComponent } from './symbol/symbol.component';
+export type IReelComponent = {
+    iReel: number;
+    getSymbols: () => TNumberArray;
+    setSymbols: (codes: TNumberArray) => void;
+    getSymbol: (iRow: number) => ISymbolComponent;
+    getIndexes: () => TNumberArray;
+    getIRowFromIndex: (index: number) => number;
+    start: () => Promise<void>;
+    stop: (stopCodes?: TNumberArray, hasIntrigue?: boolean) => Promise<void>;
+    move: (positions: TSymbolMoveBase[], playingReelIdx?: number) => Promise<void>;
+    refill: (symbolCodes: TNumberArray, positions: TNumberArray, playingIndex?: number, hasIntrigue?: boolean) => Promise<void>;
+    moveAndRefill: (symbolCodes: TNumberArray, positionsIn: TNumberArray, positionsMove: TSymbolMoveBase[], playingReelIdx?: number, hasIntrigue?: boolean) => Promise<void>;
+    break: () => void;
+} & IComponent;
+export declare enum EGameAnimationType {
+    slot = "slot",
+    cascade = "cascade"
+}
+export declare enum EMotionType {
+    clear = "clear",
+    fall = "fall",
+    move = "move",
+    refill = "refill"
+}
+type TSymbolMotionConfig = {
+    type: EMotionType;
+    symbol: ISymbolComponent;
+    toPosition?: number;
+    playingRowIdx?: number;
+    playingReelIdx?: number;
+    relativeDistanceIdx?: number;
+    hasIntrigue?: boolean;
+};
+type TCascadeTimings = {
+    timeScale?: [number, number];
+    distance?: [number, number];
+    duration?: [number, number];
+    enableMotion?: [number, number];
+    disableMotion?: [number, number];
+    reelsDelay?: [number, number];
+    rowsDelay?: [number, number];
+    ease?: gsap.EaseFunction;
+};
+export type TConfigReelComponent = {
+    factory?: ISlotFactory;
+    animationType?: EGameAnimationType;
+    numRows?: number;
+    intrigue?: {
+        onStop?: boolean;
+        onRefill?: boolean;
+        numScattersToStart?: number;
+        numScattersToEnd?: number;
+        scatterCode?: number;
+        reelsIntrigueDelay?: [number, number];
+        rowsIntrigueDelay?: [number, number];
+    };
+    symbolsOrder?: {
+        /** Порядок символов на барабане по умолчанию [0, ..., numRows - 1] */
+        default?: TNumberArray;
+        /** Приоритетные коды символов по возрастанию */
+        top?: TNumberArray;
+    };
+    randomizer?: TNumberArrays;
+    autoStopSymbolsAnimations?: boolean;
+    mask?: {
+        width?: number;
+        height?: number;
+        gradientTop?: number;
+        gradientBottom?: number;
+        offsetTop?: number;
+        offsetBottom?: number;
+    };
+    cascade?: {
+        refillAwaitsMove?: boolean;
+        skipTimeScale?: number;
+        /** с одинаковой ли высоты будут падать символы, или она будет считаться относительно iRow */
+        distanceRelative?: boolean;
+        bySymbols?: {
+            enabled?: boolean;
+            symbolsOrder?: TNumberArray;
+        };
+        byReels?: {
+            reelsOrder?: TNumberArray;
+        };
+        bounce?: {
+            distance?: [number, number];
+            durationDown?: [number, number];
+            durationUp?: [number, number];
+            scaleX?: [number, number];
+            scaleY?: [number, number];
+            easeDown?: string;
+            easeUp?: string;
+        };
+    };
+    timings?: {
+        spin?: {
+            motion?: [number, number];
+            bounceDown?: [number, number];
+            bounceUp?: [number, number];
+        };
+        cascade?: {
+            clear?: TCascadeTimings;
+            fall?: TCascadeTimings;
+            move?: TCascadeTimings;
+            refill?: TCascadeTimings;
+        };
+    };
+    events?: {
+        start?: boolean;
+        stop?: boolean;
+        bounce?: boolean;
+        spawn?: boolean;
+    };
+    bounceOffset?: number;
+    shouldDisplayBounceFakeSymbols?: boolean;
+    components?: {
+        symbol: TConfigSymbolComponent;
+        intrigue?: TConfigIntrigueComponent;
+    };
+    sounds?: {
+        symbolsStop: Map<number, string>;
+    };
+    randomGap?: number;
+};
+/** Reel component */
+export declare class FWReelComponent extends AbstractComponent implements IReelComponent {
+    iReel: number;
+    protected _config: TConfigReelComponent;
+    protected _symbolsContainer: Container;
+    protected _symbols: ISymbolComponent[];
+    protected _mask: TPixiSprite;
+    protected _gridY: TNumberArray;
+    protected _stopCodesInitial: TNumberArray;
+    protected _stopCodesStack: TNumberArray;
+    protected _isMotion: boolean;
+    protected _isStopProcessing: boolean;
+    protected _tlMotion: TGsapTimeline;
+    protected _playingSounds: TSoundEventOptions[];
+    protected _breakableSleep: TGsapTween;
+    protected _tweenTimeScale: TGsapTween;
+    protected _arrExceptions: TNumberArray;
+    /** Gets slot height */
+    get slotHeight(): number;
+    /** @constructor */
+    constructor(iReel: number, config: TConfigReelComponent);
+    /** @inheritdoc */
+    create(instance?: TSupportContainer): Promise<this>;
+    /** Получить коды символов */
+    getSymbols(): TNumberArray;
+    /**
+     * Задать символы на барабане
+     *
+     * - Чистим текущие анимации
+     * - По умолчанию ставим рандомные символы
+     * - Запуск idle анимаций, если они есть
+     */
+    setSymbols(codes?: TNumberArray): Promise<this>;
+    /** Запустить анимацию символа при остановке барабана, если анимация указана в конфиге */
+    animateSymbolsOnStop(): void;
+    /** Найти и запустить звук для старшего символа при остановке барабанаб если звук указан в конфиге */
+    playSoundsOnStop(stopCodes: TNumberArray): void;
+    /** Останавить все звуки, которые были запущены в компоненте барабана */
+    stopSounds(): void;
+    /** @inheritdoc */
+    draw(): Promise<this>;
+    /** @inheritdoc */
+    destroy(): Promise<this>;
+    /** Starts motion */
+    start(): Promise<void>;
+    /** */
+    protected _beforeStart(): Promise<void>;
+    /** */
+    protected _beforeStop(): Promise<void>;
+    /** */
+    protected _resetTl(): void;
+    /** */
+    protected _animateStart(): Promise<void>;
+    /** Stops motion */
+    stop(symbolsCodes?: TNumberArray, hasIntrigue?: boolean): Promise<void>;
+    /** */
+    protected _animateStopSpin(stopCodes?: TNumberArray, hasIntrigue?: boolean): Promise<void>;
+    /** Breaks everything for stop */
+    break(): void;
+    /** Animates motion */
+    protected _animateStartSpin(): Promise<void>;
+    /** Adds single symbol movement to motion timeline */
+    protected addMotion(): void;
+    /** Animates bounce */
+    protected animateBounce(): Promise<void>;
+    /**
+     * Resets reel's position
+     * Respawn lowest symbol
+     * Reorders symbols
+     */
+    protected spawn(isMotion: boolean): number;
+    /**  */
+    reposition(): Promise<void>;
+    /** Animates intrigue */
+    animateIntrigue(): Promise<void>;
+    /** Gets symbol component */
+    getSymbol(iRow: number): ISymbolComponent;
+    /** Gets symbols indexes */
+    getIndexes(): TNumberArray;
+    /** */
+    getIRowFromIndex(index: number): number;
+    /** Sets motion timescale */
+    setTimeScale(value: number, vars?: gsap.TweenVars): Promise<void>;
+    /**
+     * For stop Symbols take into account the controlled randomness
+     */
+    animateMotionExceptions(stopCodes: TNumberArray): Promise<void>;
+    /**
+     * Gets random symbol code for this reel
+     * the symbols must not be repeated within the other two symbols on the reel
+     */
+    protected getRandomSymbolCode(): number;
+    /**
+     * adding a symbol to the exceptions to validate for the next symbol
+     */
+    protected writeException(symbol: number): void;
+    /** Cascade start animation */
+    protected _animateStartCascade(): Promise<void>;
+    /** Cascade start animation */
+    protected _animateStopCascade(symbolCodes?: TNumberArray, hasIntrigue?: boolean): Promise<void>;
+    /** */
+    moveAndRefill(symbolCodes: TNumberArray, positionsIn: TNumberArray, positionsMove?: TSymbolMoveBase[], playingReelIdx?: number, hasIntrigue?: boolean): Promise<void>;
+    /** */
+    move(positions: TSymbolMoveBase[], playingReelIdx?: number): Promise<void>;
+    /** */
+    refill(symbolCodes: TNumberArray, positions: TNumberArray, playingReelIdx?: number, hasIntrigue?: boolean): Promise<void>;
+    /** Main func for cascade symbols animation, includes:
+     * 1. intrigue delay
+     * 2. resets symbol position for drop if needed
+     * 3. main motion to the given Y position, use _motionStarted and _motionCompleted funcs if it necessary to add some logic at the start or at the finish of the motion animation
+     * 4. switching motion textures while moving
+     * 5. stop(drop) animation after finishing main move animation, uses the same func as spin stop anim
+     * 6. bounce anim at the end
+     */
+    protected _animateMotion(config: TSymbolMotionConfig): Promise<void>;
+    /** optional actions before base move animation */
+    protected _motionStarted(_type: EMotionType, _symbol: ISymbolComponent): void;
+    /** optional actions after base move animation, don't includes time for bounce */
+    protected _motionCompleted(_type: EMotionType, _symbol: ISymbolComponent): void;
+}
+export {};