evotars 0.0.2 → 0.0.4

package/dist/evotars.js

@@ -0,0 +1,705 @@
+var I = Object.defineProperty;
+var z = (r, t, e) => t in r ? I(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var s = (r, t, e) => (z(r, typeof t != "symbol" ? t + "" : t, e), e);
+import * as c from "pixi.js";
+import { Assets as R, Spritesheet as M, AnimatedSprite as P, SCALE_MODES as k } from "pixi.js";
+import F from "tinycolor2";
+import * as g from "@tweenjs/tween.js";
+import { Tween as T } from "@tweenjs/tween.js";
+const m = 0.02 * 1e3;
+class f {
+  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 V {
+  constructor() {
+    s(this, "timers", []);
+  }
+  add(t, e) {
+    this.timers.push(new f(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 V(), L = (r) => r.name == "jump", j = (r) => r.name == "color", J = (r) => r.name == "grow", W = (r) => r.name == "dash", O = (r) => r.name == "sprite";
+class U {
+  constructor() {
+    s(this, "assets", {});
+  }
+  async initialize(t) {
+    this.assets = Object.fromEntries(
+      Array.from(Object.entries(t ?? {})).map(([e, i]) => [e, new Audio(i.src)])
+    );
+  }
+  play(t) {
+    const e = this.assets[t];
+    e && (e.volume = 0.2, e.pause(), e.currentTime = 0, e.play());
+  }
+}
+const A = new U();
+var d = /* @__PURE__ */ ((r) => (r.Idle = "Idle", r.Jump = "Jump", r.Fall = "Fall", r.Land = "Land", r.Run = "Run", r.Die = "Die", r))(d || {});
+class X {
+  constructor() {
+    s(this, "spriteLoaderFn");
+    s(this, "sprites", {});
+  }
+  initialize(t) {
+    this.spriteLoaderFn = t;
+  }
+  async getSpriteData(t) {
+    const e = await this.spriteLoaderFn(t);
+    if (!e)
+      return;
+    if (this.sprites[t])
+      return this.sprites[t];
+    const i = await R.load(e.image), n = new M({
+      texture: i,
+      data: e.sprite
+    });
+    return await n.parse(), this.sprites[t] = {
+      sheet: n,
+      data: {
+        ...e.data,
+        scale: e.data.scale ?? 1
+      }
+    }, this.sprites[t];
+  }
+  getAnimatedSprites(t) {
+    if (!t)
+      throw Error("Sheet is not defined");
+    if (!this.sprites[t])
+      throw Error("Sprite is not loaded");
+    const e = this.sprites[t].data, i = this.sprites[t].sheet, n = {};
+    for (const a of i.data.meta.frameTags ?? []) {
+      if (!i.data.meta.layers)
+        throw Error("Layers are not defined");
+      const o = {};
+      for (const h of i.data.meta.layers) {
+        const p = [];
+        for (let u = a.from; u <= a.to; u++) {
+          const E = u.toString(), C = e.name + "_" + h.name + "_" + E, b = i.textures[C], D = i.data.frames[C].duration;
+          p.push({ texture: b, time: D });
+        }
+        const x = new P(p);
+        x.texture.baseTexture.scaleMode = k.NEAREST, o[h.name] = x;
+      }
+      a.name && (n[a.name] = o);
+    }
+    return n;
+  }
+}
+const S = new X();
+class N {
+  constructor() {
+    s(this, "container", new c.Container());
+    s(this, "emotes", []);
+    s(this, "moveSpeed", 50);
+    s(this, "alphaSpeed", 1);
+    s(this, "scaleSpeed", 0.5);
+    s(this, "timer");
+  }
+  add(t) {
+    const e = c.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 f(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 c.Container());
+    s(this, "animated", new c.Container());
+    s(this, "text", new c.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 = c.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, a, o, h;
+    if ((i = this.timer) == null || i.tick(), (n = this.showTween) == null || n.update(), (a = this.hideTween) == null || a.update(), this.isChecking && this.messageQueue.length > 0) {
+      this.isChecking = !1;
+      const p = this.messageQueue.shift();
+      p && (this.beforeShow(), this.show(p));
+    }
+    this.container.position.x = t.position.x ?? this.container.position.x, this.container.position.y = t.position.y ?? this.container.position.y;
+    const e = ((o = this.showTween) == null ? void 0 : o.isPlaying()) || ((h = this.hideTween) == null ? void 0 : h.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 c.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 T(this.animated).to(n, 500).onComplete(() => {
+      this.isChecking = !0;
+    }), this.showTween = new T(this.animated).to(i, 500).onComplete(() => {
+      this.timer = new f(1e4, () => {
+        var a;
+        (a = this.hideTween) == null || a.start();
+      });
+    }), this.showTween.start();
+  }
+}
+class G {
+  constructor() {
+    s(this, "text", new c.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 Y {
+  constructor(t) {
+    s(this, "container", new c.Container());
+    s(this, "sprites");
+    this.sprites = t, this.container.sortableChildren = !0;
+    let e = 0;
+    for (const i in this.sprites) {
+      const n = this.sprites[i];
+      this.container.addChild(n), n.zIndex = ++e, n.anchor.set(0.5, 0), n.autoUpdate = !1, n.play();
+    }
+  }
+  update(t) {
+    for (const e in this.sprites) {
+      const i = this.sprites[e];
+      if (t.play && i.update(m * 0.06), t.color) {
+        for (const n in t.color)
+          if (n == e) {
+            const a = t.color[n];
+            a && (i.alpha = a.alpha, i.tint = a);
+          }
+      }
+      t.scale.x && (i.animationSpeed = 4 / Math.abs(t.scale.x));
+    }
+    this.container.scale.set(t.scale.x, t.scale.y);
+  }
+}
+class Q {
+  constructor() {
+    s(this, "container", new c.Container());
+    s(this, "timer");
+    s(this, "sprite");
+    s(this, "opacityStep", 0.1);
+    s(this, "shadowStep", 50);
+    l.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 f(this.shadowStep);
+      const e = new c.Container();
+      if (this.sprite)
+        for (const i in this.sprite.sprites) {
+          const n = this.sprite.sprites[i], a = n.texture.clone(), o = new c.Sprite(a);
+          o.anchor.set(0.5, 0), o.alpha = n.alpha, o.tint = n.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 h = this.sprite.container.getGlobalPosition();
+          e.position.set(h.x, h.y);
+        }
+      this.container.addChild(e);
+    }
+  }
+}
+class y {
+  constructor() {
+    s(this, "container", new c.Container());
+    s(this, "userState", {});
+    s(this, "state", {
+      name: "",
+      sprite: "",
+      color: new c.Color("#969696"),
+      direction: 1,
+      scale: 1,
+      isAnonymous: !1,
+      zIndex: 0
+    });
+    s(this, "animationState", d.Idle);
+    // TODO: Refactor sprite initializing, move logic to separate file
+    s(this, "sprite");
+    s(this, "spriteData", {
+      name: "evotar",
+      collider: {
+        x: 0,
+        y: 0,
+        w: 0,
+        h: 0
+      },
+      size: { w: 0, h: 0 },
+      scale: 1,
+      flip: !1,
+      colored: []
+    });
+    s(this, "animatedSprites");
+    s(this, "trail", new Q());
+    s(this, "name", new G());
+    s(this, "message", new _(() => {
+      this.state.zIndex = w.zIndexEvotarMax(this.container.zIndex);
+    }));
+    s(this, "emoteSpitter", new N());
+    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.container.sortableChildren = !0;
+  }
+  spawn(t = { isFalling: !1 }) {
+    const e = this.spriteData.collider, i = -(e.y + e.h - this.spriteData.size.h / 2), n = t.isFalling ? i : l.renderer.height, a = this.spriteData.size.w * this.state.scale * this.spriteData.scale, o = t.positionX != null ? t.positionX * l.renderer.width : Math.random() * (l.renderer.width - a) + a / 2, h = n * this.state.scale * this.spriteData.scale;
+    if (this.container.x = o, this.container.y = h, this.state.direction = Math.random() > 0.5 ? 1 : -1, !t.isFalling) {
+      const p = w.zIndexEvotarMin(this.container.zIndex);
+      this.state.zIndex = p, this.container.alpha = 0, this.spawnTween = new g.Tween(this.container).to({ alpha: 1 }, 500).onComplete(t.onComplete).start();
+    }
+    this.stateTimer = new f(5e3, () => {
+      this.isJumping || this.setAnimationState(d.Run);
+    });
+  }
+  despawn(t = {}) {
+    this.fadeTween && this.fadeTween.isPlaying() || (this.fadeTween = new g.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 g.Tween(this).to({ state: { scale: t.value ?? 2 } }, 2e3).onComplete(() => {
+      this.scaleTimer = new f((t.duration ?? 10) * 1e3, () => {
+        this.scaleTween = new g.Tween(this).to({ state: { scale: 1 } }, 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(d.Jump), A.play("jump"));
+  }
+  dash(t) {
+    this.isDespawned || this.isDashing || (this.isDashing = !0, this.velocity.x = this.state.direction * (t.force ?? 14));
+  }
+  async setSprite(t) {
+    if (t && t != this.state.sprite) {
+      const e = await S.getSpriteData(t);
+      if (!e)
+        return;
+      this.spriteData = e.data, this.animatedSprites = S.getAnimatedSprites(t), this.setAnimationState(this.animationState, !0);
+    }
+  }
+  async setProps(t) {
+    t.sprite && await this.setSprite(t.sprite), this.state = { ...this.state, ...t };
+  }
+  setUserProps(t) {
+    this.userState = { ...this.userState, ...t };
+  }
+  move() {
+    var i;
+    const t = this.spriteData.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 f(Math.random() * 5e3, () => {
+        this.animationState == d.Idle ? this.setAnimationState(d.Run) : this.animationState == d.Run && this.setAnimationState(d.Idle);
+      })), this.animationState == d.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 = l.renderer.height, this.animationState == d.Fall && (this.setAnimationState(d.Land), this.landTimer = new f(200, () => {
+        this.setAnimationState(d.Idle), this.isJumping = !1;
+      }))), this.velocity.y > 0 && this.setAnimationState(d.Fall);
+    }
+    if (this.animationState != d.Idle || this.isDashing) {
+      const n = t.w / 2 * this.state.scale * this.spriteData.scale, a = this.container.x - n < 0, o = this.container.x + n > l.renderer.width;
+      (a || o) && (this.state.direction = -this.state.direction, this.velocity.x = -this.velocity.x, a && (e.x = n), o && (e.x = l.renderer.width - n));
+    }
+    this.container.position.set(e.x, e.y);
+  }
+  update() {
+    var e, i, n, a, o, h;
+    if (this.isDespawned)
+      return;
+    (e = this.landTimer) == null || e.tick(), (i = this.stateTimer) == null || i.tick(), (n = this.scaleTimer) == null || n.tick(), (a = this.fadeTween) == null || a.update(), (o = this.spawnTween) == null || o.update(), (h = this.scaleTween) == null || h.update(), this.container.zIndex = this.state.zIndex;
+    const t = this.spriteData.collider;
+    if (this.name.update({
+      name: this.state.name,
+      isVisible: !this.state.isAnonymous,
+      position: {
+        y: -t.h * this.state.scale * this.spriteData.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) {
+      const p = Object.fromEntries(
+        this.spriteData.colored.map((u) => [
+          u,
+          this.userState.color ? this.userState.color : this.state.color
+        ])
+      ), x = this.spriteData.flip ? this.state.direction : 1;
+      this.sprite.update({
+        color: p,
+        scale: {
+          x: x * this.state.scale * this.spriteData.scale,
+          y: this.state.scale * this.spriteData.scale
+        },
+        play: !this.isDashing
+      });
+    }
+    this.trail.update({
+      play: this.isDashing
+    });
+  }
+  isOnGround(t) {
+    return t > l.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 || !this.animatedSprites)
+      return;
+    this.animationState = t, this.sprite && this.container.removeChild(this.sprite.container);
+    const i = this.animatedSprites[this.animationState] ?? this.animatedSprites[d.Idle];
+    this.sprite = new Y(i), this.trail.setSprite(this.sprite), this.sprite.container.pivot.set(
+      0,
+      this.spriteData.collider.y + this.spriteData.collider.h
+    ), this.container.addChild(this.sprite.container);
+  }
+}
+const B = 1e3 * 60 * 5;
+class q {
+  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 (!l.settings.fallingRaiders)
+      return;
+    const e = 1 / t.viewers * 5e3;
+    for (let o = 0; o < t.viewers; o++) {
+      const h = new y();
+      h.setProps({
+        isAnonymous: !0,
+        zIndex: -1,
+        sprite: "agent",
+        color: new c.Color(t.broadcaster.info.color)
+      }), v.add(e * o, () => {
+        this.addRaider(h), h.spawn({ isFalling: !0 });
+      }), v.add(o * e + 3e4, () => {
+        h.despawn({
+          onComplete: () => {
+            this.deleteRaider(h);
+          }
+        });
+      });
+    }
+    const i = this.viewers[t.broadcaster.id], n = {
+      ...this.prepareEvotarProps(
+        t.broadcaster.info.displayName,
+        t.broadcaster.info.color
+      ),
+      scale: 8
+    }, a = () => {
+      const o = new y();
+      o.setProps(n), this.addViewer(t.broadcaster.id, o), o.spawn({ isFalling: !0, positionX: 0.5 });
+    };
+    this.lastEvotarActivity[t.broadcaster.id] = performance.now(), i ? i.despawn({
+      onComplete: () => {
+        a();
+      }
+    }) : a();
+  }
+  async processChatters(t) {
+    for (const e in this.viewers) {
+      const i = this.lastEvotarActivity[e], n = !!i && performance.now() - i < B;
+      if (t.every((a) => a.userId != e) && !n) {
+        const a = this.viewers[e];
+        a && a.despawn({
+          onComplete: () => {
+            this.deleteViewer(e, a);
+          }
+        });
+      }
+    }
+    if (l.settings.showAnonymousEvotars) {
+      for (const e of t)
+        if (!this.viewers[e.userId]) {
+          const n = {
+            name: e.name,
+            isAnonymous: !this.hasActivity(e.userId)
+          }, a = new y();
+          await a.setProps(n), a.spawn(), this.addViewer(e.userId, a);
+        }
+    }
+  }
+  doAction(t, e) {
+    if (L(t) && e.jump({
+      velocityX: t.data.velocityX,
+      velocityY: t.data.velocityY,
+      cooldown: t.cooldown
+    }), W(t) && e.dash({ force: t.data.force, cooldown: t.cooldown }), j(t)) {
+      const i = F(t.data.color);
+      i && i.isValid() && e.setUserProps({ color: new c.Color(t.data.color) });
+    }
+    J(t) && e.scale({
+      value: t.data.scale,
+      duration: t.data.duration,
+      cooldown: t.cooldown
+    }), O(t) && e.setSprite(t.data.sprite);
+  }
+  prepareEvotarProps(t, e, i) {
+    const n = {
+      name: t,
+      isAnonymous: !1
+    };
+    if (i && (n.sprite = i), e)
+      try {
+        n.color = new c.Color(e);
+      } catch {
+      }
+    return n;
+  }
+  async processAction(t) {
+    const e = this.viewers[t.userId], i = this.prepareEvotarProps(
+      t.info.displayName,
+      t.info.color,
+      t.info.sprite
+    );
+    if (e)
+      await e.setProps(i), this.doAction(t, e);
+    else {
+      const n = new y();
+      await n.setProps(i), n.spawn({
+        onComplete: () => {
+          const a = this.viewers[t.userId];
+          a && this.doAction(t, a);
+        }
+      }), this.addViewer(t.userId, n);
+    }
+  }
+  async 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 = l.settings.fallingEvotars ? !this.hasActivity(t.userId) : !1;
+      i = new y(), await i.setProps(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 w = new q();
+class H {
+  constructor() {
+    s(this, "stage", new c.Container());
+    s(this, "evotars", {});
+    s(this, "chatterIds", []);
+    s(this, "settings", {});
+    s(this, "renderer");
+  }
+  async initialize(t, e) {
+    S.initialize(e.spriteLoaderFn), A.initialize(e.sounds), this.renderer = new c.Renderer({
+      width: t.clientWidth,
+      height: t.clientHeight,
+      backgroundAlpha: 0
+    }), t.appendChild(this.renderer.view), window.onresize = () => {
+      this.renderer.resize(t.clientWidth, t.clientHeight);
+    }, this.stage.sortableChildren = !0, w.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(), w.update(), this.renderer.render(this.stage);
+  }
+}
+const l = new H();
+class et {
+  constructor(t, e) {
+    s(this, "isRendered", !1);
+    s(this, "processMessage", (t) => w.processMessage(t));
+    s(this, "processAction", (t) => w.processAction(t));
+    s(this, "processChatters", (t) => w.processChatters(t));
+    s(this, "processRaid", (t) => w.processRaid(t));
+    this.root = t, this.options = e;
+  }
+  updateSettings(t) {
+    l.updateSettings(t);
+  }
+  async run() {
+    if (this.isRendered)
+      return;
+    this.isRendered = !0, await (async () => {
+      await l.initialize(this.root, this.options), performance.now();
+      let e = -1;
+      const n = 1e3 / 60;
+      requestAnimationFrame(a);
+      function a(o = performance.now()) {
+        const h = o - e | 0;
+        h > n && (e = o - h % n, l.update()), requestAnimationFrame(a);
+      }
+    })();
+  }
+}
+export {
+  et as Evotars
+};