evotars/dist/index.d.ts

Show animated characters on stream

import { AnimatedSprite } from 'pixi.js';
import * as PIXI from 'pixi.js';
import { SpritesheetData as SpritesheetData_2 } from 'pixi.js';
import { SpritesheetFrameData as SpritesheetFrameData_2 } from 'pixi.js';
import * as TWEEN from '@tweenjs/tween.js';

export declare type ActionableData = {
    arguments: string[];
    action: ActionData;
};

export declare type ActionData = Record<string, string | number | undefined>;

export declare type ActionEntity = {
    id: number;
    name: string;
    title: string;
    description: string;
    data: ActionData;
};

export declare type AddJumpHitsUserActionEntity = {
    name: 'add_jump_hits';
    data: {
        count: number;
    };
} & UserActionEntity;

declare type AppOptions = {
    font?: string;
    sounds?: SoundOptions;
    assets: AssetsOptions;
    spriteLoaderFn: SpriteLoaderFn;
};

declare type AssetsOptions = {
    poof: string;
    rip1: string;
    rip2: string;
    skull: string;
    weight: string;
};

declare type Collider = {
    x: number;
    y: number;
    w: number;
    h: number;
};

export declare type ColorUserActionEntity = {
    name: 'color';
    data: {
        color: string;
    };
} & UserActionEntity;

export declare type DashUserActionEntity = {
    name: 'dash';
    data: {
        force: number;
    };
} & UserActionEntity;

declare class Evotar {
    container: PIXI.Container;
    private userState;
    state: EvotarState;
    private animationState;
    private sprite?;
    trail: EvotarTrailEffect;
    private name;
    private info;
    private message;
    private emoteSpitter;
    private velocity;
    private runSpeed;
    private gravity;
    private dashAcc;
    private isJumping;
    private isHitJumping;
    private isDashing;
    private isDespawned;
    isDead: boolean;
    deathTimer?: Timer;
    landTimer?: Timer;
    stateTimer?: Timer;
    scaleTimer?: Timer;
    spawnTween?: TWEEN.Tween<PIXI.Container>;
    fadeTween?: TWEEN.Tween<PIXI.Container>;
    scaleTween?: TWEEN.Tween<Evotar>;
    private offset;
    get screenBounds(): {
        left: number;
        right: number;
    };
    getCenterOffsetY(): number;
    getCenterPosition(): PIXI.PointData;
    setPosition(position: PIXI.PointData): void;
    getScale(): number;
    getCollider(): Collider;
    constructor();
    resurrect(): Promise<void>;
    die(): Promise<void>;
    spawn(props?: EvotarSpawnProps): void;
    despawn(props?: EvotarDepawnProps): void;
    scale(options: {
        value: number;
        duration: number;
    }): void;
    addJumpHit(count: number): void;
    canDoAction(): boolean;
    jump(options?: EvotarJumpProps): Promise<void>;
    dash(options: {
        force: number;
    }): void;
    setSprite(sprite: string): Promise<void>;
    setProps(props: EvotarProps): Promise<void>;
    setUserProps(props: UserProps): void;
    private move;
    jumpHit(): void;
    update(): void;
    isOnGround(y: number): boolean;
    addMessage(message: string): void;
    spitEmotes(emotes: string[]): Promise<void>;
    setAnimationState(state: EvotarSpriteTags, force?: boolean): Promise<void>;
}

declare type EvotarAnimatedSprites = {
    [tag in string]: EvotarLayerSprites;
};

declare type EvotarDepawnProps = {
    onComplete?: () => void;
};

declare type EvotarJumpProps = {
    velocityX?: number;
    velocityY?: number;
};

declare type EvotarLayerSprites = {
    [layer in string]: AnimatedSprite;
};

declare type EvotarProps = {
    name?: string;
    sprite?: string;
    color?: PIXI.Color;
    direction?: number;
    scale?: number;
    isAnonymous?: boolean;
    isImmortal?: boolean;
    zIndex?: number;
};

export declare class Evotars {
    private readonly root;
    private readonly options;
    private isRendered;
    constructor(root: HTMLElement, options: AppOptions);
    processMessage: (data: MessageEntity) => Promise<void>;
    processAction: (data: UserActionEntity) => Promise<void>;
    processChatters: (data: TwitchChatterEntity[]) => Promise<void>;
    processRaid: (data: RaidEntity) => Promise<void>;
    get manager(): {
        viewers: Record<string, Evotar | undefined>;
        viewerArray: string[];
        tombstones: TombStone[];
        raiders: Evotar[];
        recentEvotarActivity: Record<string, number | undefined>;
        subscriptions: {
            onAdd: (evotar: Evotar) => void;
            onDelete: (evotar: Evotar) => void;
        }[];
        subscribe(subscription: {
            onAdd: (evotar: Evotar) => void;
            onDelete: (evotar: Evotar) => void;
        }): void;
        update(): void;
        getEvotars(): (Evotar | undefined)[];
        spawnViewerEvotar(userId: string, props: EvotarProps, spawnProps: EvotarSpawnProps): Promise<Evotar>;
        processRaid(data: RaidEntity): Promise<void>;
        despawnTombStone(evotar: Evotar): void;
        despawnRaider(evotar: Evotar): void;
        despawnViewer(id: string, evotar: Evotar): void;
        processChatters(data: TwitchChatterEntity[]): Promise<void>;
        hasActivity: (userId: string) => boolean;
        doAction(action: UserActionEntity, evotar: Evotar): void;
        prepareEvotarProps(name: string, color?: string | undefined, sprite?: string | undefined): EvotarProps;
        processAction(action: UserActionEntity): Promise<void>;
        processMessage(data: MessageEntity): Promise<void>;
        resurrect(evotar: Evotar): void;
        kill(evotar: Evotar): void;
        addTombStone(object: TombStone): void;
        deleteTombStone(object: TombStone): void;
        addViewer(id: string, evotar: Evotar): void;
        deleteViewer(id: string, evotar: Evotar): void;
        addRaider(evotar: Evotar): void;
        deleteRaider(evotar: Evotar): void;
        zIndexEvotarMax(from: number): number;
        zIndexEvotarMin(from: number): number;
    };
    updateSettings(data: SettingsEntity): void;
    run(): Promise<void>;
}

declare type EvotarSpawnProps = {
    isFalling?: boolean;
    positionX?: number;
    onComplete?: () => void;
};

declare class EvotarSpriteContainer {
    private sprites;
    data: EvotarSpriteData;
    container: PIXI.Container;
    private currentTag;
    constructor(sprites: EvotarAnimatedSprites, data: EvotarSpriteData);
    getLayersByTag(tag: EvotarSpriteTags): EvotarLayerSprites;
    setTag(tag?: EvotarSpriteTags): void;
    update(props: EvotarSpriteContainerProps): void;
}

declare type EvotarSpriteContainerProps = {
    color: {
        [key in string]?: PIXI.Color;
    };
    scale: Point;
    play: boolean;
};

declare type EvotarSpriteData = {
    name: string;
    collider: Collider;
    size: SpriteSize;
    scale: number;
    flip: boolean;
    colored: string[];
};

declare enum EvotarSpriteTags {
    Idle = "Idle",
    Jump = "Jump",
    Fall = "Fall",
    Land = "Land",
    Run = "Run",
    Die = "Die"
}

declare type EvotarState = Required<EvotarProps>;

declare class EvotarTrailEffect {
    container: PIXI.Container;
    private timer?;
    private sprite?;
    private opacityStep;
    private shadowStep;
    constructor();
    setSprite(sprite: EvotarSpriteContainer): void;
    update(props: EvotarTrailEffectProps): void;
}

declare type EvotarTrailEffectProps = {
    play: boolean;
};

export declare type GrowUserActionEntity = {
    name: 'grow';
    data: {
        duration: number;
        scale: number;
    };
} & UserActionEntity;

export declare const isAddJumpHitsUserActionEntity: (entity: ActionEntity) => entity is AddJumpHitsUserActionEntity;

export declare const isColorUserActionEntity: (entity: ActionEntity) => entity is ColorUserActionEntity;

export declare const isDashUserActionEntity: (entity: ActionEntity) => entity is DashUserActionEntity;

export declare const isGrowUserActionEntity: (entity: ActionEntity) => entity is GrowUserActionEntity;

export declare const isJumpUserActionEntity: (entity: ActionEntity) => entity is JumpUserActionEntity;

export declare const isResurrectUserActionEntity: (entity: ActionEntity) => entity is ResurrectUserActionEntity;

export declare const isSpriteUserActionEntity: (entity: ActionEntity) => entity is SpriteUserActionEntity;

export declare type JumpUserActionEntity = {
    name: 'jump';
    data: {
        velocityX: number;
        velocityY: number;
    };
} & UserActionEntity;

export declare type MessageEntity = {
    userId: string;
    message: string;
    emotes: string[];
    info: UserInfo;
};

declare type Point = {
    x?: number;
    y?: number;
};

export declare type RaidEntity = {
    broadcaster: {
        id: string;
        info: UserInfo;
    };
    viewers: {
        count: number;
        sprite: string;
    };
};

export declare type ResurrectUserActionEntity = {
    name: 'resurrect';
    data: {};
} & UserActionEntity;

export declare type SettingsEntity = {
    showAnonymousEvotars?: boolean;
    fallingEvotars?: boolean;
    fallingRaiders?: boolean;
    maxEvotars?: number;
};

declare type SoundOptions = {
    jump?: {
        src: string;
    };
};

declare type SpriteLoaderFn = (name: string) => Promise<{
    sprite: SpritesheetData;
    data: EvotarSpriteData;
    image: string;
} | undefined>;

declare interface SpritesheetData extends SpritesheetData_2 {
    frames: Record<string, SpritesheetFrameData>;
}

declare interface SpritesheetFrameData extends SpritesheetFrameData_2 {
    duration: number;
}

declare type SpriteSize = {
    w: number;
    h: number;
};

export declare type SpriteUserActionEntity = {
    name: 'sprite';
    data: {
        sprite: string;
    };
} & UserActionEntity;

declare class Timer {
    current: number;
    private onComplete?;
    isCompleted: boolean;
    constructor(current?: number, onComplete?: (() => void) | undefined);
    tick(delta?: number): void;
    complete(): void;
}

declare class TombStone {
    readonly evotar: Evotar;
    container: PIXI.Container;
    private sprite;
    private gravity;
    private velocity;
    fadeTween?: TWEEN.Tween<PIXI.Container>;
    constructor(evotar: Evotar);
    isOnGround(y: number): boolean;
    update(): void;
    despawn(smooth?: boolean, onComplete?: () => void): void;
    spawn(): void;
}

export declare type TwitchChatterEntity = {
    userId: string;
    name: string;
};

export declare type UserActionEntity = {
    userId: string;
    info: UserInfo;
} & ActionEntity;

export declare type UserEntity = {
    userId: number;
    guid: string;
    displayName: string;
    profileImageUrl: string;
    previewUrl: string;
};

export declare type UserInfo = {
    displayName: string;
    sprite: string;
    color?: string;
};

declare type UserProps = {
    color?: PIXI.Color;
};

export { }