@kbve/laser 0.0.8 → 0.1.2

package/laser.es.js

@@ -0,0 +1,872 @@
+import { jsxs as I, jsx as D } from "react/jsx-runtime";
+import { createContext as v, useContext as O, forwardRef as K, useRef as g, useState as j, useImperativeHandle as L, useEffect as R, useMemo as N } from "react";
+import x from "phaser";
+import { Canvas as q, useFrame as F } from "@react-three/fiber";
+import { query as P } from "bitecs";
+export * from "bitecs";
+import { RAPIER as Ht, createRapierPhysics as zt } from "@phaserjs/rapier-connector";
+class S {
+  handlers = /* @__PURE__ */ new Map();
+  on(t, e) {
+    let i = this.handlers.get(t);
+    return i || (i = /* @__PURE__ */ new Set(), this.handlers.set(t, i)), i.add(e), () => {
+      i.delete(e);
+    };
+  }
+  off(t, e) {
+    this.handlers.get(t)?.delete(e);
+  }
+  emit(t, e) {
+    this.handlers.get(t)?.forEach((i) => {
+      i(e);
+    });
+  }
+  clear() {
+    this.handlers.clear();
+  }
+}
+const E = new S();
+class M {
+  bounds;
+  capacity;
+  points;
+  divided;
+  cache;
+  northeast;
+  northwest;
+  southeast;
+  southwest;
+  constructor(t, e = 4) {
+    this.bounds = t, this.capacity = e, this.points = [], this.divided = !1, this.cache = /* @__PURE__ */ new Map();
+  }
+  subdivide() {
+    const { xMin: t, yMin: e, xMax: i, yMax: n } = this.bounds, r = (i - t) / 2, a = (n - e) / 2, o = t, h = e;
+    this.northeast = new M(
+      { xMin: o + r, xMax: o + 2 * r, yMin: e, yMax: h + a },
+      this.capacity
+    ), this.northwest = new M(
+      { xMin: t, xMax: o + r, yMin: e, yMax: h + a },
+      this.capacity
+    ), this.southeast = new M(
+      { xMin: o + r, xMax: o + 2 * r, yMin: h + a, yMax: h + 2 * a },
+      this.capacity
+    ), this.southwest = new M(
+      { xMin: t, xMax: o + r, yMin: h + a, yMax: h + 2 * a },
+      this.capacity
+    ), this.divided = !0;
+  }
+  insert(t) {
+    return this.contains(t.bounds) ? this.points.length < this.capacity ? (this.points.push(t), !0) : (this.divided || this.subdivide(), !!(this.northeast?.insert(t) || this.northwest?.insert(t) || this.southeast?.insert(t) || this.southwest?.insert(t))) : !1;
+  }
+  contains(t) {
+    const { xMin: e, yMin: i, xMax: n, yMax: r } = this.bounds;
+    return t.xMin >= e && t.xMax <= n && t.yMin >= i && t.yMax <= r;
+  }
+  queryRange(t, e = []) {
+    if (!this.intersects(t))
+      return e;
+    for (const i of this.points)
+      this.isWithinBounds(i.bounds, t) && e.push(i);
+    return this.divided && (this.northwest?.queryRange(t, e), this.northeast?.queryRange(t, e), this.southwest?.queryRange(t, e), this.southeast?.queryRange(t, e)), e;
+  }
+  query(t, e = []) {
+    const i = `${t.x},${t.y}`, n = this.cache.get(i);
+    if (n)
+      return n;
+    if (!this.intersects({
+      xMin: t.x,
+      xMax: t.x,
+      yMin: t.y,
+      yMax: t.y
+    }))
+      return e;
+    for (const r of this.points)
+      this.isWithinRange(t, r.bounds) && e.push(r);
+    return this.divided && (this.northwest?.query(t, e), this.northeast?.query(t, e), this.southwest?.query(t, e), this.southeast?.query(t, e)), this.cache.set(i, e), e;
+  }
+  intersects(t) {
+    const { xMin: e, yMin: i, xMax: n, yMax: r } = this.bounds;
+    return !(t.xMin > n || t.xMax < e || t.yMin > r || t.yMax < i);
+  }
+  isWithinBounds(t, e) {
+    return t.xMax >= e.xMin && t.xMin <= e.xMax && t.yMax >= e.yMin && t.yMin <= e.yMax;
+  }
+  isWithinRange(t, e) {
+    return t.x >= e.xMin && t.x <= e.xMax && t.y >= e.yMin && t.y <= e.yMax;
+  }
+}
+const T = v(null);
+function U() {
+  const s = O(T);
+  if (!s)
+    throw new Error(
+      "usePhaserGame must be used within a <PhaserGame> component"
+    );
+  return s;
+}
+const lt = K(
+  function({ config: t, onReady: e, onDestroy: i, className: n, style: r, children: a }, o) {
+    const h = g(null), c = g(null), p = g(null), [l, u] = j("idle");
+    L(
+      o,
+      () => ({
+        game: c.current,
+        status: l
+      }),
+      [l]
+    ), R(() => {
+      if (!h.current) return;
+      const m = h.current;
+      if (p.current !== null && (window.clearTimeout(p.current), p.current = null), c.current) {
+        const f = c.current.canvas;
+        return f && f.parentElement !== m && m.appendChild(f), u(c.current.isBooted ? "running" : "booting"), w;
+      }
+      u("booting");
+      const k = {
+        type: x.AUTO,
+        width: t.width ?? 800,
+        height: t.height ?? 600,
+        parent: m,
+        scene: t.scenes,
+        backgroundColor: t.backgroundColor,
+        transparent: t.transparent,
+        ...t.physics && { physics: t.physics },
+        ...t.plugins && { plugins: t.plugins },
+        ...t.scale && { scale: t.scale },
+        ...t.input && { input: t.input },
+        ...t.render || t.pixelArt ? {
+          render: t.pixelArt ? {
+            pixelArt: !0,
+            antialias: !1,
+            ...t.render
+          } : t.render
+        } : {},
+        ...t.dom && { dom: t.dom },
+        ...t.audio && { audio: t.audio },
+        ...t.callbacks && { callbacks: t.callbacks },
+        ...t.fps && { fps: t.fps }
+      }, y = new x.Game(k);
+      return c.current = y, y.events.once("ready", () => {
+        c.current === y && (u("running"), E.emit("game:ready", { game: y }), e?.(y));
+      }), w;
+      function w() {
+        p.current = window.setTimeout(() => {
+          p.current = null;
+          const f = c.current;
+          f && (u("destroyed"), E.emit("game:destroy", void 0), i?.(), f.destroy(!0), c.current = null);
+        }, 0);
+      }
+    }, [t, e, i]);
+    const d = N(
+      () => ({ game: c.current, status: l }),
+      [l]
+    );
+    return /* @__PURE__ */ I(T.Provider, { value: d, children: [
+      /* @__PURE__ */ D("div", { ref: h, className: n, style: r }),
+      a
+    ] });
+  }
+);
+function dt(s, t, e) {
+  const { game: i } = U(), n = g(t);
+  n.current = t, R(() => {
+    if (!i) return;
+    const r = (...a) => n.current(...a);
+    if (e) {
+      const a = i.scene.getScene(e);
+      if (a)
+        return a.events.on(s, r), () => {
+          a.events.off(s, r);
+        };
+    } else
+      return i.events.on(s, r), () => {
+        i.events.off(s, r);
+      };
+  }, [i, s, e]);
+}
+class W {
+  scene;
+  base;
+  thumb;
+  radius;
+  deadZone;
+  _direction = null;
+  _isActive = !1;
+  fixed;
+  activePointer = null;
+  constructor(t, e) {
+    this.scene = t, this.radius = e?.radius ?? 60, this.deadZone = e?.deadZone ?? 0.25, this.fixed = e?.fixed ?? !0;
+    const i = e?.x ?? 120, n = e?.y ?? t.scale.height - 120;
+    this.base = t.add.circle(
+      i,
+      n,
+      this.radius,
+      e?.baseColor ?? 8947848,
+      e?.baseAlpha ?? 0.35
+    ).setDepth(100).setScrollFactor(0), this.thumb = t.add.circle(
+      i,
+      n,
+      this.radius * 0.4,
+      e?.thumbColor ?? 16777215,
+      e?.thumbAlpha ?? 0.5
+    ).setDepth(101).setScrollFactor(0), this.setupInput();
+  }
+  setupInput() {
+    this.scene.input.on("pointerdown", (t) => {
+      if (this.activePointer) return;
+      const e = t.x - this.base.x, i = t.y - this.base.y, n = Math.sqrt(e * e + i * i);
+      this.fixed && n > this.radius * 2 || (this.fixed || (this.base.setPosition(t.x, t.y), this.thumb.setPosition(t.x, t.y)), this.activePointer = t, this._isActive = !0);
+    }), this.scene.input.on("pointermove", (t) => {
+      t === this.activePointer && this.updateThumb(t.x, t.y);
+    }), this.scene.input.on("pointerup", (t) => {
+      t === this.activePointer && this.resetThumb();
+    });
+  }
+  updateThumb(t, e) {
+    const i = t - this.base.x, n = e - this.base.y, r = Math.sqrt(i * i + n * n), a = Math.min(r, this.radius), o = Math.atan2(n, i);
+    if (this.thumb.setPosition(
+      this.base.x + Math.cos(o) * a,
+      this.base.y + Math.sin(o) * a
+    ), a / this.radius < this.deadZone) {
+      this._direction = null;
+      return;
+    }
+    this._direction = this.angleToDirection(o);
+  }
+  angleToDirection(t) {
+    let e = t * 180 / Math.PI;
+    return e < 0 && (e += 360), e >= 337.5 || e < 22.5 ? "right" : e >= 22.5 && e < 67.5 ? "down-right" : e >= 67.5 && e < 112.5 ? "down" : e >= 112.5 && e < 157.5 ? "down-left" : e >= 157.5 && e < 202.5 ? "left" : e >= 202.5 && e < 247.5 ? "up-left" : e >= 247.5 && e < 292.5 ? "up" : "up-right";
+  }
+  resetThumb() {
+    this.thumb.setPosition(this.base.x, this.base.y), this._direction = null, this._isActive = !1, this.activePointer = null;
+  }
+  get direction() {
+    return this._direction;
+  }
+  get isActive() {
+    return this._isActive;
+  }
+  setVisible(t) {
+    return this.base.setVisible(t), this.thumb.setVisible(t), this;
+  }
+  destroy() {
+    this.base.destroy(), this.thumb.destroy();
+  }
+}
+class pt {
+  scene;
+  gridEngine;
+  quadtree;
+  cursor;
+  wasdKeys;
+  tooltip;
+  tileSize;
+  playerId;
+  joystick = null;
+  constructor(t, e, i, n) {
+    if (this.scene = t, this.gridEngine = e, this.quadtree = i, this.tileSize = n?.tileSize ?? 48, this.playerId = n?.playerId ?? "player", this.cursor = this.scene.input.keyboard?.createCursorKeys(), this.initializeWASDKeys(), this.tooltip = this.scene.add.text(0, 0, "Press [F]", {
+      font: "16px Arial",
+      backgroundColor: "#000000"
+    }).setDepth(4).setPadding(3, 2, 2, 3).setVisible(!1), n?.joystick) {
+      const r = typeof n.joystick == "object" ? n.joystick : void 0;
+      this.joystick = new W(t, r);
+    }
+  }
+  initializeWASDKeys() {
+    const t = this.scene.input.keyboard;
+    t && (this.wasdKeys = {
+      W: t.addKey(x.Input.Keyboard.KeyCodes.W),
+      A: t.addKey(x.Input.Keyboard.KeyCodes.A),
+      S: t.addKey(x.Input.Keyboard.KeyCodes.S),
+      D: t.addKey(x.Input.Keyboard.KeyCodes.D)
+    });
+  }
+  checkForNearbyObjects() {
+    const t = this.gridEngine.getPosition(this.playerId), e = t.x * this.tileSize, i = t.y * this.tileSize, n = this.quadtree.query(t);
+    n.length > 0 ? (this.tooltip.setPosition(e, i - 60).setVisible(!0), E.emit("player:nearby", {
+      position: t,
+      ranges: n
+    })) : this.tooltip.setVisible(!1);
+  }
+  getPlayerPosition() {
+    return this.gridEngine.getPosition(this.playerId);
+  }
+  handleMovement() {
+    if (this.scene.input.keyboard?.addKey("F").isDown) {
+      const i = this.gridEngine.getPosition(
+        this.playerId
+      ), n = this.quadtree.query(i);
+      if (n.length > 0) {
+        E.emit("player:interact", {
+          position: i,
+          ranges: n
+        });
+        for (const r of n)
+          r.action();
+      }
+    }
+    if (this.joystick?.isActive && this.joystick.direction) {
+      this.gridEngine.move(this.playerId, this.joystick.direction), this.checkForNearbyObjects();
+      return;
+    }
+    if (!this.cursor) {
+      this.checkForNearbyObjects();
+      return;
+    }
+    const t = this.cursor, e = this.wasdKeys;
+    (t.left.isDown || e.A.isDown) && (t.up.isDown || e.W.isDown) ? this.gridEngine.move(this.playerId, "up-left") : (t.left.isDown || e.A.isDown) && (t.down.isDown || e.S.isDown) ? this.gridEngine.move(this.playerId, "down-left") : (t.right.isDown || e.D.isDown) && (t.up.isDown || e.W.isDown) ? this.gridEngine.move(this.playerId, "up-right") : (t.right.isDown || e.D.isDown) && (t.down.isDown || e.S.isDown) ? this.gridEngine.move(this.playerId, "down-right") : t.left.isDown || e.A.isDown ? this.gridEngine.move(this.playerId, "left") : t.right.isDown || e.D.isDown ? this.gridEngine.move(this.playerId, "right") : t.up.isDown || e.W.isDown ? this.gridEngine.move(this.playerId, "up") : (t.down.isDown || e.S.isDown) && this.gridEngine.move(this.playerId, "down"), this.checkForNearbyObjects();
+  }
+}
+function mt(s, t, e = 16739179) {
+  t.setTint(16777215).setTintMode(x.TintModes.FILL), s.time.delayedCall(60, () => t.setTint(e)), s.time.delayedCall(180, () => {
+    t.clearTint(), t.setTintMode(x.TintModes.MULTIPLY);
+  });
+}
+function yt(s, t, e, i, n, r) {
+  const a = s.add.text(t, e, i, {
+    fontFamily: "monospace",
+    fontSize: "14px",
+    color: n,
+    stroke: "#000000",
+    strokeThickness: 3
+  }).setOrigin(0.5, 1).setDepth(r);
+  return s.tweens.add({
+    targets: a,
+    y: e - 28,
+    alpha: 0,
+    duration: 900,
+    ease: "Cubic.easeOut",
+    onComplete: () => a.destroy()
+  }), a;
+}
+function ft(s, t, e, i, n, r = 26) {
+  const a = Math.max(0, Math.min(1, i / n));
+  s.clear(), s.fillStyle(0, 0.6), s.fillRect(t - r / 2, e, r, 4), s.fillStyle(a > 0.5 ? 4906624 : a > 0.25 ? 16498468 : 16281969, 1), s.fillRect(t - r / 2 + 0.5, e + 0.5, (r - 1) * a, 3);
+}
+function xt(s, { min: t = 0.6, max: e = 2.2, step: i = 0.2 } = {}) {
+  const n = (r) => {
+    const a = s.cameras.main;
+    a.setZoom(x.Math.Clamp(a.zoom + r, t, e));
+  };
+  s.input.keyboard?.on("keydown-PLUS", () => n(i)), s.input.keyboard?.on("keydown-MINUS", () => n(-i)), s.input.on(
+    "wheel",
+    (r, a, o, h) => n(h > 0 ? -i * 0.75 : i * 0.75)
+  );
+}
+function bt(s, t, e, i = 64) {
+  if (s.x === t.x && s.y === t.y || e(t.x, t.y))
+    return [];
+  const n = (d, m) => `${d},${m}`, r = /* @__PURE__ */ new Map();
+  r.set(n(s.x, s.y), null);
+  const a = [s], o = [
+    [0, -1],
+    [0, 1],
+    [-1, 0],
+    [1, 0]
+  ], h = (i * 2 + 1) ** 2;
+  let c = 0, p = !1;
+  for (; a.length; ) {
+    if (++c > h) return [];
+    const d = a.shift();
+    if (d.x === t.x && d.y === t.y) {
+      p = !0;
+      break;
+    }
+    for (const [m, k] of o) {
+      const y = d.x + m, w = d.y + k, f = n(y, w);
+      r.has(f) || e(y, w) || (r.set(f, n(d.x, d.y)), a.push({ x: y, y: w }));
+    }
+  }
+  if (!p) return [];
+  const l = [];
+  let u = n(t.x, t.y);
+  for (; u && u !== n(s.x, s.y); ) {
+    const [d, m] = u.split(",").map(Number);
+    if (l.push({ x: d, y: m }), u = r.get(u) ?? null, l.length > i) return [];
+  }
+  return l.reverse(), l;
+}
+function wt(s) {
+  return +s[s.length - 1];
+}
+function Mt(s) {
+  return s.startsWith("monster_bird_") && !s.startsWith("monster_bird_shadow");
+}
+function C(s, t, e, i, n) {
+  const r = [];
+  for (let a = 0; a < 10; a++) {
+    const o = s.add.sprite(0, 0, "monster_bird");
+    o.setCrop(t, e, i, n), o.scale = 3, r.push(o);
+  }
+  return r;
+}
+function gt(s) {
+  return C(s, 0, 0, 61, 47);
+}
+function Et(s) {
+  return C(s, 22, 47, 16, 10);
+}
+function kt(s) {
+  s.anims.create({
+    key: "bird",
+    frames: s.anims.generateFrameNumbers("monster_bird", {
+      start: 0,
+      end: 2
+    }),
+    frameRate: 10,
+    repeat: -1,
+    yoyo: !0
+  });
+}
+const St = ({
+  children: s,
+  className: t,
+  ...e
+}) => /* @__PURE__ */ I(
+  q,
+  {
+    camera: { position: [0, 0, 5] },
+    ...e,
+    className: t,
+    children: [
+      /* @__PURE__ */ D("ambientLight", { intensity: 1.5 }),
+      s
+    ]
+  }
+);
+function At(s) {
+  const t = g(s);
+  t.current = s, F((e, i) => {
+    t.current(i, e.clock.elapsedTime);
+  });
+}
+function* It(s, t, e, i, n, r) {
+  const a = r * r;
+  for (const o of P(s, t)) {
+    const h = e.x[o] - i, c = e.y[o] - n;
+    h * h + c * c <= a && (yield o);
+  }
+}
+function Dt(s, t, e, i, n, r) {
+  const a = r * r;
+  let o = -1, h = a;
+  for (const c of P(s, t)) {
+    const p = e.x[c] - i, l = e.y[c] - n, u = p * p + l * l;
+    u <= h && (h = u, o = c);
+  }
+  return o >= 0 ? o : null;
+}
+class Rt {
+  map = /* @__PURE__ */ new Map();
+  set(t, e) {
+    this.map.set(t, e);
+  }
+  get(t) {
+    return this.map.get(t);
+  }
+  delete(t) {
+    const e = this.map.get(t);
+    return this.map.delete(t), e;
+  }
+  has(t) {
+    return this.map.has(t);
+  }
+  values() {
+    return this.map.values();
+  }
+  entries() {
+    return this.map.entries();
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+}
+const H = 1e3, z = 15e3;
+function B(s, t, e) {
+  const i = t.trim();
+  return e ? s === 1e3 ? "disconnected" : i || `server dropped connection (code ${s})` : s === 1006 ? "cannot reach server — down or rejected" : i || `connection refused (code ${s})`;
+}
+class _ {
+  ws = null;
+  closed = !1;
+  attempts = 0;
+  everOpened = !1;
+  timer = 0;
+  state = { status: "connecting", attempts: 0 };
+  opts;
+  handlers;
+  constructor(t, e) {
+    this.opts = {
+      maxAttempts: 0,
+      baseDelayMs: H,
+      maxDelayMs: z,
+      closeReason: B,
+      ...t
+    }, this.handlers = e;
+  }
+  getState() {
+    return this.state;
+  }
+  isOpen() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  send(t) {
+    this.isOpen() && this.ws.send(t);
+  }
+  connect() {
+    if (this.ws || this.closed) return;
+    this.everOpened = !1, this.setState({
+      status: this.attempts === 0 ? "connecting" : "reconnecting",
+      attempts: this.attempts,
+      reason: this.state.reason
+    });
+    const t = typeof this.opts.url == "function" ? this.opts.url() : this.opts.url, e = new WebSocket(t);
+    this.ws = e, e.addEventListener("open", () => {
+      this.attempts = 0, this.everOpened = !0, this.setState({ status: "connected", attempts: 0 }), this.handlers.onOpen?.(e);
+    }), e.addEventListener(
+      "message",
+      (i) => this.handlers.onMessage?.(i)
+    ), e.addEventListener("close", (i) => {
+      this.ws = null;
+      const n = this.opts.closeReason(
+        i.code,
+        i.reason,
+        this.everOpened
+      );
+      if (this.closed) {
+        this.setState({ status: "closed", attempts: this.attempts });
+        return;
+      }
+      if (this.opts.shouldReconnect && !this.opts.shouldReconnect()) {
+        this.setState({
+          status: "closed",
+          attempts: this.attempts,
+          reason: n
+        });
+        return;
+      }
+      if (this.attempts += 1, this.opts.maxAttempts > 0 && this.attempts > this.opts.maxAttempts) {
+        this.setState({
+          status: "closed",
+          attempts: this.attempts,
+          reason: n
+        });
+        return;
+      }
+      const r = Math.min(
+        this.opts.baseDelayMs * 2 ** (this.attempts - 1),
+        this.opts.maxDelayMs
+      );
+      this.setState({
+        status: "reconnecting",
+        attempts: this.attempts,
+        reason: n,
+        nextRetryMs: r
+      }), this.timer = window.setTimeout(() => this.connect(), r);
+    });
+  }
+  close() {
+    this.closed = !0, window.clearTimeout(this.timer), this.ws?.close(), this.ws = null, this.setState({ status: "closed", attempts: this.attempts });
+  }
+  setState(t) {
+    this.state = t, this.handlers.onState?.(t);
+  }
+}
+const J = 9, Pt = 1, Tt = 2, V = 1, $ = 2, G = 3, Z = 5, Y = 6, X = 7, Ct = 8, _t = 9, Q = 10, tt = 11, vt = 0, Ot = 1, Kt = 2, et = ["spades", "hearts", "diamonds", "clubs"], st = [
+  "A",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "10",
+  "J",
+  "Q",
+  "K"
+], it = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10];
+function jt(s) {
+  const t = s & 15, e = s >> 4 & 3;
+  return {
+    suit: et[e],
+    rank: st[t],
+    points: it[t],
+    red: e === 1 || e === 2
+  };
+}
+const Lt = 65535;
+function b(s) {
+  try {
+    return JSON.parse(
+      new TextDecoder().decode(Uint8Array.from(s))
+    );
+  } catch {
+    return null;
+  }
+}
+function nt(s, t) {
+  return {
+    JoinMatch: {
+      protocol: J,
+      jwt: s,
+      kbve_username: t
+    }
+  };
+}
+function rt(s, t) {
+  return { Frame: { client_tick: s, inputs: t } };
+}
+class Nt {
+  clientTick = 0;
+  terminal = !1;
+  bus = new S();
+  opts;
+  socket;
+  constructor(t) {
+    this.opts = t, this.socket = new _(
+      {
+        url: t.url,
+        maxAttempts: t.maxReconnects ?? 3,
+        baseDelayMs: 1500,
+        shouldReconnect: () => !this.terminal
+      },
+      {
+        onOpen: () => {
+          this.send(nt(this.opts.jwt, this.opts.kbveUsername)), this.bus.emit("open", void 0);
+        },
+        onMessage: (e) => this.handleMessage(e),
+        onState: (e) => {
+          this.bus.emit("state", e), e.status === "closed" && this.bus.emit("close", void 0);
+        }
+      }
+    );
+  }
+  on(t, e) {
+    return this.bus.on(t, e);
+  }
+  getState() {
+    return this.socket.getState();
+  }
+  connect() {
+    this.socket.connect();
+  }
+  /** Stop reconnecting — the server turned us away for good. */
+  markTerminal() {
+    this.terminal = !0;
+  }
+  handleMessage(t) {
+    let e;
+    try {
+      e = JSON.parse(
+        typeof t.data == "string" ? t.data : String(t.data)
+      );
+    } catch {
+      return;
+    }
+    "Welcome" in e ? this.bus.emit("welcome", e.Welcome) : "Snapshot" in e ? this.bus.emit("snapshot", e.Snapshot) : "Ephemeral" in e ? this.handleEphemeral(e.Ephemeral) : "Reject" in e && (this.terminal = !0, this.bus.emit("reject", e.Reject.reason));
+  }
+  handleEphemeral(t) {
+    if (this.bus.emit("ephemeral", t), t.kind === V) {
+      const e = b(t.payload);
+      e && this.bus.emit("inventory", e);
+    } else if (t.kind === $) {
+      const e = b(t.payload);
+      e && this.bus.emit("combat", e);
+    } else if (t.kind === G) {
+      const e = b(t.payload);
+      e && this.bus.emit("pickup", e);
+    } else if (t.kind === Z) {
+      const e = b(t.payload);
+      e && this.bus.emit("itemUsed", e);
+    } else if (t.kind === Y) {
+      const e = b(t.payload);
+      e && this.bus.emit("equipped", e);
+    } else if (t.kind === X) {
+      const e = b(t.payload);
+      e && this.bus.emit("stats", e);
+    } else if (t.kind === Q) {
+      const e = b(t.payload);
+      e && this.bus.emit("shop", e);
+    } else if (t.kind === tt) {
+      const e = b(
+        t.payload
+      );
+      e && this.bus.emit("blackjackState", e);
+    }
+  }
+  send(t) {
+    this.socket.send(JSON.stringify(t));
+  }
+  sendInputs(t) {
+    !this.socket.isOpen() || t.length === 0 || (this.clientTick += 1, this.send(rt(this.clientTick, t)));
+  }
+  step(t) {
+    this.sendInputs([{ Step: { dir: t } }]);
+  }
+  moveTo(t) {
+    this.sendInputs([{ MoveTo: { tile: t } }]);
+  }
+  action(t, e) {
+    this.sendInputs([{ Action: { id: t, target: e } }]);
+  }
+  heartbeat() {
+    this.sendInputs([{ Heartbeat: { client_tick: this.clientTick } }]);
+  }
+  useItem(t) {
+    this.sendInputs([{ UseItem: { item_ref: t } }]);
+  }
+  equipItem(t) {
+    this.sendInputs([{ EquipItem: { item_ref: t } }]);
+  }
+  buyItem(t, e, i) {
+    this.sendInputs([{ BuyItem: { npc: t, item_ref: e, qty: i } }]);
+  }
+  sellItem(t, e, i) {
+    this.sendInputs([{ SellItem: { npc: t, item_ref: e, qty: i } }]);
+  }
+  joinTable(t) {
+    this.sendInputs([{ JoinTable: { table_ref: t } }]);
+  }
+  leaveTable() {
+    this.sendInputs(["LeaveTable"]);
+  }
+  placeBet(t) {
+    this.sendInputs([{ PlaceBet: { amount: t } }]);
+  }
+  bjAction(t) {
+    this.sendInputs([{ BjAction: { kind: t } }]);
+  }
+  face(t) {
+    this.sendInputs([{ Face: { facing: t } }]);
+  }
+  close() {
+    this.sendInputs(["Leave"]), this.socket.close();
+  }
+}
+const A = "chat";
+class qt {
+  bus = new S();
+  opts;
+  socket;
+  constructor(t) {
+    this.opts = t, this.socket = new _(
+      {
+        url: () => {
+          const e = this.opts.url.includes("?") ? "&" : "?";
+          return `${this.opts.url}${e}game=${encodeURIComponent(
+            this.opts.game
+          )}&token=${encodeURIComponent(this.opts.jwt)}`;
+        },
+        shouldReconnect: () => !!this.opts.jwt
+      },
+      {
+        onOpen: () => this.bus.emit("open", void 0),
+        onMessage: (e) => this.handleMessage(e),
+        onState: (e) => {
+          this.bus.emit("status", e), e.status === "closed" && this.bus.emit("close", void 0);
+        }
+      }
+    );
+  }
+  on(t, e) {
+    return this.bus.on(t, e);
+  }
+  getState() {
+    return this.socket.getState();
+  }
+  connect() {
+    if (!this.opts.jwt) {
+      this.bus.emit("status", {
+        status: "closed",
+        attempts: 0,
+        reason: "missing auth token"
+      });
+      return;
+    }
+    this.socket.connect();
+  }
+  handleMessage(t) {
+    let e;
+    try {
+      e = JSON.parse(
+        typeof t.data == "string" ? t.data : String(t.data)
+      );
+    } catch {
+      return;
+    }
+    e.kind === A && (e.channel && e.channel !== this.opts.channel || this.bus.emit("message", { from: e.sender, text: e.content }));
+  }
+  send(t) {
+    const e = t.trim().slice(0, 200);
+    if (!e || !this.socket.isOpen()) return;
+    const i = {
+      kind: A,
+      sender: "",
+      platform: "",
+      channel: this.opts.channel,
+      content: e
+    };
+    this.socket.send(JSON.stringify(i));
+  }
+  close() {
+    this.socket.close();
+  }
+}
+export {
+  Pt as ACTION_ATTACK,
+  Tt as ACTION_PICKUP,
+  tt as EPHEMERAL_BLACKJACK,
+  $ as EPHEMERAL_COMBAT,
+  Y as EPHEMERAL_EQUIPPED,
+  V as EPHEMERAL_INVENTORY,
+  Z as EPHEMERAL_ITEM_USED,
+  G as EPHEMERAL_PICKUP,
+  Q as EPHEMERAL_SHOP,
+  X as EPHEMERAL_STATS,
+  Ct as EPHEMERAL_STATUS,
+  _t as EPHEMERAL_TRADE,
+  Nt as GameClient,
+  Kt as KIND_CAT_ITEM,
+  Ot as KIND_CAT_NPC,
+  vt as KIND_CAT_PLAYER,
+  S as LaserEventBus,
+  Lt as OWNER_NONE,
+  J as PROTOCOL_VERSION,
+  T as PhaserContext,
+  lt as PhaserGame,
+  pt as PlayerController,
+  M as Quadtree,
+  Ht as RAPIER,
+  qt as RealmChatClient,
+  _ as ReconnectingSocket,
+  Rt as SideMap,
+  St as Stage,
+  W as VirtualJoystick,
+  xt as attachCameraZoom,
+  kt as createBirdAnimation,
+  gt as createBirdSprites,
+  zt as createRapierPhysics,
+  Et as createShadowSprites,
+  jt as decodeCard,
+  b as decodeEphemeralPayload,
+  B as defaultCloseReason,
+  ft as drawHealthBar,
+  bt as findTilePath,
+  mt as flashEntity,
+  yt as floatingText,
+  wt as getBirdNum,
+  rt as inputFrame,
+  Mt as isBird,
+  nt as joinFrame,
+  E as laserEvents,
+  Dt as nearestInRange,
+  It as queryInRange,
+  At as useGameLoop,
+  dt as usePhaserEvent,
+  U as usePhaserGame
+};