evotars 0.0.2 → 0.0.4

package/src/entities/DudeSpriteContainer.ts

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

package/src/entities/DudeTrailEffect.ts

@@ -1,72 +0,0 @@
-import * as PIXI from 'pixi.js';
-import { app } from '../app';
-import { Timer } from '../helpers/timer';
-import { DudeSpriteContainer } from './DudeSpriteContainer';
-
-export type DudeTrailEffectProps = {
-  play: boolean;
-};
-
-export class DudeTrailEffect {
-  public container: PIXI.Container = new PIXI.Container();
-
-  private timer?: Timer;
-
-  private sprite?: DudeSpriteContainer;
-
-  private opacityStep = 0.1;
-
-  private shadowStep = 50;
-
-  constructor() {
-    app.stage.addChild(this.container);
-  }
-
-  public setSprite(sprite: DudeSpriteContainer) {
-    this.sprite = sprite;
-  }
-
-  public update(props: DudeTrailEffectProps): 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 of this.sprite.sprites) {
-          const texture = layer.sprite.texture.clone();
-          const sprite = new PIXI.Sprite(texture);
-
-          sprite.anchor.set(0.5, 0.5);
-          sprite.alpha = layer.sprite.alpha;
-          sprite.tint = layer.sprite.tint;
-
-          container.addChild(sprite);
-
-          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/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,11 +0,0 @@
-export type Point = {
-  x?: number;
-  y?: number;
-};
-
-export type Rect = {
-  x: number;
-  y: number;
-  w: number;
-  h: number;
-};

package/src/index.ts

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

package/src/main.ts

@@ -1,75 +0,0 @@
-import { Dudes } from "./dudes";
-import { SettingsEntity } from "./types";
-import "./styles.css";
-
-const manifest = {
-  bundles: [
-    {
-      name: "main",
-      assets: [
-        {
-          alias: "dude",
-          src: "/sprites/dude/dude.json",
-        },
-        {
-          alias: "sith",
-          src: "/sprites/sith/sith.json",
-        },
-        {
-          alias: "agent",
-          src: "/sprites/agent/agent.json",
-        },
-        {
-          alias: "girl",
-          src: "/sprites/girl/girl.json",
-        },
-        {
-          alias: "senior",
-          src: "/sprites/senior/senior.json",
-        },
-        {
-          alias: "cat",
-          src: "/sprites/cat/cat.json",
-        },
-        {
-          alias: "nerd",
-          src: "/sprites/nerd/nerd.json",
-        },
-      ],
-    },
-    {
-      name: "fonts",
-      assets: [
-        {
-          alias: "Rubik",
-          src: "/fonts/Rubik.ttf",
-        },
-      ],
-    },
-  ],
-};
-
-const sound = { jump: "/sounds/jump.mp3" };
-const settings: SettingsEntity = {
-  fallingDudes: true,
-};
-
-const root = document.getElementById("root");
-
-if (root) {
-  const dudes = new Dudes(root);
-  await dudes.run({ manifest, sound });
-  dudes.updateSettings(settings);
-
-  setTimeout(() => {
-    dudes.processMessage({
-      message: "Hello!",
-      userId: "1",
-      emotes: [],
-      info: {
-        color: "pink",
-        displayName: "Dude",
-      },
-    });
-  }, 500);
-}

package/src/services/assetsLoader.ts

@@ -1,27 +0,0 @@
-import * as PIXI from 'pixi.js';
-
-export interface AsepriteFrameData extends PIXI.ISpritesheetFrameData {
-  duration: number;
-}
-
-export interface AsepriteData extends PIXI.ISpritesheetData {
-  frames: Record<string, AsepriteFrameData>;
-  duration: number;
-}
-
-export class AssetsLoader {
-  private isLoaded = false;
-
-  public sheets: Record<string, PIXI.Spritesheet<AsepriteData>> = {};
-
-  async load(manifest: PIXI.AssetsManifest): Promise<void> {
-    if (!this.isLoaded) {
-      this.isLoaded = true;
-      await PIXI.Assets.init({ manifest });
-      this.sheets = await PIXI.Assets.loadBundle('main');
-      await PIXI.Assets.loadBundle('fonts');
-    }
-  }
-}
-
-export const assetsLoader = new AssetsLoader();

package/src/services/dudesManager.ts

@@ -1,305 +0,0 @@
-import {
-  MessageEntity,
-  RaidData,
-  TwitchChatterEntity,
-  UserActionEntity,
-  isColorUserActionEntity,
-  isDashUserActionEntity,
-  isGrowUserActionEntity,
-  isJumpUserActionEntity,
-} from "../types";
-import * as PIXI from "pixi.js";
-import tinycolor from "tinycolor2";
-import { app } from "../app";
-import { config } from "../config/config";
-import { Dude, DudeProps } from "../entities/Dude";
-import { timers } from "../helpers/timer";
-
-type DudesManagerSubscription = {
-  onAdd: (dude: Dude) => void;
-  onDelete: (dude: Dude) => void;
-};
-
-const DUDE_DESPAWN_TIMER = 1000 * 60 * 5;
-
-class DudesManager {
-  private viewers: Record<string, Dude | undefined> = {};
-
-  private raiders: Dude[] = [];
-
-  private lastDudeActivity: Record<string, number | undefined> = {};
-
-  private subscriptions: DudesManagerSubscription[] = [];
-
-  public subscribe(subscription: DudesManagerSubscription) {
-    this.subscriptions.push(subscription);
-  }
-
-  public update() {
-    for (const id in this.viewers) {
-      const viewer = this.viewers[id];
-
-      if (viewer) {
-        viewer.update();
-      }
-    }
-
-    for (const dude of this.raiders) {
-      dude.update();
-    }
-  }
-
-  public processRaid(data: RaidData) {
-    if (!app.settings.fallingRaiders) {
-      return;
-    }
-
-    const time = (1 / data.viewers) * 5000;
-
-    const spriteConfig = config.sprites["agent"];
-
-    for (let i = 0; i < data.viewers; i++) {
-      const dude = new Dude({
-        isAnonymous: true,
-        zIndex: -1,
-        sprite: spriteConfig,
-        color: new PIXI.Color(data.broadcaster.info.color),
-      });
-
-      timers.add(time * i, () => {
-        this.addRaider(dude);
-        dude.spawn({ isFalling: true });
-      });
-
-      timers.add(i * time + 30000, () => {
-        dude.despawn({
-          onComplete: () => {
-            this.deleteRaider(dude);
-          },
-        });
-      });
-    }
-
-    const dude = this.viewers[data.broadcaster.id];
-
-    const props: DudeProps = {
-      ...this.prepareDudeProps(
-        data.broadcaster.info.displayName,
-        data.broadcaster.info.color,
-      ),
-      scale: 8,
-    };
-
-    const spawnBroadcaster = () => {
-      const dude = new Dude(props);
-      this.addViewer(data.broadcaster.id, dude);
-      dude.spawn({ isFalling: true, positionX: 0.5 });
-    };
-
-    this.lastDudeActivity[data.broadcaster.id] = performance.now();
-
-    if (!dude) {
-      spawnBroadcaster();
-    } else {
-      dude.despawn({
-        onComplete: () => {
-          spawnBroadcaster();
-        },
-      });
-    }
-  }
-
-  public processChatters(data: TwitchChatterEntity[]) {
-    for (const id in this.viewers) {
-      const lastMessageTime = this.lastDudeActivity[id];
-      const spawnedRecently =
-        !!lastMessageTime &&
-        performance.now() - lastMessageTime < DUDE_DESPAWN_TIMER;
-
-      if (data.every((chatter) => chatter.userId != id) && !spawnedRecently) {
-        const dude = this.viewers[id];
-
-        if (dude) {
-          dude.despawn({
-            onComplete: () => {
-              this.deleteViewer(id, dude);
-            },
-          });
-        }
-      }
-    }
-
-    if (app.settings.showAnonymousDudes) {
-      for (const chatter of data) {
-        const dude = this.viewers[chatter.userId];
-
-        if (!dude) {
-          const props = {
-            name: chatter.name,
-            isAnonymous: !this.hasActivity(chatter.userId),
-          };
-
-          const dude = new Dude(props);
-          dude.spawn();
-
-          this.addViewer(chatter.userId, dude);
-        }
-      }
-    }
-  }
-
-  private hasActivity = (userId: string): boolean =>
-    !!this.lastDudeActivity[userId];
-
-  public doAction(action: UserActionEntity, dude: Dude) {
-    if (isJumpUserActionEntity(action)) {
-      dude.jump({
-        velocityX: action.data.velocityX,
-        velocityY: action.data.velocityY,
-        cooldown: action.cooldown,
-      });
-    }
-
-    if (isDashUserActionEntity(action)) {
-      dude.dash({ force: action.data.force, cooldown: action.cooldown });
-    }
-
-    if (isColorUserActionEntity(action)) {
-      const color = tinycolor(action.data.color);
-
-      if (color && color.isValid()) {
-        dude.setUserProps({ color: new PIXI.Color(action.data.color) });
-      }
-    }
-
-    if (isGrowUserActionEntity(action)) {
-      dude.scale({
-        value: action.data.scale,
-        duration: action.data.duration,
-        cooldown: action.cooldown,
-      });
-    }
-  }
-
-  private prepareDudeProps(
-    name: string,
-    color?: string,
-    sprite?: string,
-  ): DudeProps {
-    const props: DudeProps = {
-      name,
-      isAnonymous: false,
-    };
-
-    const spriteConfig = sprite ? config.sprites[sprite] : null;
-
-    if (spriteConfig) {
-      props.sprite = spriteConfig;
-    }
-
-    if (color) {
-      props.color = new PIXI.Color(color);
-    }
-
-    return props;
-  }
-
-  public processAction(action: UserActionEntity): void {
-    const dude = this.viewers[action.userId];
-
-    const props: DudeProps = this.prepareDudeProps(
-      action.info.displayName,
-      action.info.color,
-      action.info.sprite,
-    );
-
-    if (!dude) {
-      const dude = new Dude(props);
-
-      dude.spawn({
-        onComplete: () => {
-          const dude = this.viewers[action.userId];
-          if (dude) {
-            this.doAction(action, dude);
-          }
-        },
-      });
-
-      this.addViewer(action.userId, dude);
-    } else {
-      this.doAction(action, dude);
-      dude.setProps(props);
-    }
-  }
-
-  public processMessage(data: MessageEntity): void {
-    const props: DudeProps = this.prepareDudeProps(
-      data.info.displayName,
-      data.info.color,
-      data.info.sprite,
-    );
-
-    let dude = this.viewers[data.userId];
-
-    if (!dude) {
-      const isFalling = app.settings.fallingDudes
-        ? !this.hasActivity(data.userId)
-        : false;
-
-      dude = new Dude(props);
-      dude.spawn({ isFalling });
-
-      this.addViewer(data.userId, dude);
-    } else {
-      dude.setProps(props);
-    }
-
-    this.lastDudeActivity[data.userId] = performance.now();
-
-    if (data.message) {
-      dude.addMessage(data.message);
-    }
-
-    if (data.emotes.length > 0) {
-      dude.spitEmotes(data.emotes);
-    }
-  }
-
-  public addViewer(id: string, dude: Dude): void {
-    this.subscriptions.forEach((s) => s.onAdd(dude));
-    this.viewers[id] = dude;
-  }
-
-  public deleteViewer(id: string, dude: Dude): void {
-    this.subscriptions.forEach((s) => s.onDelete(dude));
-    delete this.viewers[id];
-  }
-
-  public addRaider(dude: Dude): void {
-    this.subscriptions.forEach((s) => s.onAdd(dude));
-    this.raiders.push(dude);
-  }
-
-  public deleteRaider(dude: Dude): void {
-    this.subscriptions.forEach((s) => s.onDelete(dude));
-    this.raiders = this.raiders.filter((raider) => raider != dude);
-  }
-
-  public zIndexDudeMax(from: number) {
-    return Object.values(this.viewers).reduce((zIndex, dude) => {
-      return dude && zIndex <= dude.container.zIndex
-        ? dude.container.zIndex + 1
-        : zIndex;
-    }, from);
-  }
-
-  public zIndexDudeMin(from: number) {
-    return Object.values(this.viewers).reduce((zIndex, dude) => {
-      return dude && zIndex >= dude.container.zIndex
-        ? dude.container.zIndex - 1
-        : zIndex;
-    }, from);
-  }
-}
-
-export const dudesManager = new DudesManager();

package/src/services/soundService.ts

@@ -1,28 +0,0 @@
-export type SoundManifest = {
-  [key: string]: string;
-};
-
-class SoundService {
-  assets: { [key: string]: HTMLAudioElement } = {};
-
-  async init(manifest: SoundManifest) {
-    this.assets = Object.fromEntries(
-      Array.from(Object.entries(manifest)).map(([key, value]) => {
-        return [key, new Audio(value)];
-      })
-    );
-  }
-
-  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();