evotars 0.0.11 → 0.0.13

package/dist/index.d.ts

@@ -1,5 +1,8 @@
-import { ISpritesheetData } from 'pixi.js';
-import { ISpritesheetFrameData } from 'pixi.js';
+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[];
@@ -16,6 +19,13 @@ export declare type ActionEntity = {
     data: ActionData;
 };
 
+export declare type AddJumpHitsUserActionEntity = {
+    name: 'add_jump_hits';
+    data: {
+        count: number;
+    };
+} & UserActionEntity;
+
 declare type AppOptions = {
     font?: string;
     sounds?: SoundOptions;
@@ -43,6 +53,94 @@ export declare type DashUserActionEntity = {
     };
 } & 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;
+    private screenBounds;
+    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;
+    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;
@@ -52,10 +150,72 @@ export declare class Evotars {
     processAction: (data: UserActionEntity) => Promise<void>;
     processChatters: (data: TwitchChatterEntity[]) => Promise<void>;
     processRaid: (data: RaidEntity) => void;
+    get manager(): {
+        viewers: Record<string, Evotar | undefined>;
+        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;
+        getViewerEvotars(): Record<string, Evotar | undefined>;
+        getViewerEvotar(id: number): Evotar | undefined;
+        spawnViewerEvotar(userId: string, props: EvotarProps, spawnProps: EvotarSpawnProps): Promise<Evotar>;
+        processRaid(data: RaidEntity): void;
+        despawnEvotar(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>;
+        getViewerId(evotar: Evotar): string | undefined;
+        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;
@@ -65,6 +225,32 @@ declare type EvotarSpriteData = {
     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: {
@@ -73,6 +259,8 @@ export declare type GrowUserActionEntity = {
     };
 } & 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;
@@ -81,6 +269,8 @@ export declare const isGrowUserActionEntity: (entity: ActionEntity) => entity is
 
 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 = {
@@ -98,6 +288,11 @@ export declare type MessageEntity = {
     info: UserInfo;
 };
 
+declare type Point = {
+    x?: number;
+    y?: number;
+};
+
 export declare type RaidEntity = {
     broadcaster: {
         id: string;
@@ -109,6 +304,11 @@ export declare type RaidEntity = {
     };
 };
 
+export declare type ResurrectUserActionEntity = {
+    name: 'resurrect';
+    data: {};
+} & UserActionEntity;
+
 export declare type SettingsEntity = {
     showAnonymousEvotars?: boolean;
     fallingEvotars?: boolean;
@@ -127,11 +327,11 @@ declare type SpriteLoaderFn = (name: string) => Promise<{
     image: string;
 } | undefined>;
 
-declare interface SpritesheetData extends ISpritesheetData {
+declare interface SpritesheetData extends SpritesheetData_2 {
     frames: Record<string, SpritesheetFrameData>;
 }
 
-declare interface SpritesheetFrameData extends ISpritesheetFrameData {
+declare interface SpritesheetFrameData extends SpritesheetFrameData_2 {
     duration: number;
 }
 
@@ -147,6 +347,34 @@ export declare type SpriteUserActionEntity = {
     };
 } & 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 id: string;
+    container: PIXI.Container;
+    private sprite;
+    private gravity;
+    private velocity;
+    fadeTween?: TWEEN.Tween<PIXI.Container>;
+    constructor(id: string);
+    isOnGround(y: number): boolean;
+    update(): void;
+    despawn(smooth?: boolean, onComplete?: () => void): void;
+    spawn(props: TombStoneProps): void;
+}
+
+declare type TombStoneProps = {
+    position: Point;
+    scale: number;
+};
+
 export declare type TwitchChatterEntity = {
     userId: string;
     name: string;
@@ -154,7 +382,6 @@ export declare type TwitchChatterEntity = {
 
 export declare type UserActionEntity = {
     userId: string;
-    cooldown: number;
     info: UserInfo;
 } & ActionEntity;
 
@@ -172,4 +399,8 @@ export declare type UserInfo = {
     color?: string;
 };
 
+declare type UserProps = {
+    color?: PIXI.Color;
+};
+
 export { }