evotars 0.0.1 → 0.0.3

package/dist/evotars.js

@@ -0,0 +1,789 @@
+var M = Object.defineProperty;
+var k = (a, t, e) => t in a ? M(a, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[t] = e;
+var s = (a, t, e) => (k(a, typeof t != "symbol" ? t + "" : t, e), e);
+import * as h from "pixi.js";
+import D from "tinycolor2";
+import * as y from "@tweenjs/tween.js";
+import { Tween as S } from "@tweenjs/tween.js";
+const m = 0.02 * 1e3;
+class w {
+  constructor(t = 0, e) {
+    s(this, "isCompleted", !1);
+    this.current = t, this.onComplete = e;
+  }
+  tick(t = m) {
+    var e;
+    this.isCompleted || (this.current -= t, this.current < 0 && (this.isCompleted = !0, (e = this.onComplete) == null || e.call(this)));
+  }
+}
+class P {
+  constructor() {
+    s(this, "timers", []);
+  }
+  add(t, e) {
+    this.timers.push(new w(t, e));
+  }
+  tick(t = m) {
+    const e = [];
+    for (const i of this.timers)
+      i.isCompleted || (i.tick(t), e.push(i));
+    this.timers = e;
+  }
+}
+const v = new P();
+class z {
+  constructor() {
+    s(this, "isLoaded", !1);
+    s(this, "sheets", {});
+  }
+  async load(t) {
+    this.isLoaded || (this.isLoaded = !0, await h.Assets.init({ manifest: t }), this.sheets = await h.Assets.loadBundle("main"), await h.Assets.loadBundle("fonts"));
+  }
+}
+const T = new z(), F = (a) => a.name == "jump", L = (a) => a.name == "color", V = (a) => a.name == "grow", j = (a) => a.name == "dash", C = {
+  sprites: {
+    sith: {
+      name: "sith",
+      w: 32,
+      h: 32,
+      collider: {
+        x: 8,
+        y: 5,
+        w: 16,
+        h: 20
+      },
+      pivot: {
+        x: 0,
+        y: 9
+      }
+    },
+    agent: {
+      name: "agent",
+      w: 32,
+      h: 32,
+      collider: {
+        x: 8,
+        y: 7,
+        w: 16,
+        h: 18
+      },
+      pivot: {
+        x: 0,
+        y: 9
+      }
+    },
+    nerd: {
+      name: "nerd",
+      w: 32,
+      h: 32,
+      collider: {
+        x: 8,
+        y: 7,
+        w: 16,
+        h: 18
+      },
+      pivot: {
+        x: 0,
+        y: 9
+      }
+    },
+    girl: {
+      name: "girl",
+      w: 32,
+      h: 32,
+      collider: {
+        x: 8,
+        y: 5,
+        w: 16,
+        h: 20
+      },
+      pivot: {
+        x: 0,
+        y: 9
+      }
+    },
+    cat: {
+      name: "cat",
+      w: 32,
+      h: 32,
+      collider: {
+        x: 8,
+        y: 4,
+        w: 16,
+        h: 21
+      },
+      pivot: {
+        x: 0,
+        y: 9
+      }
+    },
+    senior: {
+      name: "senior",
+      w: 32,
+      h: 32,
+      collider: {
+        x: 8,
+        y: 4,
+        w: 16,
+        h: 21
+      },
+      pivot: {
+        x: 0,
+        y: 9
+      }
+    },
+    sponge: {
+      name: "sponge",
+      w: 32,
+      h: 32,
+      collider: {
+        x: 8,
+        y: 7,
+        w: 16,
+        h: 18
+      },
+      pivot: {
+        x: 0,
+        y: 9
+      }
+    }
+  }
+};
+class O {
+  constructor() {
+    s(this, "assets", {});
+  }
+  async init(t) {
+    this.assets = Object.fromEntries(
+      Array.from(Object.entries(t)).map(([e, i]) => [e, new Audio(i)])
+    );
+  }
+  play(t) {
+    const e = this.assets[t];
+    e && (e.volume = 0.2, e.pause(), e.currentTime = 0, e.play());
+  }
+}
+const E = new O();
+var b = /* @__PURE__ */ ((a) => (a.Body = "Body", a.Eyes = "Eyes", a))(b || {}), l = /* @__PURE__ */ ((a) => (a.Idle = "Idle", a.Jump = "Jump", a.Fall = "Fall", a.Land = "Land", a.Run = "Run", a.Die = "Die", a))(l || {});
+class J {
+  createLayerAnimatedSprites(t, e, i) {
+    const n = e.data.meta.layers;
+    if (n) {
+      const o = Object.fromEntries(
+        n.map((r) => [r.name, []])
+      );
+      for (let r = i.from; r <= i.to; r++) {
+        const c = r.toString();
+        for (const d in o) {
+          const g = t + "_" + d + "_" + c, I = e.textures[g], R = e.data.frames[g].duration;
+          o[d].push({ texture: I, time: R });
+        }
+      }
+      return Object.entries(o).map((r) => {
+        const c = new h.AnimatedSprite(r[1]);
+        return c.texture.baseTexture.scaleMode = h.SCALE_MODES.NEAREST, { layer: r[0], sprite: c };
+      });
+    }
+    throw Error("Sprite sheet doesn't have layers");
+  }
+  createTagAnimatedSprites(t) {
+    if (!t)
+      throw Error("Sheet is not defined");
+    const e = T.sheets[t];
+    return (e.data.meta.frameTags ?? []).reduce(
+      (i, n) => (n && n.name && (i[n.name] = this.createLayerAnimatedSprites(t, e, n)), i),
+      {}
+    );
+  }
+}
+const A = new J();
+class W {
+  constructor() {
+    s(this, "container", new h.Container());
+    s(this, "emotes", []);
+    s(this, "moveSpeed", 50);
+    s(this, "alphaSpeed", 1);
+    s(this, "scaleSpeed", 0.5);
+    s(this, "timer");
+  }
+  add(t) {
+    const e = h.Sprite.from(t);
+    e.anchor.set(0.5, 0.5), e.scale.set(0, 0), this.emotes.push(e);
+  }
+  update(t) {
+    var e;
+    (e = this.timer) == null || e.tick(), (!this.timer || this.timer.isCompleted) && this.emotes.length > 0 && (this.timer = new w(2e3, () => {
+      const i = this.emotes.shift();
+      i && this.container.addChild(i);
+    })), this.container.position.x = t.position.x ?? this.container.position.x, this.container.position.y = t.position.y ?? this.container.position.y;
+    for (const i of this.container.children)
+      i.position.y -= m * this.moveSpeed / 1e3, i.scale.x += m * this.scaleSpeed / 1e3, i.scale.y += m * this.scaleSpeed / 1e3, i.scale.x > 1 && (i.alpha -= m * this.alphaSpeed / 1e3), i.alpha <= 0 && this.container.removeChild(i);
+  }
+}
+class _ {
+  constructor(t) {
+    s(this, "container", new h.Container());
+    s(this, "animated", new h.Container());
+    s(this, "text", new h.Text(void 0, {
+      fontFamily: "Rubik",
+      fontSize: 20,
+      fill: 2236962,
+      align: "left",
+      breakWords: !0,
+      wordWrap: !0,
+      wordWrapWidth: 200
+    }));
+    s(this, "padding", 10);
+    s(this, "borderRadius", 10);
+    s(this, "boxColor", 15658734);
+    s(this, "fadeShift", 10);
+    s(this, "isChecking", !0);
+    s(this, "messageQueue", []);
+    s(this, "showTween");
+    s(this, "hideTween");
+    s(this, "timer");
+    this.beforeShow = t, this.container.addChild(this.animated), this.text.anchor.set(0.5, 1), this.text.position.set(0, -this.padding);
+  }
+  trim(t) {
+    const e = h.TextMetrics.measureText(t.text, t.style);
+    return e.lines.length > 4 ? e.lines.slice(0, 4).join(" ").slice(0, -3) + "..." : t.text;
+  }
+  update(t) {
+    var i, n, o, r, c;
+    if ((i = this.timer) == null || i.tick(), (n = this.showTween) == null || n.update(), (o = this.hideTween) == null || o.update(), this.isChecking && this.messageQueue.length > 0) {
+      this.isChecking = !1;
+      const d = this.messageQueue.shift();
+      d && (this.beforeShow(), this.show(d));
+    }
+    this.container.position.x = t.position.x ?? this.container.position.x, this.container.position.y = t.position.y ?? this.container.position.y;
+    const e = ((r = this.showTween) == null ? void 0 : r.isPlaying()) || ((c = this.hideTween) == null ? void 0 : c.isPlaying());
+    !this.isChecking && !e && this.timer && (this.animated.position.y = Math.sin(this.timer.current * 25e-4) * 4 - 2);
+  }
+  add(t) {
+    this.messageQueue.push(t);
+  }
+  drawBox(t) {
+    const e = {
+      x: t.x - this.padding - t.width * t.anchor.x,
+      y: t.y - this.padding - t.height * t.anchor.y,
+      w: t.width + this.padding * 2,
+      h: t.height + this.padding * 2
+    }, i = new h.Graphics();
+    return i.beginFill(this.boxColor), i.drawRoundedRect(
+      e.x,
+      e.y,
+      e.w,
+      e.h,
+      this.borderRadius
+    ), i.drawPolygon(
+      {
+        x: e.x + e.w / 2 - 10,
+        y: e.y + e.h
+      },
+      {
+        x: e.x + e.w / 2 + 10,
+        y: e.y + e.h
+      },
+      {
+        x: e.x + e.w / 2,
+        y: e.y + e.h + 10 - 4
+      }
+    ), i.endFill(), i;
+  }
+  show(t) {
+    this.text.text = t, this.text.text = this.trim(this.text), this.animated.alpha = 0, this.animated.position.y = this.fadeShift;
+    const e = this.drawBox(this.text);
+    this.animated.removeChildren(), this.animated.addChild(e, this.text);
+    const i = {
+      alpha: 1,
+      y: this.animated.y - this.fadeShift
+    }, n = {
+      alpha: 0,
+      y: this.animated.y + this.fadeShift
+    };
+    this.hideTween = new S(this.animated).to(n, 500).onComplete(() => {
+      this.isChecking = !0;
+    }), this.showTween = new S(this.animated).to(i, 500).onComplete(() => {
+      this.timer = new w(1e4, () => {
+        var o;
+        (o = this.hideTween) == null || o.start();
+      });
+    }), this.showTween.start();
+  }
+}
+class B {
+  constructor() {
+    s(this, "text", new h.Text(void 0, {
+      fontFamily: "Rubik",
+      fontSize: 18,
+      fill: 16777215,
+      align: "center",
+      lineJoin: "round",
+      strokeThickness: 4,
+      stroke: "black"
+    }));
+    s(this, "rect", () => ({
+      x: this.text.x,
+      y: this.text.y,
+      w: this.text.width,
+      h: this.text.height
+    }));
+    this.text.anchor.set(0.5, 1), this.text.zIndex = 100;
+  }
+  update(t) {
+    this.text.text = t.name ?? "", this.text.visible = t.isVisible, this.text.position.x = t.position.x ?? this.text.position.x, this.text.position.y = t.position.y ?? this.text.position.y;
+  }
+}
+class U {
+  constructor(t) {
+    s(this, "container", new h.Container());
+    s(this, "sprites");
+    this.sprites = t, this.container.sortableChildren = !0;
+    let e = 0;
+    for (const i of this.sprites) {
+      const n = i.sprite;
+      this.container.addChild(n), n.zIndex = ++e, n.anchor.set(0.5, 0.5), n.autoUpdate = !1, n.play();
+    }
+  }
+  update(t) {
+    for (const e of this.sprites) {
+      if (t.play && e.sprite.update(m * 0.06), t.color) {
+        for (const i in t.color)
+          if (i == e.layer) {
+            const n = t.color[i];
+            n && (e.sprite.alpha = n.alpha, e.sprite.tint = n);
+          }
+      }
+      t.scale.x && (e.sprite.animationSpeed = x / Math.abs(t.scale.x));
+    }
+    this.container.scale.set(t.scale.x, t.scale.y);
+  }
+}
+class X {
+  constructor() {
+    s(this, "container", new h.Container());
+    s(this, "timer");
+    s(this, "sprite");
+    s(this, "opacityStep", 0.1);
+    s(this, "shadowStep", 50);
+    p.stage.addChild(this.container);
+  }
+  setSprite(t) {
+    this.sprite = t;
+  }
+  update(t) {
+    for (const e of this.container.children)
+      e.alpha > 0 && (e.alpha = e.alpha - this.opacityStep);
+    if (this.timer && !this.timer.isCompleted)
+      this.timer.tick();
+    else if (t.play) {
+      this.timer = new w(this.shadowStep);
+      const e = new h.Container();
+      if (this.sprite)
+        for (const i of this.sprite.sprites) {
+          const n = i.sprite.texture.clone(), o = new h.Sprite(n);
+          o.anchor.set(0.5, 0.5), o.alpha = i.sprite.alpha, o.tint = i.sprite.tint, e.addChild(o), e.scale.set(
+            this.sprite.container.scale.x,
+            this.sprite.container.scale.y
+          ), e.pivot.set(
+            this.sprite.container.pivot.x,
+            this.sprite.container.pivot.y
+          );
+          const r = this.sprite.container.getGlobalPosition();
+          e.position.set(r.x, r.y);
+        }
+      this.container.addChild(e);
+    }
+  }
+}
+const x = 4;
+class f {
+  constructor(t = {}) {
+    s(this, "container", new h.Container());
+    s(this, "userState", {});
+    s(this, "state", {
+      name: "",
+      sprite: {
+        name: "dude",
+        w: 32,
+        h: 32,
+        collider: {
+          x: 8,
+          y: 7,
+          w: 16,
+          h: 18
+        },
+        pivot: {
+          x: 0,
+          y: 9
+        }
+      },
+      color: new h.Color("#969696"),
+      direction: 1,
+      scale: x,
+      isAnonymous: !1,
+      zIndex: 0
+    });
+    s(this, "animationState");
+    // TODO: Refactor sprite initializing, move logic to separate file
+    s(this, "sprite");
+    s(this, "tagSprites", A.createTagAnimatedSprites(this.state.sprite.name));
+    s(this, "trail", new X());
+    s(this, "name", new B());
+    s(this, "message", new _(() => {
+      this.state.zIndex = u.zIndexEvotarMax(this.container.zIndex);
+    }));
+    s(this, "emoteSpitter", new W());
+    s(this, "velocity", {
+      x: 0,
+      y: 0
+    });
+    s(this, "runSpeed", 0.05);
+    s(this, "gravity", 0.2);
+    s(this, "dashAcc", 3);
+    s(this, "isJumping", !1);
+    s(this, "isDashing", !1);
+    s(this, "isDespawned", !1);
+    s(this, "landTimer");
+    s(this, "stateTimer");
+    s(this, "scaleTimer");
+    s(this, "spawnTween");
+    s(this, "fadeTween");
+    s(this, "scaleTween");
+    this.container.addChild(this.name.text), this.container.addChild(this.emoteSpitter.container), this.container.addChild(this.message.container), this.setAnimationState(l.Idle), t.sprite && this.setSprite(t.sprite), this.state = { ...this.state, ...t }, this.stateTimer = new w(5e3, () => {
+      this.isJumping || this.setAnimationState(l.Run);
+    });
+  }
+  spawn(t = { isFalling: !1 }) {
+    const e = this.state.sprite.collider, i = -(e.y + e.h - this.state.sprite.h / 2), n = t.isFalling ? i : p.renderer.height, o = this.state.sprite.w * this.state.scale, r = t.positionX != null ? t.positionX * p.renderer.width : Math.random() * (p.renderer.width - o) + o / 2, c = n * this.state.scale;
+    if (this.container.x = r, this.container.y = c, this.state.direction = Math.random() > 0.5 ? 1 : -1, !t.isFalling) {
+      const d = u.zIndexEvotarMin(this.container.zIndex);
+      this.state.zIndex = d, this.container.alpha = 0, this.spawnTween = new y.Tween(this.container).to({ alpha: 1 }, 500).onComplete(t.onComplete).start();
+    }
+  }
+  despawn(t = {}) {
+    this.fadeTween && this.fadeTween.isPlaying() || (this.fadeTween = new y.Tween(this.container).to({ alpha: 0 }, 1e3).onComplete(() => {
+      this.isDespawned = !0, t.onComplete && t.onComplete();
+    }).start());
+  }
+  scale(t) {
+    this.scaleTween && this.scaleTween.isPlaying() || this.scaleTimer && !this.scaleTimer.isCompleted || (this.scaleTween = new y.Tween(this).to(
+      { state: { scale: x * (t.value ?? 2) } },
+      2e3
+    ).onComplete(() => {
+      this.scaleTimer = new w((t.duration ?? 10) * 1e3, () => {
+        this.scaleTween = new y.Tween(this).to({ state: { scale: x } }, 2e3).start();
+      });
+    }).start());
+  }
+  jump(t) {
+    this.isDespawned || this.isJumping || (this.isJumping = !0, this.velocity.x = this.state.direction * (t.velocityX ?? 3.5), this.velocity.y = t.velocityY ?? -8, this.setAnimationState(l.Jump), E.play("jump"));
+  }
+  dash(t) {
+    this.isDespawned || this.isDashing || (this.isDashing = !0, this.velocity.x = this.state.direction * (t.force ?? 14));
+  }
+  setSprite(t) {
+    t.name && t.name != this.state.sprite.name && (this.tagSprites = A.createTagAnimatedSprites(t.name), this.animationState && this.setAnimationState(this.animationState, !0));
+  }
+  setProps(t) {
+    t.sprite && this.setSprite(t.sprite), this.state = { ...this.state, ...t };
+  }
+  setUserProps(t) {
+    this.userState = { ...this.userState, ...t };
+  }
+  move() {
+    var i;
+    const t = this.state.sprite.collider, e = {
+      x: this.container.position.x,
+      y: this.container.position.y
+    };
+    if (this.isDashing) {
+      const n = Math.sign(this.velocity.x);
+      this.velocity.x = this.velocity.x - n * this.dashAcc / Math.abs(this.velocity.x), n != Math.sign(this.velocity.x) ? (this.isDashing = !1, this.velocity.x = 0) : e.x += this.velocity.x;
+    } else {
+      if ((i = this.stateTimer) != null && i.isCompleted && (this.stateTimer = new w(Math.random() * 5e3, () => {
+        this.animationState == l.Idle ? this.setAnimationState(l.Run) : this.animationState == l.Run && this.setAnimationState(l.Idle);
+      })), this.animationState == l.Run) {
+        const n = this.runSpeed * this.state.direction;
+        this.velocity.x = n * m;
+      }
+      this.velocity.y = this.velocity.y + this.gravity, e.x += this.velocity.x, e.y += this.velocity.y, this.isOnGround(e.y) && (this.velocity.y = 0, this.velocity.x = 0, e.y = p.renderer.height, this.animationState == l.Fall && (this.setAnimationState(l.Land), this.landTimer = new w(200, () => {
+        this.setAnimationState(l.Idle), this.isJumping = !1;
+      }))), this.velocity.y > 0 && this.setAnimationState(l.Fall);
+    }
+    if (this.animationState != l.Idle || this.isDashing) {
+      const n = t.w / 2 * this.state.scale, o = this.container.x - n < 0, r = this.container.x + n > p.renderer.width;
+      (o || r) && (this.state.direction = -this.state.direction, this.velocity.x = -this.velocity.x, o && (e.x = n), r && (e.x = p.renderer.width - n));
+    }
+    this.container.position.set(e.x, e.y);
+  }
+  update() {
+    var e, i, n, o, r, c;
+    if (this.isDespawned)
+      return;
+    (e = this.landTimer) == null || e.tick(), (i = this.stateTimer) == null || i.tick(), (n = this.scaleTimer) == null || n.tick(), (o = this.fadeTween) == null || o.update(), (r = this.spawnTween) == null || r.update(), (c = this.scaleTween) == null || c.update(), this.container.zIndex = this.state.zIndex;
+    const t = this.state.sprite.collider;
+    this.name.update({
+      name: this.state.name,
+      isVisible: !this.state.isAnonymous,
+      position: {
+        y: -(this.state.sprite.h / 2 - t.y + this.state.sprite.pivot.y) * this.state.scale
+      }
+    }), this.message.update({
+      position: {
+        y: this.name.text.position.y - this.name.text.height - 6
+      }
+    }), this.emoteSpitter.update({
+      position: {
+        y: this.message.container.position.y - this.message.container.height
+      }
+    }), this.move(), this.sprite && this.sprite.update({
+      color: {
+        [b.Body]: this.userState.color ? this.userState.color : this.state.color
+      },
+      scale: {
+        x: this.state.direction * this.state.scale,
+        y: this.state.scale
+      },
+      play: !this.isDashing
+    }), this.trail.update({
+      play: this.isDashing
+    });
+  }
+  isOnGround(t) {
+    return t > p.renderer.height;
+  }
+  addMessage(t) {
+    var e;
+    this.message.add(t), this.state.isAnonymous = !1, (e = this.fadeTween) == null || e.stop(), this.fadeTween = void 0, this.container.alpha = 1;
+  }
+  spitEmotes(t) {
+    for (const e of t)
+      this.emoteSpitter.add(e);
+  }
+  async setAnimationState(t, e = !1) {
+    if (this.animationState == t && !e)
+      return;
+    this.animationState = t, this.sprite && this.container.removeChild(this.sprite.container);
+    const i = this.tagSprites[this.animationState];
+    this.sprite = new U(i), this.trail.setSprite(this.sprite), this.sprite.container.pivot.set(
+      this.state.sprite.pivot.x,
+      this.state.sprite.pivot.y
+    ), this.container.addChild(this.sprite.container);
+  }
+}
+const G = 1e3 * 60 * 5;
+class N {
+  constructor() {
+    s(this, "viewers", {});
+    s(this, "raiders", []);
+    s(this, "lastEvotarActivity", {});
+    s(this, "subscriptions", []);
+    s(this, "hasActivity", (t) => !!this.lastEvotarActivity[t]);
+  }
+  subscribe(t) {
+    this.subscriptions.push(t);
+  }
+  update() {
+    for (const t in this.viewers) {
+      const e = this.viewers[t];
+      e && e.update();
+    }
+    for (const t of this.raiders)
+      t.update();
+  }
+  processRaid(t) {
+    if (!p.settings.fallingRaiders)
+      return;
+    const e = 1 / t.viewers * 5e3, i = C.sprites.agent;
+    for (let c = 0; c < t.viewers; c++) {
+      const d = new f({
+        isAnonymous: !0,
+        zIndex: -1,
+        sprite: i,
+        color: new h.Color(t.broadcaster.info.color)
+      });
+      v.add(e * c, () => {
+        this.addRaider(d), d.spawn({ isFalling: !0 });
+      }), v.add(c * e + 3e4, () => {
+        d.despawn({
+          onComplete: () => {
+            this.deleteRaider(d);
+          }
+        });
+      });
+    }
+    const n = this.viewers[t.broadcaster.id], o = {
+      ...this.prepareEvotarProps(
+        t.broadcaster.info.displayName,
+        t.broadcaster.info.color
+      ),
+      scale: 8
+    }, r = () => {
+      const c = new f(o);
+      this.addViewer(t.broadcaster.id, c), c.spawn({ isFalling: !0, positionX: 0.5 });
+    };
+    this.lastEvotarActivity[t.broadcaster.id] = performance.now(), n ? n.despawn({
+      onComplete: () => {
+        r();
+      }
+    }) : r();
+  }
+  processChatters(t) {
+    for (const e in this.viewers) {
+      const i = this.lastEvotarActivity[e], n = !!i && performance.now() - i < G;
+      if (t.every((o) => o.userId != e) && !n) {
+        const o = this.viewers[e];
+        o && o.despawn({
+          onComplete: () => {
+            this.deleteViewer(e, o);
+          }
+        });
+      }
+    }
+    if (p.settings.showAnonymousEvotars) {
+      for (const e of t)
+        if (!this.viewers[e.userId]) {
+          const n = {
+            name: e.name,
+            isAnonymous: !this.hasActivity(e.userId)
+          }, o = new f(n);
+          o.spawn(), this.addViewer(e.userId, o);
+        }
+    }
+  }
+  doAction(t, e) {
+    if (F(t) && e.jump({
+      velocityX: t.data.velocityX,
+      velocityY: t.data.velocityY,
+      cooldown: t.cooldown
+    }), j(t) && e.dash({ force: t.data.force, cooldown: t.cooldown }), L(t)) {
+      const i = D(t.data.color);
+      i && i.isValid() && e.setUserProps({ color: new h.Color(t.data.color) });
+    }
+    V(t) && e.scale({
+      value: t.data.scale,
+      duration: t.data.duration,
+      cooldown: t.cooldown
+    });
+  }
+  prepareEvotarProps(t, e, i) {
+    const n = {
+      name: t,
+      isAnonymous: !1
+    }, o = i ? C.sprites[i] : null;
+    return o && (n.sprite = o), e && (n.color = new h.Color(e)), n;
+  }
+  processAction(t) {
+    const e = this.viewers[t.userId], i = this.prepareEvotarProps(
+      t.info.displayName,
+      t.info.color,
+      t.info.sprite
+    );
+    if (e)
+      this.doAction(t, e), e.setProps(i);
+    else {
+      const n = new f(i);
+      n.spawn({
+        onComplete: () => {
+          const o = this.viewers[t.userId];
+          o && this.doAction(t, o);
+        }
+      }), this.addViewer(t.userId, n);
+    }
+  }
+  processMessage(t) {
+    const e = this.prepareEvotarProps(
+      t.info.displayName,
+      t.info.color,
+      t.info.sprite
+    );
+    let i = this.viewers[t.userId];
+    if (i)
+      i.setProps(e);
+    else {
+      const n = p.settings.fallingEvotars ? !this.hasActivity(t.userId) : !1;
+      i = new f(e), i.spawn({ isFalling: n }), this.addViewer(t.userId, i);
+    }
+    this.lastEvotarActivity[t.userId] = performance.now(), t.message && i.addMessage(t.message), t.emotes.length > 0 && i.spitEmotes(t.emotes);
+  }
+  addViewer(t, e) {
+    this.subscriptions.forEach((i) => i.onAdd(e)), this.viewers[t] = e;
+  }
+  deleteViewer(t, e) {
+    this.subscriptions.forEach((i) => i.onDelete(e)), delete this.viewers[t];
+  }
+  addRaider(t) {
+    this.subscriptions.forEach((e) => e.onAdd(t)), this.raiders.push(t);
+  }
+  deleteRaider(t) {
+    this.subscriptions.forEach((e) => e.onDelete(t)), this.raiders = this.raiders.filter((e) => e != t);
+  }
+  zIndexEvotarMax(t) {
+    return Object.values(this.viewers).reduce((e, i) => i && e <= i.container.zIndex ? i.container.zIndex + 1 : e, t);
+  }
+  zIndexEvotarMin(t) {
+    return Object.values(this.viewers).reduce((e, i) => i && e >= i.container.zIndex ? i.container.zIndex - 1 : e, t);
+  }
+}
+const u = new N();
+class Y {
+  constructor() {
+    s(this, "stage", new h.Container());
+    s(this, "evotars", {});
+    s(this, "chatterIds", []);
+    s(this, "settings", {});
+    s(this, "renderer");
+  }
+  async init(t, e) {
+    await T.load(t.manifest), E.init(t.sound), this.renderer = new h.Renderer({
+      width: e.clientWidth,
+      height: e.clientHeight,
+      backgroundAlpha: 0
+    }), e.appendChild(this.renderer.view), window.onresize = () => {
+      this.renderer.resize(e.clientWidth, e.clientHeight);
+    }, this.stage.sortableChildren = !0, u.subscribe({
+      onAdd: (i) => this.stage.addChild(i.container),
+      onDelete: (i) => {
+        this.stage.removeChild(i.container), this.stage.removeChild(i.trail.container);
+      }
+    });
+  }
+  updateSettings(t) {
+    this.settings = t;
+  }
+  update() {
+    v.tick(), u.update(), this.renderer.render(this.stage);
+  }
+}
+const p = new Y();
+class K {
+  constructor(t) {
+    s(this, "isRendered", !1);
+    s(this, "processMessage", (t) => u.processMessage(t));
+    s(this, "processAction", (t) => u.processAction(t));
+    s(this, "processChatters", (t) => u.processChatters(t));
+    s(this, "processRaid", (t) => u.processRaid(t));
+    this.root = t;
+  }
+  updateSettings(t) {
+    p.updateSettings(t);
+  }
+  async run(t) {
+    if (this.isRendered)
+      return;
+    this.isRendered = !0, await (async () => {
+      await p.init(t, this.root), performance.now();
+      let i = -1;
+      const o = 1e3 / 60;
+      requestAnimationFrame(r);
+      function r(c = performance.now()) {
+        const d = c - i | 0;
+        d > o && (i = c - d % o, p.update()), requestAnimationFrame(r);
+      }
+    })();
+  }
+}
+export {
+  K as Evotars
+};