mudlet-map-renderer 0.0.25 → 0.1.1-konva

package/dist/index.mjs

@@ -0,0 +1,1074 @@
+import u from "konva";
+const _ = ["north", "south", "east", "west", "northeast", "northwest", "southeast", "southwest"], w = {
+  north: "n",
+  south: "s",
+  east: "e",
+  west: "w",
+  northeast: "ne",
+  northwest: "nw",
+  southeast: "se",
+  southwest: "sw",
+  up: "u",
+  down: "d",
+  in: "i",
+  out: "o"
+}, M = {
+  north: { x: 0, y: -1 },
+  south: { x: 0, y: 1 },
+  east: { x: 1, y: 0 },
+  west: { x: -1, y: 0 },
+  northeast: { x: 1, y: -1 },
+  northwest: { x: -1, y: -1 },
+  southeast: { x: 1, y: 1 },
+  southwest: { x: -1, y: 1 }
+}, L = [
+  "north",
+  "south",
+  "east",
+  "west",
+  "northeast",
+  "northwest",
+  "southeast",
+  "southwest"
+], j = {
+  north: "south",
+  south: "north",
+  east: "west",
+  west: "east",
+  northeast: "southwest",
+  northwest: "southeast",
+  southeast: "northwest",
+  southwest: "northeast"
+};
+function X(a) {
+  return a ? Object.prototype.hasOwnProperty.call(M, a) : !1;
+}
+function p(a, e, t, s = 1) {
+  if (!X(t))
+    return { x: a, y: e };
+  const r = M[t];
+  return {
+    x: a + r.x * s,
+    y: e + r.y * s
+  };
+}
+const y = {
+  OPEN_DOOR: "rgb(10, 155, 10)",
+  CLOSED_DOOR: "rgb(226, 205, 59)",
+  LOCKED_DOOR: "rgb(155, 10, 10)"
+}, F = {
+  1: "north",
+  2: "northeast",
+  3: "northwest",
+  4: "east",
+  5: "west",
+  6: "south",
+  7: "southeast",
+  8: "southwest",
+  9: "up",
+  10: "down",
+  11: "in",
+  12: "out"
+}, Z = ["up", "down", "in", "out"];
+function G(a) {
+  switch (a) {
+    case 1:
+      return y.OPEN_DOOR;
+    case 2:
+      return y.CLOSED_DOOR;
+    default:
+      return y.LOCKED_DOOR;
+  }
+}
+class H {
+  constructor(e) {
+    this.mapReader = e;
+  }
+  render(e) {
+    return e.aDir && e.bDir ? this.renderTwoWayExit(e) : this.renderOneWayExit(e);
+  }
+  renderTwoWayExit(e) {
+    const t = this.mapReader.getRoom(e.a), s = this.mapReader.getRoom(e.b);
+    if (!t || !s || !e.aDir || !e.bDir)
+      return;
+    const r = new u.Group(), i = [];
+    if (i.push(...Object.values(p(t.x, t.y, e.aDir, c.roomSize / 2))), i.push(...Object.values(p(s.x, s.y, e.bDir, c.roomSize / 2))), t.doors[w[e.aDir]] || s.doors[w[e.bDir]]) {
+      const n = this.renderDoor(i, t.doors[w[e.aDir]] ?? s.doors[w[e.bDir]]);
+      r.add(n);
+    }
+    const o = new u.Line({
+      points: i,
+      stroke: c.lineColor,
+      strokeWidth: 0.025
+    });
+    return r.add(o), r;
+  }
+  renderOneWayExit(e) {
+    const t = e.aDir ? this.mapReader.getRoom(e.a) : this.mapReader.getRoom(e.b), s = e.aDir ? this.mapReader.getRoom(e.b) : this.mapReader.getRoom(e.a), r = e.aDir ? e.aDir : e.bDir;
+    if (!t || !s)
+      return;
+    if (t.area != s.area && r)
+      return this.renderAreaExit(t, r);
+    let i = { x: s.x, y: s.y };
+    (s.area !== t.area || s.z !== t.z) && (i = p(t.x, t.y, r, c.roomSize / 2));
+    const o = p(t.x, t.y, r, 0.3), n = o.x - (o.x - i.x) / 2, d = o.y - (o.y - i.y) / 2, l = new u.Group(), h = [];
+    h.push(...Object.values(p(t.x, t.y, r, c.roomSize / 2))), h.push(i.x, i.y);
+    const f = new u.Line({
+      points: h,
+      stroke: c.lineColor,
+      strokeWidth: 0.025,
+      dashEnabled: !0,
+      dash: [0.1, 0.05]
+    });
+    l.add(f);
+    const g = new u.Arrow({
+      points: [h[0], h[1], n, d],
+      pointerLength: 0.5,
+      pointerWidth: 0.35,
+      strokeWidth: 0.035,
+      stroke: c.lineColor,
+      fill: "#FF0000",
+      dashEnabled: !0,
+      dash: [0.1, 0.05]
+    });
+    return l.add(g), l;
+  }
+  renderAreaExit(e, t) {
+    const s = p(e.x, e.y, t, c.roomSize / 2), r = p(e.x, e.y, t, c.roomSize * 1.5);
+    return new u.Arrow({
+      points: [s.x, s.y, r.x, r.y],
+      pointerLength: 0.3,
+      pointerWidth: 0.3,
+      strokeWidth: 0.035,
+      stroke: this.mapReader.getColorValue(e.env),
+      fill: this.mapReader.getColorValue(e.env)
+    });
+  }
+  renderSpecialExits(e) {
+    return Object.entries(e.customLines).map(([t, s]) => {
+      const r = [e.x, e.y];
+      s.points.reduce((d, l) => (d.push(l.x, -l.y), d), r);
+      const i = s.attributes.arrow ? u.Arrow : u.Line, o = new i({
+        points: r,
+        strokeWidth: 0.025,
+        stroke: `rgb(${s.attributes.color.r}, ${s.attributes.color.g}, ${s.attributes.color.b})`,
+        fill: `rgb(${s.attributes.color.r}, ${s.attributes.color.g} , ${s.attributes.color.b})`,
+        pointerLength: 0.3,
+        pointerWidth: 0.2
+      });
+      let n = s.attributes.style;
+      return n === "dot line" ? (o.dash([0.05, 0.05]), o.dashOffset(0.1)) : n === "dash line" ? o.dash([0.4, 0.2]) : n === "solid line" || n !== void 0 && console.log("Brak opisu stylu: " + n), o;
+    });
+  }
+  renderStubs(e) {
+    return e.stubs.map((t) => {
+      const s = F[t], r = p(e.x, e.y, s, c.roomSize / 2), i = p(e.x, e.y, s, c.roomSize / 2 + 0.5), o = [r.x, r.y, i.x, i.y];
+      return new u.Line({
+        points: o,
+        stroke: c.lineColor,
+        strokeWidth: 0.025
+      });
+    });
+  }
+  renderInnerExits(e) {
+    return Z.map((t) => {
+      if (e.exits[t]) {
+        const s = new u.Group(), r = new u.RegularPolygon({
+          x: e.x,
+          y: e.y,
+          sides: 3,
+          fill: this.mapReader.getSymbolColor(e.env, 0.6),
+          stroke: this.mapReader.getSymbolColor(e.env),
+          strokeWidth: 0.025,
+          radius: c.roomSize / 5,
+          scaleX: 1.4,
+          scaleY: 0.8
+        });
+        s.add(r);
+        let i = e.doors[t];
+        if (i !== void 0)
+          switch (i) {
+            case 1:
+              r.stroke(y.OPEN_DOOR);
+              break;
+            case 2:
+              r.stroke(y.CLOSED_DOOR);
+              break;
+            default:
+              r.stroke(y.LOCKED_DOOR);
+          }
+        switch (t) {
+          case "up":
+            r.position(p(e.x, e.y, "south", c.roomSize / 4));
+            break;
+          case "down":
+            r.rotation(180), r.position(p(e.x, e.y, "north", c.roomSize / 4));
+            break;
+          case "in":
+            const o = r.clone();
+            o.rotation(-90), o.position(p(e.x, e.y, "east", c.roomSize / 4)), s.add(o), r.rotation(90), r.position(p(e.x, e.y, "west", c.roomSize / 4));
+            break;
+          case "out":
+            const n = r.clone();
+            n.rotation(90), n.position(p(e.x, e.y, "east", c.roomSize / 4)), s.add(n), r.rotation(-90), r.position(p(e.x, e.y, "west", c.roomSize / 4));
+            break;
+        }
+        return s;
+      }
+    }).filter((t) => t !== void 0);
+  }
+  renderDoor(e, t) {
+    const s = {
+      x: e[0] + (e[2] - e[0]) / 2,
+      y: e[1] + (e[3] - e[1]) / 2
+    };
+    return new u.Rect({
+      x: s.x - c.roomSize / 4,
+      y: s.y - c.roomSize / 4,
+      width: c.roomSize / 2,
+      height: c.roomSize / 2,
+      stroke: G(t),
+      strokeWidth: 0.025
+    });
+  }
+}
+class B {
+  constructor(e, t) {
+    this.paths = [], this.mapReader = e, this.overlayLayer = t;
+  }
+  renderPath(e, t, s) {
+    if (t === void 0 || s === void 0)
+      return;
+    const r = e.map((h) => this.mapReader.getRoom(h)).filter((h) => h !== void 0), i = [];
+    let o = null;
+    const n = () => {
+      o && (o.length < 4 && i.pop(), o = null);
+    }, d = () => (o || (o = [], i.push(o)), o);
+    r.forEach((h, f) => {
+      if (!this.isRoomVisible(h, t, s))
+        return;
+      const g = f > 0 ? r[f - 1] : void 0, m = f < r.length - 1 ? r[f + 1] : void 0;
+      if (this.isRoomVisible(g, t, s))
+        d();
+      else {
+        n();
+        const R = d();
+        if (g) {
+          const b = this.getDirectionTowards(h, g);
+          if (b) {
+            const D = p(h.x, h.y, b, c.roomSize);
+            R.push(D.x, D.y);
+          }
+        }
+      }
+      if (o == null || o.push(h.x, h.y), !this.isRoomVisible(m, t, s) && m) {
+        const R = this.getDirectionTowards(h, m);
+        if (R) {
+          const b = p(h.x, h.y, R, c.roomSize);
+          o == null || o.push(b.x, b.y);
+        }
+        n();
+      }
+    }), n();
+    const l = i.filter((h) => h.length >= 4).map((h) => new u.Line({
+      points: h,
+      stroke: "green",
+      strokeWidth: 0.1
+    }));
+    return l.forEach((h) => {
+      this.overlayLayer.add(h), this.paths.push(h);
+    }), l[0];
+  }
+  clearPaths() {
+    this.paths.forEach((e) => {
+      e.destroy();
+    }), this.paths = [];
+  }
+  isRoomVisible(e, t, s) {
+    return e ? e.area === t && e.z === s : !1;
+  }
+  getDirectionTowards(e, t) {
+    for (const s of L)
+      if (e.exits[s] === t.id)
+        return s;
+    for (const s of L)
+      if (t.exits[s] === e.id)
+        return j[s];
+  }
+}
+const T = 0.6, O = 1, x = 75, q = "rgb(225, 255, 225)", E = class E {
+};
+E.roomSize = T, E.lineColor = q;
+let c = E;
+class ue {
+  constructor(e, t) {
+    this.highlights = /* @__PURE__ */ new Map(), this.currentZoom = 1, this.stage = new u.Stage({
+      container: e,
+      width: e.clientWidth,
+      height: e.clientHeight,
+      draggable: !0
+    }), e.addEventListener("resize", () => {
+      this.stage.width(e.clientWidth), this.stage.height(e.clientHeight), this.stage.batchDraw();
+    }), this.linkLayer = new u.Layer({
+      listening: !1
+    }), this.stage.add(this.linkLayer), this.roomLayer = new u.Layer(), this.stage.add(this.roomLayer), this.overlayLayer = new u.Layer({
+      listening: !1
+    }), this.stage.add(this.overlayLayer), this.positionLayer = new u.Layer({
+      listening: !1
+    }), this.stage.add(this.positionLayer), this.mapReader = t, this.exitRenderer = new H(t), this.pathRenderer = new B(t, this.overlayLayer), this.initScaling(1.1);
+  }
+  initScaling(e) {
+    this.stage.on("wheel", (t) => {
+      t.evt.preventDefault();
+      const s = this.stage.scaleX(), r = this.stage.getPointerPosition();
+      if (!r)
+        return;
+      const i = {
+        x: (r.x - this.stage.x()) / s,
+        y: (r.y - this.stage.y()) / s
+      };
+      let o = t.evt.deltaY > 0 ? -1 : 1;
+      t.evt.ctrlKey && (o = -o);
+      const n = o > 0 ? this.currentZoom * e : this.currentZoom / e, d = n * x;
+      this.setZoom(n);
+      const l = {
+        x: r.x - i.x * d,
+        y: r.y - i.y * d
+      };
+      this.stage.position(l);
+    });
+  }
+  drawArea(e, t) {
+    const s = this.mapReader.getArea(e);
+    if (!s)
+      return;
+    const r = s.getPlane(t);
+    if (!r)
+      return;
+    this.currentArea = e, this.currentZIndex = t, this.currentAreaVersion = s.getVersion(), this.roomLayer.destroyChildren(), this.linkLayer.destroyChildren();
+    const { minX: i, maxX: o, minY: n, maxY: d } = r.getBounds();
+    this.stage.offset({ x: i - O, y: n - O }), this.stage.scale({ x: x * this.currentZoom, y: x * this.currentZoom }), this.renderLabels(r.getLabels()), this.renderRooms(r.getRooms() ?? []), this.renderExits(s.getLinkExits(t)), this.refreshHighlights(), this.stage.batchDraw();
+  }
+  setZoom(e) {
+    this.currentZoom = e, this.stage.scale({ x: x * e, y: x * e });
+  }
+  getZoom() {
+    return this.currentZoom;
+  }
+  getCurrentArea() {
+    return this.currentArea ? this.mapReader.getArea(this.currentArea) : void 0;
+  }
+  setPosition(e) {
+    const t = this.mapReader.getRoom(e);
+    if (!t) return;
+    const s = this.mapReader.getArea(t.area), r = s == null ? void 0 : s.getVersion();
+    let i = this.currentArea !== t.area || this.currentZIndex !== t.z;
+    (this.currentArea !== t.area || this.currentZIndex !== t.z || r !== void 0 && this.currentAreaVersion !== r) && this.drawArea(t.area, t.z), this.positionRender || (this.positionRender = new u.Circle({
+      x: t.x,
+      y: t.y,
+      radius: T * 0.85,
+      stroke: "rgb(0, 229, 178)",
+      strokeWidth: 0.1,
+      dash: [0.05, 0.05],
+      dashEnabled: !0
+    }), this.positionLayer.add(this.positionRender)), this.centerOnRoom(t, i);
+  }
+  renderPath(e) {
+    return this.pathRenderer.renderPath(e, this.currentArea, this.currentZIndex);
+  }
+  clearPaths() {
+    this.pathRenderer.clearPaths();
+  }
+  renderHighlight(e, t) {
+    const s = this.mapReader.getRoom(e);
+    if (!s)
+      return;
+    const r = this.highlights.get(e);
+    r != null && r.shape && (r.shape.destroy(), delete r.shape);
+    const i = { color: t, area: s.area, z: s.z };
+    if (this.highlights.set(e, i), s.area === this.currentArea && s.z === this.currentZIndex) {
+      const o = this.createHighlightShape(s, t);
+      return this.overlayLayer.add(o), i.shape = o, this.overlayLayer.batchDraw(), o;
+    }
+    return i.shape;
+  }
+  clearHighlights() {
+    this.highlights.forEach(({ shape: e }) => e == null ? void 0 : e.destroy()), this.highlights.clear(), this.overlayLayer.batchDraw();
+  }
+  refreshHighlights() {
+    this.highlights.forEach((e, t) => {
+      var i;
+      if ((i = e.shape) == null || i.destroy(), delete e.shape, e.area !== this.currentArea || e.z !== this.currentZIndex)
+        return;
+      const s = this.mapReader.getRoom(t);
+      if (!s)
+        return;
+      const r = this.createHighlightShape(s, e.color);
+      this.overlayLayer.add(r), e.shape = r;
+    }), this.overlayLayer.batchDraw();
+  }
+  createHighlightShape(e, t) {
+    return new u.Circle({
+      x: e.x,
+      y: e.y,
+      radius: c.roomSize * 0.9,
+      stroke: t,
+      strokeWidth: 0.15,
+      dash: [0.1, 0.05],
+      dashEnabled: !0,
+      listening: !1
+    });
+  }
+  centerOnRoom(e, t = !1) {
+    var l;
+    const s = { x: e.x, y: e.y };
+    (l = this.positionRender) == null || l.position(e);
+    const i = this.stage.getAbsoluteTransform().point(s), o = {
+      x: this.stage.width() / 2,
+      y: this.stage.height() / 2
+    }, n = o.x - i.x, d = o.y - i.y;
+    this.currentTransition && (this.currentTransition.pause(), this.currentTransition.destroy(), delete this.currentTransition), t ? this.stage.position({
+      x: this.stage.x() + n,
+      y: this.stage.y() + d
+    }) : (this.currentTransition = new u.Tween({
+      node: this.stage,
+      x: this.stage.x() + n,
+      y: this.stage.y() + d,
+      duration: 0.2,
+      easing: u.Easings.EaseInOut
+    }), this.currentTransition.play());
+  }
+  renderRooms(e) {
+    e.forEach((t) => {
+      const s = new u.Group({
+        x: t.x - c.roomSize / 2,
+        y: t.y - c.roomSize / 2
+      }), r = new u.Rect({
+        x: 0,
+        y: 0,
+        width: c.roomSize,
+        height: c.roomSize,
+        fill: this.mapReader.getColorValue(t.env),
+        strokeWidth: 0.025,
+        stroke: c.lineColor
+      });
+      s.on("mouseenter", () => {
+        this.stage.container().style.cursor = "pointer";
+      }), s.on("mouseleave", () => {
+        this.stage.container().style.cursor = "auto";
+      }), s.add(r), this.renderSymbol(t, s), this.roomLayer.add(s), this.exitRenderer.renderSpecialExits(t).forEach((i) => {
+        this.linkLayer.add(i);
+      }), this.exitRenderer.renderStubs(t).forEach((i) => {
+        this.linkLayer.add(i);
+      }), this.exitRenderer.renderInnerExits(t).forEach((i) => {
+        this.roomLayer.add(i);
+      });
+    });
+  }
+  renderSymbol(e, t) {
+    if (e.roomChar !== void 0) {
+      const s = new u.Text({
+        x: 0,
+        y: 0,
+        text: e.roomChar,
+        fontSize: 0.45,
+        fontStyle: "bold",
+        fill: this.mapReader.getSymbolColor(e.env),
+        align: "center",
+        verticalAlign: "middle",
+        width: c.roomSize,
+        height: c.roomSize
+      });
+      t.add(s);
+    }
+  }
+  renderExits(e) {
+    e.forEach((t) => {
+      const s = this.exitRenderer.render(t);
+      s && this.linkLayer.add(s);
+    });
+  }
+  renderLabels(e) {
+    e.forEach((t) => {
+      if (!t.pixMap)
+        return;
+      const s = new Image();
+      s.src = `data:image/png;base64,${t.pixMap}`;
+      const r = new u.Image({
+        x: t.X,
+        y: -t.Y,
+        width: t.Width,
+        height: t.Height,
+        image: s
+      });
+      this.linkLayer.add(r);
+    });
+  }
+}
+class A {
+  constructor(e, t) {
+    this.rooms = [], this.labels = [], this.rooms = e, this.bounds = this.createBounds(), this.labels = t;
+  }
+  getRooms() {
+    return this.rooms;
+  }
+  getLabels() {
+    return this.labels;
+  }
+  getBounds() {
+    return this.bounds;
+  }
+  createBounds() {
+    return this.rooms.reduce(
+      (e, t) => ({
+        minX: Math.min(e.minX, t.x),
+        maxX: Math.max(e.maxX, t.x),
+        minY: Math.min(e.minY, t.y),
+        maxY: Math.max(e.maxY, t.y)
+      }),
+      {
+        minX: Number.POSITIVE_INFINITY,
+        maxX: Number.NEGATIVE_INFINITY,
+        minY: Number.POSITIVE_INFINITY,
+        maxY: Number.NEGATIVE_INFINITY
+      }
+    );
+  }
+}
+class S {
+  constructor(e) {
+    this.planes = {}, this.exits = /* @__PURE__ */ new Map(), this.version = 0, this.area = e, this.planes = this.createPlanes(), this.createExits();
+  }
+  getAreaName() {
+    return this.area.areaName;
+  }
+  getAreaId() {
+    return parseInt(this.area.areaId);
+  }
+  getVersion() {
+    return this.version;
+  }
+  markDirty() {
+    this.version++;
+  }
+  getPlane(e) {
+    return this.planes[e];
+  }
+  getPlanes() {
+    return Object.values(this.planes);
+  }
+  getRooms() {
+    return this.area.rooms;
+  }
+  getLinkExits(e) {
+    return Array.from(this.exits.values()).filter((t) => t.zIndex.includes(e));
+  }
+  createPlanes() {
+    const e = this.area.rooms.reduce((t, s) => (t[s.z] || (t[s.z] = []), t[s.z].push(s), t), {});
+    return Object.entries(e).reduce(
+      (t, [s, r]) => (t[+s] = new A(r, this.area.labels.filter((i) => i.Z === +s)), t),
+      {}
+    );
+  }
+  createExits() {
+    this.area.rooms.forEach((e) => {
+      Object.entries(e.exits).filter(([t, s]) => _.indexOf(t) > -1 && !e.customLines.hasOwnProperty(w[t])).forEach(([t, s]) => this.createHalfExit(e.id, s, e.z, t));
+    });
+  }
+  createHalfExit(e, t, s, r) {
+    if (e === t)
+      return;
+    const i = Math.min(e, t), o = Math.max(e, t), n = `${i}-${o}`;
+    let d = this.exits.get(n);
+    d || (d = { a: i, b: o, zIndex: [s] }), i == e ? d.aDir = r : d.bDir = r, d.zIndex.push(s), this.exits.set(n, d);
+  }
+}
+class I extends A {
+  constructor(e, t) {
+    super(e.getRooms(), e.getLabels()), this.basePlane = e, this.visitedRooms = t;
+  }
+  getRooms() {
+    return this.basePlane.getRooms().filter((e) => this.visitedRooms.has(e.id));
+  }
+  getLabels() {
+    return this.basePlane.getLabels();
+  }
+  getBounds() {
+    const e = this.getRooms();
+    return e.length ? e.reduce(
+      (t, s) => ({
+        minX: Math.min(t.minX, s.x),
+        maxX: Math.max(t.maxX, s.x),
+        minY: Math.min(t.minY, s.y),
+        maxY: Math.max(t.maxY, s.y)
+      }),
+      {
+        minX: Number.POSITIVE_INFINITY,
+        maxX: Number.NEGATIVE_INFINITY,
+        minY: Number.POSITIVE_INFINITY,
+        maxY: Number.NEGATIVE_INFINITY
+      }
+    ) : this.basePlane.getBounds();
+  }
+}
+class P extends S {
+  constructor(e, t) {
+    super(e), this.planeCache = /* @__PURE__ */ new WeakMap(), this.visitedRooms = t instanceof Set ? t : new Set(t ?? []), this.areaRoomIds = new Set(e.rooms.map((s) => s.id));
+  }
+  getPlane(e) {
+    const t = super.getPlane(e);
+    if (!t)
+      return t;
+    let s = this.planeCache.get(t);
+    return s || (s = new I(t, this.visitedRooms), this.planeCache.set(t, s)), s;
+  }
+  getPlanes() {
+    return super.getPlanes().map((e) => {
+      let t = this.planeCache.get(e);
+      return t || (t = new I(e, this.visitedRooms), this.planeCache.set(e, t)), t;
+    });
+  }
+  getLinkExits(e) {
+    return super.getLinkExits(e).filter((t) => this.visitedRooms.has(t.a) || this.visitedRooms.has(t.b));
+  }
+  getVisitedRoomCount() {
+    return super.getRooms().reduce((e, t) => e + (this.visitedRooms.has(t.id) ? 1 : 0), 0);
+  }
+  getTotalRoomCount() {
+    return this.areaRoomIds.size;
+  }
+  hasVisitedRoom(e) {
+    return this.areaRoomIds.has(e) && this.visitedRooms.has(e);
+  }
+  getVisitedRoomIds() {
+    return super.getRooms().filter((e) => this.visitedRooms.has(e.id)).map((e) => e.id);
+  }
+  addVisitedRoom(e) {
+    const t = this.visitedRooms.has(e);
+    this.visitedRooms.add(e);
+    const s = !t && this.areaRoomIds.has(e);
+    return s && this.markDirty(), s;
+  }
+  addVisitedRooms(e) {
+    let t = 0;
+    for (const s of e) {
+      const r = this.visitedRooms.has(s);
+      this.visitedRooms.add(s), !r && this.areaRoomIds.has(s) && t++;
+    }
+    return t > 0 && this.markDirty(), t;
+  }
+}
+const C = {
+  rgbValue: "rgb(114, 1, 0)",
+  symbolColor: [225, 225, 225]
+};
+function z(a) {
+  const e = a[0] / 255, t = a[1] / 255, s = a[2] / 255, r = Math.max(e, t, s), i = Math.min(e, t, s);
+  return (r + i) / 2;
+}
+class de {
+  constructor(e, t) {
+    this.rooms = {}, this.areas = {}, this.areaSources = {}, this.explorationEnabled = !1, this.colors = {}, e.forEach((s) => {
+      s.rooms.forEach((i) => {
+        i.y = -i.y, this.rooms[i.id] = i;
+      });
+      const r = parseInt(s.areaId);
+      this.areas[r] = new S(s), this.areaSources[r] = s;
+    }), this.colors = t.reduce((s, r) => ({
+      ...s,
+      [r.envId]: {
+        rgb: r.colors,
+        rgbValue: `rgb(${r.colors.join(",")}`,
+        symbolColor: z(r.colors) > 0.41 ? [25, 25, 25] : [225, 255, 255],
+        symbolColorValue: z(r.colors) > 0.41 ? "rgb(25,25,25)" : "rgb(225,255,255)"
+      }
+    }), {});
+  }
+  getArea(e) {
+    return this.areas[e];
+  }
+  getExplorationArea(e) {
+    const t = this.areas[e];
+    if (t instanceof P)
+      return t;
+  }
+  getAreas() {
+    return Object.values(this.areas);
+  }
+  getRooms() {
+    return Object.values(this.rooms);
+  }
+  getRoom(e) {
+    return this.rooms[e];
+  }
+  decorateWithExploration(e) {
+    return this.visitedRooms = e instanceof Set ? e : new Set(e ?? []), Object.entries(this.areaSources).forEach(([t, s]) => {
+      const r = parseInt(t, 10);
+      this.areas[r] = new P(s, this.visitedRooms);
+    }), this.explorationEnabled = !0, this.visitedRooms;
+  }
+  getVisitedRooms() {
+    return this.visitedRooms;
+  }
+  clearExplorationDecoration() {
+    Object.entries(this.areaSources).forEach(([e, t]) => {
+      const s = parseInt(e, 10);
+      this.areas[s] = new S(t);
+    }), this.explorationEnabled = !1;
+  }
+  isExplorationEnabled() {
+    return this.explorationEnabled;
+  }
+  getColorValue(e) {
+    var t;
+    return ((t = this.colors[e]) == null ? void 0 : t.rgbValue) ?? C.rgbValue;
+  }
+  getSymbolColor(e, t) {
+    var o;
+    const s = ((o = this.colors[e]) == null ? void 0 : o.symbolColor) ?? C.symbolColor, r = Math.min(Math.max(t ?? 1, 0), 1), i = s.join(",");
+    return r != 1 ? `rgba(${i}, ${r})` : `rgba(${i})`;
+  }
+}
+function K(a) {
+  return a && a.__esModule && Object.prototype.hasOwnProperty.call(a, "default") ? a.default : a;
+}
+class Q {
+  /**
+   * Creates a new empty priority queue
+   */
+  constructor() {
+    this.keys = /* @__PURE__ */ new Set(), this.queue = [];
+  }
+  /**
+   * Sort the queue to have the least expensive node to visit on top
+   *
+   * @private
+   */
+  sort() {
+    this.queue.sort((e, t) => e.priority - t.priority);
+  }
+  /**
+   * Sets a priority for a key in the queue.
+   * Inserts it in the queue if it does not already exists.
+   *
+   * @param {any}     key       Key to update or insert
+   * @param {number}  value     Priority of the key
+   * @return {number} Size of the queue
+   */
+  set(e, t) {
+    const s = Number(t);
+    if (isNaN(s)) throw new TypeError('"priority" must be a number');
+    return this.keys.has(e) ? this.queue.map((r) => (r.key === e && Object.assign(r, { priority: s }), r)) : (this.keys.add(e), this.queue.push({ key: e, priority: s })), this.sort(), this.queue.length;
+  }
+  /**
+   * The next method is used to dequeue a key:
+   * It removes the first element from the queue and returns it
+   *
+   * @return {object} First priority queue entry
+   */
+  next() {
+    const e = this.queue.shift();
+    return this.keys.delete(e.key), e;
+  }
+  /**
+   * @return {boolean} `true` when the queue is empty
+   */
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+  /**
+   * Check if the queue has a key in it
+   *
+   * @param {any} key   Key to lookup
+   * @return {boolean}
+   */
+  has(e) {
+    return this.keys.has(e);
+  }
+  /**
+   * Get the element in the queue with the specified key
+   *
+   * @param {any} key   Key to lookup
+   * @return {object}
+   */
+  get(e) {
+    return this.queue.find((t) => t.key === e);
+  }
+}
+var J = Q;
+function Y(a, e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const [s, r] of a)
+    s !== e && r instanceof Map ? t.set(s, Y(r, e)) : s !== e && t.set(s, r);
+  return t;
+}
+var U = Y;
+function ee(a) {
+  const e = Number(a);
+  return !(isNaN(e) || e <= 0);
+}
+function $(a) {
+  const e = /* @__PURE__ */ new Map();
+  return Object.keys(a).forEach((s) => {
+    const r = a[s];
+    if (r !== null && typeof r == "object" && !Array.isArray(r))
+      return e.set(s, $(r));
+    if (!ee(r))
+      throw new Error(
+        `Could not add node at key "${s}", make sure it's a valid node`,
+        r
+      );
+    return e.set(s, Number(r));
+  }), e;
+}
+var te = $;
+function W(a) {
+  if (!(a instanceof Map))
+    throw new Error(`Invalid graph: Expected Map instead found ${typeof a}`);
+  a.forEach((e, t) => {
+    if (typeof e == "object" && e instanceof Map) {
+      W(e);
+      return;
+    }
+    if (typeof e != "number" || e <= 0)
+      throw new Error(
+        `Values must be numbers greater than 0. Found value ${e} at ${t}`
+      );
+  });
+}
+var se = W;
+const re = J, ie = U, V = te, N = se;
+class oe {
+  /**
+   * Creates a new Graph, optionally initializing it a nodes graph representation.
+   *
+   * A graph representation is an object that has as keys the name of the point and as values
+   * the points reacheable from that node, with the cost to get there:
+   *
+   *     {
+   *       node (Number|String): {
+   *         neighbor (Number|String): cost (Number),
+   *         ...,
+   *       },
+   *     }
+   *
+   * In alternative to an object, you can pass a `Map` of `Map`. This will
+   * allow you to specify numbers as keys.
+   *
+   * @param {Objec|Map} [graph] - Initial graph definition
+   * @example
+   *
+   * const route = new Graph();
+   *
+   * // Pre-populated graph
+   * const route = new Graph({
+   *   A: { B: 1 },
+   *   B: { A: 1, C: 2, D: 4 },
+   * });
+   *
+   * // Passing a Map
+   * const g = new Map()
+   *
+   * const a = new Map()
+   * a.set('B', 1)
+   *
+   * const b = new Map()
+   * b.set('A', 1)
+   * b.set('C', 2)
+   * b.set('D', 4)
+   *
+   * g.set('A', a)
+   * g.set('B', b)
+   *
+   * const route = new Graph(g)
+   */
+  constructor(e) {
+    e instanceof Map ? (N(e), this.graph = e) : e ? this.graph = V(e) : this.graph = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Adds a node to the graph
+   *
+   * @param {string} name      - Name of the node
+   * @param {Object|Map} neighbors - Neighbouring nodes and cost to reach them
+   * @return {this}
+   * @example
+   *
+   * const route = new Graph();
+   *
+   * route.addNode('A', { B: 1 });
+   *
+   * // It's possible to chain the calls
+   * route
+   *   .addNode('B', { A: 1 })
+   *   .addNode('C', { A: 3 });
+   *
+   * // The neighbors can be expressed in a Map
+   * const d = new Map()
+   * d.set('A', 2)
+   * d.set('B', 8)
+   *
+   * route.addNode('D', d)
+   */
+  addNode(e, t) {
+    let s;
+    return t instanceof Map ? (N(t), s = t) : s = V(t), this.graph.set(e, s), this;
+  }
+  /**
+   * @deprecated since version 2.0, use `Graph#addNode` instead
+   */
+  addVertex(e, t) {
+    return this.addNode(e, t);
+  }
+  /**
+   * Removes a node and all of its references from the graph
+   *
+   * @param {string|number} key - Key of the node to remove from the graph
+   * @return {this}
+   * @example
+   *
+   * const route = new Graph({
+   *   A: { B: 1, C: 5 },
+   *   B: { A: 3 },
+   *   C: { B: 2, A: 2 },
+   * });
+   *
+   * route.removeNode('C');
+   * // The graph now is:
+   * // { A: { B: 1 }, B: { A: 3 } }
+   */
+  removeNode(e) {
+    return this.graph = ie(this.graph, e), this;
+  }
+  /**
+   * Compute the shortest path between the specified nodes
+   *
+   * @param {string}  start     - Starting node
+   * @param {string}  goal      - Node we want to reach
+   * @param {object}  [options] - Options
+   *
+   * @param {boolean} [options.trim]    - Exclude the origin and destination nodes from the result
+   * @param {boolean} [options.reverse] - Return the path in reversed order
+   * @param {boolean} [options.cost]    - Also return the cost of the path when set to true
+   *
+   * @return {array|object} Computed path between the nodes.
+   *
+   *  When `option.cost` is set to true, the returned value will be an object with shape:
+   *    - `path` *(Array)*: Computed path between the nodes
+   *    - `cost` *(Number)*: Cost of the path
+   *
+   * @example
+   *
+   * const route = new Graph()
+   *
+   * route.addNode('A', { B: 1 })
+   * route.addNode('B', { A: 1, C: 2, D: 4 })
+   * route.addNode('C', { B: 2, D: 1 })
+   * route.addNode('D', { C: 1, B: 4 })
+   *
+   * route.path('A', 'D') // => ['A', 'B', 'C', 'D']
+   *
+   * // trimmed
+   * route.path('A', 'D', { trim: true }) // => [B', 'C']
+   *
+   * // reversed
+   * route.path('A', 'D', { reverse: true }) // => ['D', 'C', 'B', 'A']
+   *
+   * // include the cost
+   * route.path('A', 'D', { cost: true })
+   * // => {
+   * //       path: [ 'A', 'B', 'C', 'D' ],
+   * //       cost: 4
+   * //    }
+   */
+  path(e, t, s = {}) {
+    if (!this.graph.size)
+      return s.cost ? { path: null, cost: 0 } : null;
+    const r = /* @__PURE__ */ new Set(), i = new re(), o = /* @__PURE__ */ new Map();
+    let n = [], d = 0, l = [];
+    if (s.avoid && (l = [].concat(s.avoid)), l.includes(e))
+      throw new Error(`Starting node (${e}) cannot be avoided`);
+    if (l.includes(t))
+      throw new Error(`Ending node (${t}) cannot be avoided`);
+    for (i.set(e, 0); !i.isEmpty(); ) {
+      const h = i.next();
+      if (h.key === t) {
+        d = h.priority;
+        let g = h.key;
+        for (; o.has(g); )
+          n.push(g), g = o.get(g);
+        break;
+      }
+      r.add(h.key), (this.graph.get(h.key) || /* @__PURE__ */ new Map()).forEach((g, m) => {
+        if (r.has(m) || l.includes(m)) return null;
+        if (!i.has(m))
+          return o.set(m, h.key), i.set(m, h.priority + g);
+        const k = i.get(m).priority, v = h.priority + g;
+        return v < k ? (o.set(m, h.key), i.set(m, v)) : null;
+      });
+    }
+    return n.length ? (s.trim ? n.shift() : n = n.concat([e]), s.reverse || (n = n.reverse()), s.cost ? {
+      path: n,
+      cost: d
+    } : n) : s.cost ? { path: null, cost: 0 } : null;
+  }
+  /**
+   * @deprecated since version 2.0, use `Graph#path` instead
+   */
+  shortestPath(...e) {
+    return this.path(...e);
+  }
+}
+var ne = oe;
+const ae = /* @__PURE__ */ K(ne), he = {
+  1: "north",
+  2: "northeast",
+  3: "northwest",
+  4: "east",
+  5: "west",
+  6: "south",
+  7: "southeast",
+  8: "southwest",
+  9: "up",
+  10: "down",
+  11: "in",
+  12: "out"
+};
+class le {
+  constructor(e) {
+    this.cache = /* @__PURE__ */ new Map(), this.mapReader = e, this.graph = this.buildGraph();
+  }
+  buildGraph() {
+    const e = {};
+    return this.mapReader.getRooms().forEach((t) => {
+      const s = {}, r = new Set(
+        (t.exitLocks ?? []).map((o) => he[o]).filter((o) => !!o)
+      ), i = new Set(t.mSpecialExitLocks ?? []);
+      Object.entries(t.exits ?? {}).forEach(([o, n]) => {
+        r.has(o) || this.mapReader.getRoom(n) && (s[n.toString()] = 1);
+      }), Object.values(t.specialExits ?? {}).forEach((o) => {
+        i.has(o) || this.mapReader.getRoom(o) && (s[o.toString()] = 1);
+      }), e[t.id.toString()] = s;
+    }), new ae(e);
+  }
+  findPath(e, t) {
+    const s = `${e}->${t}`;
+    if (this.cache.has(s))
+      return this.cache.get(s);
+    if (e === t) {
+      const n = this.mapReader.getRoom(e) ? [e] : null;
+      return this.cache.set(s, n), n;
+    }
+    if (!this.mapReader.getRoom(e) || !this.mapReader.getRoom(t))
+      return this.cache.set(s, null), null;
+    const r = this.graph.path(e.toString(), t.toString()), i = Array.isArray(r) ? r : r == null ? void 0 : r.path, o = i ? i.map((n) => Number(n)) : null;
+    return this.cache.set(s, o), o;
+  }
+}
+export {
+  P as ExplorationArea,
+  de as MapReader,
+  le as PathFinder,
+  ue as Renderer,
+  c as Settings
+};
+//# sourceMappingURL=index.mjs.map