evotars 0.0.7 → 0.0.9

package/src/services/spriteService.ts

@@ -0,0 +1,167 @@
+import {
+  AnimatedSprite,
+  Assets,
+  ISpritesheetData,
+  ISpritesheetFrameData,
+  SCALE_MODES,
+  Spritesheet,
+} from 'pixi.js';
+
+export type EvotarSpriteData = {
+  name: string;
+  collider: Collider;
+  size: SpriteSize;
+  scale: number;
+  flip: boolean;
+  colored: string[];
+};
+
+export type SpriteLoaderFn = (name: string) => Promise<
+  | {
+      sprite: SpritesheetData;
+      data: EvotarSpriteData;
+      image: string;
+    }
+  | undefined
+>;
+
+export type Collider = {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+};
+
+export interface SpritesheetFrameData extends ISpritesheetFrameData {
+  duration: number;
+}
+
+export interface SpritesheetData extends ISpritesheetData {
+  frames: Record<string, SpritesheetFrameData>;
+}
+
+export type EvotarLayerSprites = {
+  [layer in string]: AnimatedSprite;
+};
+
+export type EvotarAnimatedSprites = {
+  [tag in string]: EvotarLayerSprites;
+};
+
+export enum EvotarSpriteTags {
+  Idle = 'Idle',
+  Jump = 'Jump',
+  Fall = 'Fall',
+  Land = 'Land',
+  Run = 'Run',
+  Die = 'Die',
+}
+
+export type FrameTag = {
+  from: number;
+  name: string;
+  to: number;
+  direction: string;
+};
+
+export type SpriteSize = {
+  w: number;
+  h: number;
+};
+
+export type SpriteData = {
+  sheet: Spritesheet<SpritesheetData>;
+  data: EvotarSpriteData;
+};
+
+export class SpriteService {
+  private spriteLoaderFn!: SpriteLoaderFn;
+
+  private sprites: Record<string, SpriteData> = {};
+
+  public initialize(spriteLoaderFn: SpriteLoaderFn) {
+    this.spriteLoaderFn = spriteLoaderFn;
+  }
+
+  public async getSpriteData(name: string): Promise<SpriteData | undefined> {
+    const sprite = await this.spriteLoaderFn(name);
+
+    if (!sprite) {
+      return;
+    }
+
+    if (this.sprites[name]) {
+      return this.sprites[name];
+    }
+
+    const texture = await Assets.load(sprite.image);
+
+    const sheet = new Spritesheet({
+      texture,
+      data: sprite.sprite,
+    });
+
+    await sheet.parse();
+
+    this.sprites[name] = {
+      sheet,
+      data: {
+        ...sprite.data,
+        scale: sprite.data.scale ?? 1,
+      },
+    };
+
+    return this.sprites[name];
+  }
+
+  public getAnimatedSprites(name: string): EvotarAnimatedSprites {
+    if (!name) {
+      throw Error('Sheet is not defined');
+    }
+
+    if (!this.sprites[name]) {
+      throw Error('Sprite is not loaded');
+    }
+
+    const data = this.sprites[name].data;
+    const sheet = this.sprites[name].sheet;
+
+    const sprites: EvotarAnimatedSprites = {};
+
+    for (const frameTag of sheet.data.meta.frameTags ?? []) {
+      if (!sheet.data.meta.layers) {
+        throw Error('Layers are not defined');
+      }
+
+      const layers: EvotarLayerSprites = {};
+
+      for (const layer of sheet.data.meta.layers) {
+        const textures = [];
+
+        for (let i = frameTag.from; i <= frameTag.to; i++) {
+          const framekey = i.toString();
+
+          const key = data.name + '_' + layer.name + '_' + framekey;
+          const texture = sheet.textures[key];
+          const time = sheet.data.frames[key].duration;
+
+          textures.push({ texture: texture, time: time });
+        }
+
+        const sprite = new AnimatedSprite(textures);
+
+        sprite.texture.baseTexture.scaleMode = SCALE_MODES.NEAREST;
+
+        layers[layer.name] = sprite;
+      }
+
+      if (frameTag.name) {
+        sprites[frameTag.name] = layers;
+      }
+    }
+
+    return sprites;
+  }
+}
+
+export const spriteService = new SpriteService();

package/src/types/dto/action.ts

@@ -0,0 +1,79 @@
+import { UserInfo } from './user';
+
+export type ActionData = Record<string, string | number | undefined>;
+
+export type ActionableData = {
+  arguments: string[];
+  action: ActionData;
+};
+
+export type ActionEntity = {
+  id: number;
+  name: string;
+  title: string;
+  description: string;
+  data: ActionData;
+};
+
+export type UserActionEntity = {
+  userId: string;
+  cooldown: number;
+  info: UserInfo;
+} & ActionEntity;
+
+export type JumpUserActionEntity = {
+  name: 'jump';
+  data: {
+    velocityX: number;
+    velocityY: number;
+  };
+} & UserActionEntity;
+
+export type ColorUserActionEntity = {
+  name: 'color';
+  data: {
+    color: string;
+  };
+} & UserActionEntity;
+
+export type GrowUserActionEntity = {
+  name: 'grow';
+  data: {
+    duration: number;
+    scale: number;
+  };
+} & UserActionEntity;
+
+export type DashUserActionEntity = {
+  name: 'dash';
+  data: {
+    force: number;
+  };
+} & UserActionEntity;
+
+export type SpriteUserActionEntity = {
+  name: 'sprite';
+  data: {
+    sprite: string;
+  };
+} & UserActionEntity;
+
+export const isJumpUserActionEntity = (
+  entity: ActionEntity,
+): entity is JumpUserActionEntity => entity.name == 'jump';
+
+export const isColorUserActionEntity = (
+  entity: ActionEntity,
+): entity is ColorUserActionEntity => entity.name == 'color';
+
+export const isGrowUserActionEntity = (
+  entity: ActionEntity,
+): entity is GrowUserActionEntity => entity.name == 'grow';
+
+export const isDashUserActionEntity = (
+  entity: ActionEntity,
+): entity is DashUserActionEntity => entity.name == 'dash';
+
+export const isSpriteUserActionEntity = (
+  entity: ActionEntity,
+): entity is SpriteUserActionEntity => entity.name == 'sprite';

package/{dist/types/dto/chatter.d.ts → src/types/dto/chatter.ts}

@@ -1,4 +1,4 @@
 export type TwitchChatterEntity = {
-    userId: string;
-    name: string;
+  userId: string;
+  name: string;
 };

package/src/types/dto/event.ts

@@ -0,0 +1,9 @@
+import { UserInfo } from './user';
+
+export type RaidData = {
+  broadcaster: {
+    id: string;
+    info: UserInfo;
+  };
+  viewers: number;
+};

package/src/types/dto/message.ts

@@ -0,0 +1,8 @@
+import { UserInfo } from './user';
+
+export type MessageEntity = {
+  userId: string;
+  message: string;
+  emotes: string[];
+  info: UserInfo;
+};

package/src/types/dto/settings.ts

@@ -0,0 +1,5 @@
+export type SettingsEntity = {
+  showAnonymousEvotars?: boolean;
+  fallingEvotars?: boolean;
+  fallingRaiders?: boolean;
+};

package/src/types/dto/user.ts

@@ -0,0 +1,13 @@
+export type UserEntity = {
+  userId: number;
+  guid: string;
+  displayName: string;
+  profileImageUrl: string;
+  previewUrl: string;
+};
+
+export type UserInfo = {
+  displayName: string;
+  color?: string;
+  sprite?: string;
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable", "ES2021.String"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"]
+}

package/vite.config.js

@@ -0,0 +1,26 @@
+import { resolve } from 'path';
+import { defineConfig } from 'vite';
+import dts from 'vite-plugin-dts';
+import pkg from './package.json' assert { type: 'json' };
+
+export default defineConfig({
+  plugins: [dts()],
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'src/index.ts'),
+      name: 'evotars',
+      fileName: 'evotars',
+    },
+    copyPublicDir: false,
+    rollupOptions: {
+      external: [...Object.keys(pkg.dependencies)],
+      output: {
+        globals: {
+          'pixi.js': 'PIXI',
+          tinycolor2: 'tinycolor',
+          '@tweenjs/tween.js': 'TWEEN',
+        },
+      },
+    },
+  },
+});

package/dist/app.d.ts

@@ -1,24 +0,0 @@
-import { SpriteLoaderFn } from './services/spriteService';
-import { SettingsEntity } from './types';
-import { SoundOptions } from './services/soundService';
-import { Evotar } from './entities/Evotar';
-import * as PIXI from 'pixi.js';
-export type AppOptions = {
-    font?: {
-        name: string;
-        src?: string;
-    };
-    sounds?: SoundOptions;
-    spriteLoaderFn: SpriteLoaderFn;
-};
-export declare class App {
-    stage: PIXI.Container;
-    evotars: Record<string, Evotar>;
-    chatterIds: string[];
-    settings: SettingsEntity;
-    renderer: PIXI.Renderer;
-    initialize(element: HTMLElement, options: AppOptions): Promise<void>;
-    updateSettings(data: SettingsEntity): void;
-    update(): void;
-}
-export declare const app: App;

package/dist/config/constants.d.ts

@@ -1 +0,0 @@
-export declare const FIXED_DELTA_TIME: number;

package/dist/entities/EmoteSpitter.d.ts

@@ -1,15 +0,0 @@
-import { Point } from '../helpers/types';
-import * as PIXI from 'pixi.js';
-export type EvotarEmoteSpitterProps = {
-    position: Point;
-};
-export declare class EvotarEmoteSpitter {
-    container: PIXI.Container;
-    private emotes;
-    private moveSpeed;
-    private alphaSpeed;
-    private scaleSpeed;
-    private timer?;
-    add(url: string): void;
-    update(props: EvotarEmoteSpitterProps): void;
-}

package/dist/entities/Evotar.d.ts

@@ -1,78 +0,0 @@
-import { EvotarTrailEffect } from './TrailEffect';
-import { EvotarSpriteTags } from '../services/spriteService';
-import { Timer } from '../helpers/timer';
-import * as TWEEN from '@tweenjs/tween.js';
-import * as PIXI from 'pixi.js';
-export type EvotarProps = {
-    name?: string;
-    sprite?: string;
-    color?: PIXI.Color;
-    direction?: number;
-    scale?: number;
-    isAnonymous?: boolean;
-    zIndex?: number;
-};
-export type EvotarSpawnProps = {
-    isFalling?: boolean;
-    positionX?: number;
-    onComplete?: () => void;
-};
-export type EvotarDepawnProps = {
-    onComplete?: () => void;
-};
-type UserProps = {
-    color?: PIXI.Color;
-};
-export declare class Evotar {
-    container: PIXI.Container;
-    private userState;
-    private state;
-    private animationState;
-    private sprite?;
-    private spriteData;
-    private animatedSprites?;
-    trail: EvotarTrailEffect;
-    private name;
-    private message;
-    private emoteSpitter;
-    private velocity;
-    private runSpeed;
-    private gravity;
-    private dashAcc;
-    private isJumping;
-    private isDashing;
-    private isDespawned;
-    landTimer?: Timer;
-    stateTimer?: Timer;
-    scaleTimer?: Timer;
-    spawnTween?: TWEEN.Tween<PIXI.Container>;
-    fadeTween?: TWEEN.Tween<PIXI.Container>;
-    scaleTween?: TWEEN.Tween<Evotar>;
-    constructor();
-    spawn(props?: EvotarSpawnProps): void;
-    despawn(props?: EvotarDepawnProps): void;
-    scale(options: {
-        value: number;
-        duration: number;
-        cooldown: number;
-    }): void;
-    jump(options: {
-        velocityX: number;
-        velocityY: number;
-        cooldown: number;
-    }): void;
-    dash(options: {
-        force: number;
-        cooldown: number;
-    }): void;
-    setSprite(sprite: string): Promise<void>;
-    setProps(props: EvotarProps): Promise<void>;
-    setUserProps(props: UserProps): void;
-    private move;
-    update(): void;
-    isOnGround(y: number): boolean;
-    addMessage(message: string): void;
-    spitEmotes(emotes: string[]): void;
-    setAnimationState(state: EvotarSpriteTags, force?: boolean): Promise<void>;
-}
-export {};

package/dist/entities/Message.d.ts

@@ -1,27 +0,0 @@
-import { Point } from '../helpers/types';
-
-import * as PIXI from 'pixi.js';
-export type EvotarMesageProps = {
-    position: Point;
-};
-export declare class EvotarMessage {
-    private beforeShow;
-    container: PIXI.Container;
-    animated: PIXI.Container;
-    private text;
-    private padding;
-    private borderRadius;
-    private boxColor;
-    private fadeShift;
-    private isChecking;
-    private messageQueue;
-    private showTween?;
-    private hideTween?;
-    private timer?;
-    constructor(beforeShow: () => void);
-    private trim;
-    update(props: EvotarMesageProps): void;
-    add(message: string): void;
-    private drawBox;
-    private show;
-}

package/dist/entities/Name.d.ts

@@ -1,14 +0,0 @@
-import { Point, Rect } from '../helpers/types';
-
-import * as PIXI from 'pixi.js';
-export type EvotarNameProps = {
-    name: string;
-    position: Point;
-    isVisible: boolean;
-};
-export declare class EvotarName {
-    text: PIXI.Text;
-    constructor();
-    update(props: EvotarNameProps): void;
-    rect: () => Rect;
-}

package/dist/entities/SpriteContainer.d.ts

@@ -1,16 +0,0 @@
-import { EvotarLayerSprites } from '../services/spriteService';
-import { Point } from '../helpers/types';
-import * as PIXI from 'pixi.js';
-export type EvotarSpriteContainerProps = {
-    color: {
-        [key in string]?: PIXI.Color;
-    };
-    scale: Point;
-    play: boolean;
-};
-export declare class EvotarSpriteContainer {
-    container: PIXI.Container;
-    sprites: EvotarLayerSprites;
-    constructor(sprites: EvotarLayerSprites);
-    update(props: EvotarSpriteContainerProps): void;
-}

package/dist/entities/TrailEffect.d.ts

@@ -1,15 +0,0 @@
-import { EvotarSpriteContainer } from './SpriteContainer';
-import * as PIXI from 'pixi.js';
-export type EvotarTrailEffectProps = {
-    play: boolean;
-};
-export declare class EvotarTrailEffect {
-    container: PIXI.Container;
-    private timer?;
-    private sprite?;
-    private opacityStep;
-    private shadowStep;
-    constructor();
-    setSprite(sprite: EvotarSpriteContainer): void;
-    update(props: EvotarTrailEffectProps): void;
-}

package/dist/evotars.d.ts

@@ -1,15 +0,0 @@
-import { MessageEntity, RaidData, SettingsEntity, TwitchChatterEntity, UserActionEntity } from './types';
-import { AppOptions } from './app';
-
-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: RaidData) => void;
-    updateSettings(data: SettingsEntity): void;
-    run(): Promise<void>;
-}