evotars 0.0.12 → 0.0.14

package/dist/index.d.ts

@@ -1,5 +1,8 @@
+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;
@@ -29,6 +39,13 @@ declare type Collider = {
     h: number;
 };
 
+export declare type ColorUserActionEntity = {
+    name: 'color';
+    data: {
+        color: string;
+    };
+} & UserActionEntity;
+
 export declare type DashUserActionEntity = {
     name: 'dash';
     data: {
@@ -36,6 +53,95 @@ 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;
+    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;
@@ -44,11 +150,73 @@ export declare class Evotars {
     processMessage: (data: MessageEntity) => Promise<void>;
     processAction: (data: UserActionEntity) => Promise<void>;
     processChatters: (data: TwitchChatterEntity[]) => Promise<void>;
-    processRaid: (data: RaidEntity) => void;
+    processRaid: (data: RaidEntity) => Promise<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;
+        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;
@@ -58,6 +226,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: {
@@ -66,18 +260,20 @@ export declare type GrowUserActionEntity = {
     };
 } & UserActionEntity;
 
-export declare type InfoUserActionEntity = {
-    name: 'info';
-} & 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 isInfoUserActionEntity: (entity: ActionEntity) => entity is InfoUserActionEntity;
-
 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: {
@@ -93,6 +289,11 @@ export declare type MessageEntity = {
     info: UserInfo;
 };
 
+declare type Point = {
+    x?: number;
+    y?: number;
+};
+
 export declare type RaidEntity = {
     broadcaster: {
         id: string;
@@ -104,6 +305,11 @@ export declare type RaidEntity = {
     };
 };
 
+export declare type ResurrectUserActionEntity = {
+    name: 'resurrect';
+    data: {};
+} & UserActionEntity;
+
 export declare type SettingsEntity = {
     showAnonymousEvotars?: boolean;
     fallingEvotars?: boolean;
@@ -135,6 +341,36 @@ declare type SpriteSize = {
     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;
@@ -142,7 +378,6 @@ export declare type TwitchChatterEntity = {
 
 export declare type UserActionEntity = {
     userId: string;
-    cooldown: number;
     info: UserInfo;
 } & ActionEntity;
 
@@ -160,4 +395,8 @@ export declare type UserInfo = {
     color?: string;
 };
 
+declare type UserProps = {
+    color?: PIXI.Color;
+};
+
 export { }

package/dist/{webworkerAll-Bg_9Ksbn.js → webworkerAll-DHxhFvSG.js}

@@ -1,7 +1,7 @@
-import { E as b, U as pt, T as pe, O as q, M as U, N as Fe, c as Me, w as L, j as R, P as gt, t as Re, K as k, L as H, b as Q, B as D, I, Q as mt, V as xt, a as _t, W as re, X as z, R as V, Y as bt, Z as M, _ as E, $ as yt, q as B, a0 as Tt, D as $, a1 as wt, a2 as Z, a3 as vt, m as St, a4 as Ct, a5 as se, n as ge, e as P, a6 as Bt } from "./index-B5GUB2He.js";
-import { U as Y, T as A, R as ne, S as Ae, i as ae, b as ke, c as Ue, j as Ge, e as Pt, r as ze, o as Ft, n as He, a as Mt, g as Rt, k as At, m as kt, B as Ie } from "./colorToUniform-Cp4M-zOy.js";
-import { C as W } from "./CanvasPool-5ekdWScU.js";
-import { g as Ut } from "./getBatchSamplersUniformGroup-CIYh8OT7.js";
+import { E as b, U as pt, T as pe, O as q, M as U, N as Fe, c as Me, w as L, j as R, P as gt, t as Re, K as k, L as H, b as Q, B as D, I, Q as mt, V as xt, a as _t, W as re, X as z, R as V, Y as bt, Z as M, _ as E, $ as yt, q as B, a0 as Tt, D as $, a1 as wt, a2 as Z, a3 as vt, m as St, a4 as Ct, a5 as se, n as ge, e as P, a6 as Bt } from "./index-B90O-olH.js";
+import { U as Y, T as A, R as ne, S as Ae, i as ae, b as ke, c as Ue, j as Ge, e as Pt, r as ze, o as Ft, n as He, a as Mt, g as Rt, k as At, m as kt, B as Ie } from "./colorToUniform-B386n34M.js";
+import { C as W } from "./CanvasPool-CVUDTUp2.js";
+import { g as Ut } from "./getBatchSamplersUniformGroup-DAYmfPu3.js";
 class We {
   /**
    * Initialize the plugin with scope of application instance

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.12",
+  "version": "0.0.14",
   "name": "evotars",
   "description": "Show animated characters on stream",
   "author": "Mikhail Morozov",