evotars 0.0.9 → 0.0.11

package/src/entities/SpriteContainer.ts

@@ -1,65 +0,0 @@
-import * as PIXI from 'pixi.js';
-import { FIXED_DELTA_TIME } from '../config/constants';
-import { Point } from '../helpers/types';
-import { EvotarLayerSprites } from '../services/spriteService';
-
-export type EvotarSpriteContainerProps = {
-  color: {
-    [key in string]?: PIXI.Color;
-  };
-  scale: Point;
-  play: boolean;
-};
-
-export class EvotarSpriteContainer {
-  public container: PIXI.Container = new PIXI.Container();
-
-  public sprites: EvotarLayerSprites;
-
-  constructor(sprites: EvotarLayerSprites) {
-    this.sprites = sprites;
-
-    this.container.sortableChildren = true;
-
-    let zIndex = 0;
-
-    for (const layer in this.sprites) {
-      const sprite = this.sprites[layer];
-      this.container.addChild(sprite);
-
-      sprite.zIndex = ++zIndex;
-      sprite.anchor.set(0.5, 0);
-      sprite.autoUpdate = false;
-      sprite.play();
-    }
-  }
-
-  public update(props: EvotarSpriteContainerProps): void {
-    for (const layer in this.sprites) {
-      const sprite = this.sprites[layer];
-
-      if (props.play) {
-        sprite.update(FIXED_DELTA_TIME * 0.06);
-      }
-
-      if (props.color) {
-        for (const colorLayer in props.color) {
-          if (colorLayer == layer) {
-            const color = props.color[colorLayer];
-
-            if (color) {
-              sprite.alpha = color.alpha;
-              sprite.tint = color;
-            }
-          }
-        }
-      }
-
-      if (props.scale.x) {
-        sprite.animationSpeed = 4 / Math.abs(props.scale.x);
-      }
-    }
-
-    this.container.scale.set(props.scale.x, props.scale.y);
-  }
-}

package/src/entities/TrailEffect.ts

@@ -1,73 +0,0 @@
-import * as PIXI from 'pixi.js';
-import { app } from '../app';
-import { Timer } from '../helpers/timer';
-import { EvotarSpriteContainer } from './SpriteContainer';
-
-export type EvotarTrailEffectProps = {
-  play: boolean;
-};
-
-export class EvotarTrailEffect {
-  public container: PIXI.Container = new PIXI.Container();
-
-  private timer?: Timer;
-
-  private sprite?: EvotarSpriteContainer;
-
-  private opacityStep = 0.1;
-
-  private shadowStep = 50;
-
-  constructor() {
-    app.stage.addChild(this.container);
-  }
-
-  public setSprite(sprite: EvotarSpriteContainer) {
-    this.sprite = sprite;
-  }
-
-  public update(props: EvotarTrailEffectProps): void {
-    for (const child of this.container.children) {
-      if (child.alpha > 0) {
-        child.alpha = child.alpha - this.opacityStep;
-      }
-    }
-
-    if (this.timer && !this.timer.isCompleted) {
-      this.timer.tick();
-    } else if (props.play) {
-      this.timer = new Timer(this.shadowStep);
-
-      const container = new PIXI.Container();
-
-      if (this.sprite) {
-        for (const layer in this.sprite.sprites) {
-          const sprite = this.sprite.sprites[layer];
-          const texture = sprite.texture.clone();
-          const trailSprite = new PIXI.Sprite(texture);
-
-          trailSprite.anchor.set(0.5, 0);
-          trailSprite.alpha = sprite.alpha;
-          trailSprite.tint = sprite.tint;
-
-          container.addChild(trailSprite);
-
-          container.scale.set(
-            this.sprite.container.scale.x,
-            this.sprite.container.scale.y,
-          );
-
-          container.pivot.set(
-            this.sprite.container.pivot.x,
-            this.sprite.container.pivot.y,
-          );
-
-          const globalPosition = this.sprite.container.getGlobalPosition();
-          container.position.set(globalPosition.x, globalPosition.y);
-        }
-      }
-
-      this.container.addChild(container);
-    }
-  }
-}

package/src/evotars.ts

@@ -1,75 +0,0 @@
-import { AppOptions, app } from './app';
-import { evotarsManager } from './evotarsManager';
-import {
-  MessageEntity,
-  RaidData,
-  SettingsEntity,
-  TwitchChatterEntity,
-  UserActionEntity,
-} from './types';
-
-export class Evotars {
-  private isRendered = false;
-
-  constructor(
-    private readonly root: HTMLElement,
-    private readonly options: AppOptions,
-  ) {}
-
-  processMessage = (data: MessageEntity) => evotarsManager.processMessage(data);
-
-  processAction = (data: UserActionEntity) =>
-    evotarsManager.processAction(data);
-
-  processChatters = (data: TwitchChatterEntity[]) =>
-    evotarsManager.processChatters(data);
-
-  processRaid = (data: RaidData) => evotarsManager.processRaid(data);
-
-  updateSettings(data: SettingsEntity) {
-    app.updateSettings(data);
-  }
-
-  async run() {
-    if (this.isRendered) {
-      return;
-    }
-
-    this.isRendered = true;
-
-    const init = async (): Promise<void> => {
-      await app.initialize(this.root, this.options);
-
-      let lastTime = performance.now();
-      let lastFrame = -1;
-
-      const maxFps = 60;
-
-      const minElapsedMS = 1000 / maxFps;
-      const maxElapsedMS = 100;
-
-      requestAnimationFrame(animate);
-
-      function animate(currentTime = performance.now()): void {
-        let elapsedMS = currentTime - lastTime;
-
-        if (elapsedMS > maxElapsedMS) {
-          elapsedMS = maxElapsedMS;
-        }
-
-        const delta = (currentTime - lastFrame) | 0;
-
-        if (delta > minElapsedMS) {
-          lastFrame = currentTime - (delta % minElapsedMS);
-          lastTime = currentTime;
-
-          app.update();
-        }
-
-        requestAnimationFrame(animate);
-      }
-    };
-
-    await init();
-  }
-}

package/src/evotarsManager.ts

@@ -1,313 +0,0 @@
-import {
-  MessageEntity,
-  RaidData,
-  TwitchChatterEntity,
-  UserActionEntity,
-  isColorUserActionEntity,
-  isDashUserActionEntity,
-  isGrowUserActionEntity,
-  isJumpUserActionEntity,
-  isSpriteUserActionEntity,
-} from './types';
-import * as PIXI from 'pixi.js';
-import tinycolor from 'tinycolor2';
-import { app } from './app';
-import { Evotar, EvotarProps } from './entities/Evotar';
-import { timers } from './helpers/timer';
-
-type EvotarsManagerSubscription = {
-  onAdd: (evotar: Evotar) => void;
-  onDelete: (evotar: Evotar) => void;
-};
-
-const EVOTAR_DESPAWN_TIMER = 1000 * 60 * 5;
-
-class EvotarsManager {
-  private viewers: Record<string, Evotar | undefined> = {};
-
-  private raiders: Evotar[] = [];
-
-  private lastEvotarActivity: Record<string, number | undefined> = {};
-
-  private subscriptions: EvotarsManagerSubscription[] = [];
-
-  public subscribe(subscription: EvotarsManagerSubscription) {
-    this.subscriptions.push(subscription);
-  }
-
-  public update() {
-    for (const id in this.viewers) {
-      const viewer = this.viewers[id];
-
-      if (viewer) {
-        viewer.update();
-      }
-    }
-
-    for (const evotar of this.raiders) {
-      evotar.update();
-    }
-  }
-
-  public processRaid(data: RaidData) {
-    if (!app.settings.fallingRaiders) {
-      return;
-    }
-
-    const time = (1 / data.viewers) * 5000;
-
-    for (let i = 0; i < data.viewers; i++) {
-      const evotar = new Evotar();
-
-      evotar.setProps({
-        isAnonymous: true,
-        zIndex: -1,
-        sprite: 'agent',
-        color: new PIXI.Color(data.broadcaster.info.color),
-      });
-
-      timers.add(time * i, () => {
-        this.addRaider(evotar);
-        evotar.spawn({ isFalling: true });
-      });
-
-      timers.add(i * time + 30000, () => {
-        evotar.despawn({
-          onComplete: () => {
-            this.deleteRaider(evotar);
-          },
-        });
-      });
-    }
-
-    const evotar = this.viewers[data.broadcaster.id];
-
-    const props: EvotarProps = {
-      ...this.prepareEvotarProps(
-        data.broadcaster.info.displayName,
-        data.broadcaster.info.color,
-      ),
-      scale: 8,
-    };
-
-    const spawnBroadcaster = () => {
-      const evotar = new Evotar();
-      evotar.setProps(props);
-      this.addViewer(data.broadcaster.id, evotar);
-      evotar.spawn({ isFalling: true, positionX: 0.5 });
-    };
-
-    this.lastEvotarActivity[data.broadcaster.id] = performance.now();
-
-    if (!evotar) {
-      spawnBroadcaster();
-    } else {
-      evotar.despawn({
-        onComplete: () => {
-          spawnBroadcaster();
-        },
-      });
-    }
-  }
-
-  public async processChatters(data: TwitchChatterEntity[]) {
-    for (const id in this.viewers) {
-      const lastMessageTime = this.lastEvotarActivity[id];
-      const spawnedRecently =
-        !!lastMessageTime &&
-        performance.now() - lastMessageTime < EVOTAR_DESPAWN_TIMER;
-
-      if (data.every((chatter) => chatter.userId != id) && !spawnedRecently) {
-        const evotar = this.viewers[id];
-
-        if (evotar) {
-          evotar.despawn({
-            onComplete: () => {
-              this.deleteViewer(id, evotar);
-            },
-          });
-        }
-      }
-    }
-
-    if (app.settings.showAnonymousEvotars) {
-      for (const chatter of data) {
-        const evotar = this.viewers[chatter.userId];
-
-        if (!evotar) {
-          const props = {
-            name: chatter.name,
-            isAnonymous: !this.hasActivity(chatter.userId),
-          };
-
-          const evotar = new Evotar();
-          await evotar.setProps(props);
-          evotar.spawn();
-
-          this.addViewer(chatter.userId, evotar);
-        }
-      }
-    }
-  }
-
-  private hasActivity = (userId: string): boolean =>
-    !!this.lastEvotarActivity[userId];
-
-  public doAction(action: UserActionEntity, evotar: Evotar) {
-    if (isJumpUserActionEntity(action)) {
-      evotar.jump({
-        velocityX: action.data.velocityX,
-        velocityY: action.data.velocityY,
-        cooldown: action.cooldown,
-      });
-    }
-
-    if (isDashUserActionEntity(action)) {
-      evotar.dash({ force: action.data.force, cooldown: action.cooldown });
-    }
-
-    if (isColorUserActionEntity(action)) {
-      const color = tinycolor(action.data.color);
-
-      if (color && color.isValid()) {
-        evotar.setUserProps({ color: new PIXI.Color(action.data.color) });
-      }
-    }
-
-    if (isGrowUserActionEntity(action)) {
-      evotar.scale({
-        value: action.data.scale,
-        duration: action.data.duration,
-        cooldown: action.cooldown,
-      });
-    }
-
-    if (isSpriteUserActionEntity(action)) {
-      evotar.setSprite(action.data.sprite);
-    }
-  }
-
-  private prepareEvotarProps(
-    name: string,
-    color?: string,
-    sprite?: string,
-  ): EvotarProps {
-    const props: EvotarProps = {
-      name,
-      isAnonymous: false,
-    };
-
-    if (sprite) {
-      props.sprite = sprite;
-    }
-
-    if (color) {
-      try {
-        props.color = new PIXI.Color(color);
-      } catch (e) {}
-    }
-
-    return props;
-  }
-
-  public async processAction(action: UserActionEntity): Promise<void> {
-    const evotar = this.viewers[action.userId];
-
-    const props: EvotarProps = this.prepareEvotarProps(
-      action.info.displayName,
-      action.info.color,
-      action.info.sprite,
-    );
-
-    if (!evotar) {
-      const evotar = new Evotar();
-      await evotar.setProps(props);
-
-      evotar.spawn({
-        onComplete: () => {
-          const evotar = this.viewers[action.userId];
-          if (evotar) {
-            this.doAction(action, evotar);
-          }
-        },
-      });
-
-      this.addViewer(action.userId, evotar);
-    } else {
-      await evotar.setProps(props);
-      this.doAction(action, evotar);
-    }
-  }
-
-  public async processMessage(data: MessageEntity): Promise<void> {
-    const props: EvotarProps = this.prepareEvotarProps(
-      data.info.displayName,
-      data.info.color,
-      data.info.sprite,
-    );
-
-    let evotar = this.viewers[data.userId];
-
-    if (!evotar) {
-      const isFalling = app.settings.fallingEvotars
-        ? !this.hasActivity(data.userId)
-        : false;
-
-      evotar = new Evotar();
-      await evotar.setProps(props);
-      evotar.spawn({ isFalling });
-
-      this.addViewer(data.userId, evotar);
-    } else {
-      evotar.setProps(props);
-    }
-
-    this.lastEvotarActivity[data.userId] = performance.now();
-
-    if (data.message) {
-      evotar.addMessage(data.message);
-    }
-
-    if (data.emotes.length > 0) {
-      evotar.spitEmotes(data.emotes);
-    }
-  }
-
-  public addViewer(id: string, evotar: Evotar): void {
-    this.subscriptions.forEach((s) => s.onAdd(evotar));
-    this.viewers[id] = evotar;
-  }
-
-  public deleteViewer(id: string, evotar: Evotar): void {
-    this.subscriptions.forEach((s) => s.onDelete(evotar));
-    delete this.viewers[id];
-  }
-
-  public addRaider(evotar: Evotar): void {
-    this.subscriptions.forEach((s) => s.onAdd(evotar));
-    this.raiders.push(evotar);
-  }
-
-  public deleteRaider(evotar: Evotar): void {
-    this.subscriptions.forEach((s) => s.onDelete(evotar));
-    this.raiders = this.raiders.filter((raider) => raider != evotar);
-  }
-
-  public zIndexEvotarMax(from: number) {
-    return Object.values(this.viewers).reduce((zIndex, evotar) => {
-      return evotar && zIndex <= evotar.container.zIndex
-        ? evotar.container.zIndex + 1
-        : zIndex;
-    }, from);
-  }
-
-  public zIndexEvotarMin(from: number) {
-    return Object.values(this.viewers).reduce((zIndex, evotar) => {
-      return evotar && zIndex >= evotar.container.zIndex
-        ? evotar.container.zIndex - 1
-        : zIndex;
-    }, from);
-  }
-}
-
-export const evotarsManager = new EvotarsManager();

package/src/helpers/timer.ts

@@ -1,43 +0,0 @@
-import { FIXED_DELTA_TIME } from '../config/constants';
-
-export class Timer {
-  public isCompleted = false;
-
-  constructor(public current = 0, private onComplete?: () => void) {}
-
-  tick(delta: number = FIXED_DELTA_TIME) {
-    if (this.isCompleted) {
-      return;
-    }
-
-    this.current -= delta;
-
-    if (this.current < 0) {
-      this.isCompleted = true;
-      this.onComplete?.();
-    }
-  }
-}
-
-class Timers {
-  private timers: Timer[] = [];
-
-  public add(current?: number, onComplete?: () => void) {
-    this.timers.push(new Timer(current, onComplete));
-  }
-
-  public tick(delta: number = FIXED_DELTA_TIME) {
-    const uncompleted = [];
-
-    for (const timer of this.timers) {
-      if (!timer.isCompleted) {
-        timer.tick(delta);
-        uncompleted.push(timer);
-      }
-    }
-
-    this.timers = uncompleted;
-  }
-}
-
-export const timers = new Timers();

package/src/helpers/types.ts

@@ -1,4 +0,0 @@
-export type Point = {
-  x?: number;
-  y?: number;
-};

package/src/index.ts

@@ -1 +0,0 @@
-export * from './evotars';

package/src/services/soundService.ts

@@ -1,30 +0,0 @@
-export type SoundOptions = {
-  jump?: {
-    src: string;
-  };
-};
-
-class SoundService {
-  assets: { [key: string]: HTMLAudioElement } = {};
-
-  async initialize(options?: SoundOptions) {
-    this.assets = Object.fromEntries(
-      Array.from(Object.entries(options ?? {})).map(([key, value]) => {
-        return [key, new Audio(value.src)];
-      }),
-    );
-  }
-
-  play(name: string) {
-    const audio = this.assets[name];
-
-    if (audio) {
-      audio.volume = 0.2;
-      audio.pause();
-      audio.currentTime = 0;
-      audio.play();
-    }
-  }
-}
-
-export const soundService = new SoundService();