1681-engine 0.0.0-stage → 0.5.9

package/dist/input/Keymap.js

@@ -0,0 +1,170 @@
+class g {
+  binds;
+  defaults;
+  reserved;
+  fixed;
+  listeners = [];
+  /**
+   * `reserved`: keys never bound (default Escape, Enter, Tab; pass `undefined` for the default). `fixed`: inputs each
+   * action always has besides the player's keys (gamepad, touch, a reserved key), never saved or rebound.
+   */
+  constructor(t, s = ["Escape", "Enter", "Tab"], e = {}) {
+    this.defaults = { ...t }, this.reserved = new Set(s), this.fixed = { ...e }, this.binds = this.fresh();
+  }
+  fresh() {
+    const t = {};
+    for (const s of this.actions()) t[s] = this.defaults[s].filter((e) => !this.reserved.has(e));
+    return t;
+  }
+  /** Every action, in the order the defaults named them. */
+  actions() {
+    return Object.keys(this.defaults);
+  }
+  isReserved(t) {
+    return this.reserved.has(t);
+  }
+  /** The keys of one action; the first is the one a settings screen shows and edits. */
+  keysFor(t) {
+    return this.binds[t] ?? [];
+  }
+  /** The inputs an action always has besides the player's keys (the constructor's `fixed`). */
+  fixedFor(t) {
+    return this.fixed[t] ?? [];
+  }
+  /** Which action a key belongs to, or undefined. */
+  actionFor(t) {
+    for (const s of this.actions()) if (this.binds[s].includes(t)) return s;
+  }
+  /**
+   * Puts `code` first on `action`, taking it off whatever else held it; returns the actions that lost it (to tell the
+   * player). A reserved key is refused (returns null). An action stripped of its last key keeps none: it is unbound
+   * until something is put back on it.
+   */
+  bind(t, s) {
+    if (this.reserved.has(s) || !(t in this.binds)) return null;
+    const e = [];
+    for (const n of this.actions())
+      n === t || !this.binds[n].includes(s) || (this.binds[n] = this.binds[n].filter((a) => a !== s), e.push(n));
+    const h = this.binds[t].slice(1).filter((n) => n !== s);
+    return this.binds[t] = [s, ...h], this.changed(), e;
+  }
+  /** Takes every key off `action`. */
+  unbind(t) {
+    this.binds[t]?.length && (this.binds[t] = [], this.changed());
+  }
+  /** Every action back on its defaults. */
+  reset() {
+    this.binds = this.fresh(), this.changed();
+  }
+  /** A plain object to store wherever the game keeps its settings. */
+  toJSON() {
+    const t = {};
+    for (const s of this.actions()) t[s] = [...this.binds[s]];
+    return t;
+  }
+  /**
+   * A saved set laid over this build's defaults. Only actions this build knows are read, so an old save cannot leave
+   * a key bound to nothing; an action newer than the save keeps its defaults only where no saved action holds that key
+   * (the saved one is what the player chose). Anything malformed is ignored.
+   */
+  load(t) {
+    this.binds = u(this.defaults, t, this.reserved), this.changed();
+  }
+  /**
+   * Hands the bindings to an `Actions`: each action's keys, then its fixed inputs, then its `extra` ones. Only the
+   * keymap's actions are bound, so the `Actions` may hold more (menu actions alongside the rebindable ones, each on
+   * its own fixed inputs); those are left as they are. Fixed and extra inputs are the game's, so neither the reserved
+   * keys nor one-key-one-action apply to them.
+   */
+  applyTo(t, s = {}) {
+    for (const e of this.actions()) t.bind(e, [...this.binds[e], ...this.fixed[e] ?? [], ...s[e] ?? []]);
+  }
+  /** Called after every change; returns a function that stops it. */
+  onChange(t) {
+    return this.listeners.push(t), () => {
+      const s = this.listeners.indexOf(t);
+      s >= 0 && this.listeners.splice(s, 1);
+    };
+  }
+  changed() {
+    for (const t of [...this.listeners]) t();
+  }
+}
+function u(i, t, s = /* @__PURE__ */ new Set()) {
+  const e = Object.keys(i), h = {}, n = /* @__PURE__ */ new Set(), a = t && typeof t == "object" ? t : {};
+  for (const r of e) {
+    const o = a[r];
+    Array.isArray(o) && o.every((f) => typeof f == "string") ? (h[r] = [...new Set(o)].filter((f) => !s.has(f)), n.add(r)) : h[r] = i[r].filter((f) => !s.has(f));
+  }
+  const l = /* @__PURE__ */ new Map();
+  for (const r of e)
+    n.has(r) && (h[r] = h[r].filter((o) => l.has(o) ? !1 : (l.set(o, r), !0)));
+  for (const r of e) n.has(r) || (h[r] = h[r].filter((o) => !l.has(o)));
+  return h;
+}
+function b(i) {
+  const t = () => {
+    try {
+      return typeof localStorage > "u" ? null : localStorage;
+    } catch {
+      return null;
+    }
+  };
+  return {
+    read() {
+      try {
+        const s = t()?.getItem(i);
+        return s ? JSON.parse(s) : null;
+      } catch {
+        return null;
+      }
+    },
+    write(s) {
+      try {
+        t()?.setItem(i, JSON.stringify(s));
+      } catch {
+      }
+    },
+    clear() {
+      try {
+        t()?.removeItem(i);
+      } catch {
+      }
+    }
+  };
+}
+const c = {
+  Space: "Space",
+  ShiftLeft: "Shift",
+  ShiftRight: "Right Shift",
+  ControlLeft: "Ctrl",
+  ControlRight: "Right Ctrl",
+  AltLeft: "Alt",
+  AltRight: "Right Alt",
+  ArrowUp: "Up",
+  ArrowDown: "Down",
+  ArrowLeft: "Left",
+  ArrowRight: "Right",
+  Backquote: "`",
+  Minus: "-",
+  Equal: "=",
+  Semicolon: ";",
+  Quote: "'",
+  Comma: ",",
+  Period: ".",
+  Slash: "/",
+  Backslash: "\\",
+  BracketLeft: "[",
+  BracketRight: "]"
+};
+function d(i, t = {}) {
+  if (i.length > 1 && i.includes("+")) return i.split("+").map((e) => d(e, t)).join("+");
+  const s = t[i];
+  return s !== void 0 ? s : i.startsWith("Key") ? i.slice(3) : i.startsWith("Digit") ? i.slice(5) : i.startsWith("Numpad") ? `Num ${i.slice(6)}` : c[i] ?? i;
+}
+export {
+  g as Keymap,
+  d as keyLabel,
+  b as keymapStorage,
+  u as mergeKeymap
+};

package/dist/input/TargetLock.js

@@ -0,0 +1,72 @@
+const _ = 220, g = 300, d = 50 * Math.PI / 180;
+function p(e, n) {
+  let t = (e - n) % (Math.PI * 2);
+  return t > Math.PI && (t -= Math.PI * 2), t < -Math.PI && (t += Math.PI * 2), t;
+}
+function y(e, n, t, i = 220, s = d) {
+  if (Math.hypot(n.x, n.y) < 1e-6) return null;
+  const h = Math.atan2(n.y, n.x);
+  let l = null, u = 1 / 0;
+  for (const a of t) {
+    const o = Math.hypot(a.x - e.x, a.y - e.y);
+    if (o > i) continue;
+    const r = o < 1 ? 0 : Math.abs(p(Math.atan2(a.y - e.y, a.x - e.x), h));
+    if (r > s) continue;
+    const f = r / s + 0.35 * o / i;
+    f < u && (u = f, l = a.id);
+  }
+  return l;
+}
+function K(e, n, t = 220) {
+  let i = null, s = 1 / 0;
+  for (const c of n) {
+    const h = Math.hypot(c.x - e.x, c.y - e.y);
+    h > t || (h < s || h === s && i !== null && c.id < i) && (s = h, i = c.id);
+  }
+  return i;
+}
+function R(e, n, t, i = 300) {
+  if (n === null) return null;
+  const s = t.find((c) => c.id === n);
+  return !s || Math.hypot(s.x - e.x, s.y - e.y) > i ? null : s;
+}
+class b {
+  constructor(n, t = {}) {
+    this.bodies = n, this.pickRange = t.pickRange ?? 220, this.keepRange = t.keepRange ?? 300, this.cone = t.cone ?? d;
+  }
+  bodies;
+  id = null;
+  pickRange;
+  keepRange;
+  cone;
+  /** The id held, without checking it still stands (use `current` for that). */
+  get locked() {
+    return this.id;
+  }
+  /** A drag in `dir` from `from`: locks what it points at; pointing at nothing keeps the old lock. */
+  pick(n, t) {
+    const i = y(n, t, this.bodies(), this.pickRange, this.cone);
+    return i !== null && (this.id = i), this.id;
+  }
+  /** Locks the nearest body, every call, whatever was held. */
+  pickNearest(n) {
+    return this.id = K(n, this.bodies(), this.pickRange), this.id;
+  }
+  /** The held body if it still holds; a lock that no longer does is dropped. */
+  current(n) {
+    const t = R(n, this.id, this.bodies(), this.keepRange);
+    return t || (this.id = null), t;
+  }
+  clear() {
+    this.id = null;
+  }
+}
+export {
+  g as LOCK_KEEP_RANGE,
+  d as LOCK_PICK_CONE,
+  _ as LOCK_PICK_RANGE,
+  b as TargetLock,
+  R as keptTarget,
+  K as nearestTarget,
+  y as pickTarget
+};

package/dist/input/aimAxis.js

@@ -0,0 +1,7 @@
+function h(t) {
+  const s = Math.cos(t), a = Math.sin(t), n = Math.sin(Math.PI / 8);
+  return { dx: Math.abs(s) > n ? Math.sign(s) : 0, dy: Math.abs(a) > n ? Math.sign(a) : 0 };
+}
+export {
+  h as aimAxis
+};

package/dist/input/keyChord.js

@@ -0,0 +1,28 @@
+const o = {
+  Shift: ["ShiftLeft", "ShiftRight"],
+  Ctrl: ["ControlLeft", "ControlRight"],
+  Alt: ["AltLeft", "AltRight"],
+  Meta: ["MetaLeft", "MetaRight"]
+};
+function l(e) {
+  const t = e.split("+");
+  if (t.length < 2) return null;
+  const r = t[t.length - 1];
+  if (!r) return null;
+  const n = [];
+  for (const i of t.slice(0, -1)) {
+    const f = o[i];
+    if (!f) return null;
+    n.push(f);
+  }
+  return { code: r, modifiers: n };
+}
+function s(e, t) {
+  if (!t(e.code)) return !1;
+  for (const [r, n] of e.modifiers) if (!t(r) && !t(n)) return !1;
+  return !0;
+}
+export {
+  s as chordHeld,
+  l as parseChord
+};

package/dist/input/longPress.js

@@ -0,0 +1,31 @@
+class r {
+  constructor(s = 480, i = 10) {
+    this.ms = s, this.slop = i;
+  }
+  ms;
+  slop;
+  finger = null;
+  done = !1;
+  down(s, i, n, t) {
+    if (this.finger) {
+      this.finger = null, this.done = !0;
+      return;
+    }
+    this.finger = { id: s, x: i, y: n, at: t }, this.done = !1;
+  }
+  move(s, i, n) {
+    const t = this.finger;
+    t && t.id === s && Math.hypot(i - t.x, n - t.y) > this.slop && (this.finger = null);
+  }
+  up(s) {
+    this.finger?.id === s && (this.finger = null), this.finger || (this.done = !1);
+  }
+  /** Where the press is, the first time this is asked at or after `ms`; null otherwise. */
+  fire(s) {
+    const i = this.finger;
+    return !i || this.done || s - i.at < this.ms ? null : (this.done = !0, { x: i.x, y: i.y });
+  }
+}
+export {
+  r as LongPress
+};

package/dist/input/rumble.js

@@ -0,0 +1,42 @@
+function u(t) {
+  return t !== void 0 && t > 0 ? Math.min(1, t) : 0;
+}
+function o(t) {
+  const a = t.durationMs !== void 0 && t.durationMs > 0 ? t.durationMs : 200;
+  return {
+    duration: Math.min(5e3, a),
+    startDelay: t.startDelayMs !== void 0 && t.startDelayMs > 0 ? t.startDelayMs : 0,
+    strongMagnitude: u(t.strong),
+    weakMagnitude: u(t.weak)
+  };
+}
+function i() {
+  return typeof navigator < "u" && typeof navigator.getGamepads == "function" ? navigator.getGamepads() : [];
+}
+async function c(t, a) {
+  const r = t?.vibrationActuator;
+  if (!r || typeof r.playEffect != "function") return !1;
+  const e = o(a);
+  if (e.strongMagnitude === 0 && e.weakMagnitude === 0) return !1;
+  try {
+    const n = await r.playEffect("dual-rumble", e);
+    return n === "complete" || n === "preempted" || n === void 0;
+  } catch {
+    return !1;
+  }
+}
+function s(t, a, r = i) {
+  return c(r()[t], a);
+}
+async function d(t, a = i) {
+  try {
+    await a()[t]?.vibrationActuator?.reset?.();
+  } catch {
+  }
+}
+export {
+  s as rumble,
+  c as rumblePad,
+  o as rumbleParams,
+  d as stopRumble
+};

package/dist/input/stickAxis.js

@@ -0,0 +1,22 @@
+const a = 0.28;
+function h(t, n, r) {
+  if (r <= 0) return { x: 0, y: 0 };
+  const o = Math.hypot(t, n);
+  if (o === 0) return { x: 0, y: 0 };
+  const c = o > r ? 1 / o : 1 / r;
+  return { x: t * c, y: n * c };
+}
+function s(t, n = 0.28) {
+  return Math.hypot(t.x, t.y) >= n;
+}
+function i(t, n = 0.28) {
+  if (!s(t, n)) return { dx: 0, dy: 0 };
+  const o = Math.round(Math.atan2(t.y, t.x) / (Math.PI / 4)) * (Math.PI / 4), c = (e) => Math.abs(e) < 1e-9 ? 0 : Math.sign(e);
+  return { dx: c(Math.cos(o)), dy: c(Math.sin(o)) };
+}
+export {
+  a as STICK_DEAD_ZONE,
+  s as stickActive,
+  i as stickToAxis,
+  h as stickVector
+};

package/dist/input/touchDetect.js

@@ -0,0 +1,6 @@
+function e(r) {
+  return r.override === "1" || r.override === "on" ? !0 : r.override === "0" || r.override === "off" ? !1 : r.native ? !0 : r.coarse && r.touchPoints > 0;
+}
+export {
+  e as detectTouch
+};

package/dist/light/LightLayer.js

@@ -0,0 +1,83 @@
+import { RenderTexture as M, Sprite as c, Container as w, Texture as f } from "pixi.js";
+let o = null;
+function m() {
+  if (o) return o;
+  const h = 256, t = document.createElement("canvas");
+  t.width = t.height = h;
+  const s = t.getContext("2d");
+  if (!s) return f.EMPTY;
+  const e = s.createRadialGradient(h / 2, h / 2, 0, h / 2, h / 2, h / 2);
+  return e.addColorStop(0, "rgba(255,255,255,1)"), e.addColorStop(0.35, "rgba(255,255,255,0.75)"), e.addColorStop(0.7, "rgba(255,255,255,0.25)"), e.addColorStop(1, "rgba(255,255,255,0)"), s.fillStyle = e, s.fillRect(0, 0, h, h), o = f.from(t), o.source.scaleMode = "linear", o;
+}
+class x {
+  constructor(t, s = {}) {
+    this.stage = t, this.ambient = s.ambient ?? 658468, this.darkness = s.darkness ?? 0.85, this.tint = s.tint ?? 0.35, this.squash = s.squash ?? 1, this.scratch.addChild(this.sheet, this.holes), this.rt = M.create({ width: 1, height: 1 }), this.view = new c(this.rt), this.washes.blendMode = "add", t.screen.addChild(this.view, this.washes), this.unsubscribe = t.onResize(() => this.fit()), this.fit();
+  }
+  stage;
+  lights = /* @__PURE__ */ new Set();
+  scratch = new w();
+  sheet = new c(f.WHITE);
+  holes = new w();
+  washes = new w();
+  view;
+  rt;
+  pool = [];
+  ambient;
+  darkness;
+  tint;
+  squash;
+  unsubscribe;
+  add(t) {
+    return this.lights.add(t), t;
+  }
+  remove(t) {
+    this.lights.delete(t);
+  }
+  clear() {
+    this.lights.clear();
+  }
+  /** Changes the dark: its colour and how dark (a day/night cycle eases these). */
+  setAmbient(t, s) {
+    this.ambient = t, this.darkness = Math.min(1, Math.max(0, s));
+  }
+  /** Redraws the dark with this frame's lights. Call once a frame, after the camera moved. */
+  update(t = performance.now()) {
+    const s = this.darkness > 4e-3;
+    if (this.view.visible = s, this.washes.visible = s, !s) return;
+    const e = this.stage.cameras.main, a = e.zoom;
+    this.sheet.tint = this.ambient, this.sheet.alpha = this.darkness;
+    let b = 0;
+    for (const i of this.lights) {
+      if (i.on === !1 || i.radius <= 0) continue;
+      const d = (i.x - e.scrollX) * a, u = (i.y - e.scrollY) * a, p = i.flicker ? 1 + Math.sin(t / 97 + i.x) * Math.sin(t / 53 + i.y) * i.flicker : 1, r = i.radius * a * p;
+      if (d < -r || u < -r || d > e.width + r || u > e.height + r) continue;
+      const n = this.sprites(b++), g = Math.min(1, Math.max(0, i.intensity ?? 1));
+      for (const l of [n.hole, n.wash])
+        l.visible = !0, l.position.set(d, u), l.width = r * 2, l.height = r * 2 * this.squash;
+      n.hole.alpha = g, n.wash.tint = i.color ?? 16773340, n.wash.alpha = g * this.tint;
+    }
+    for (let i = b; i < this.pool.length; i++)
+      this.pool[i].hole.visible = !1, this.pool[i].wash.visible = !1;
+    this.stage.app.renderer.render({ container: this.scratch, target: this.rt, clear: !0 });
+  }
+  destroy() {
+    this.unsubscribe(), this.view.destroy(), this.washes.destroy({ children: !0 }), this.scratch.destroy({ children: !0 }), this.rt.destroy(!0), this.lights.clear();
+  }
+  sprites(t) {
+    let s = this.pool[t];
+    if (!s) {
+      const e = new c(m());
+      e.anchor.set(0.5), e.blendMode = "erase";
+      const a = new c(m());
+      a.anchor.set(0.5), this.holes.addChild(e), this.washes.addChild(a), s = { hole: e, wash: a }, this.pool.push(s);
+    }
+    return s;
+  }
+  fit() {
+    const t = Math.max(1, Math.ceil(this.stage.width)), s = Math.max(1, Math.ceil(this.stage.height));
+    this.rt.resize(t, s), this.sheet.width = t, this.sheet.height = s;
+  }
+}
+export {
+  x as LightLayer
+};

package/dist/nav/MinHeap.js

@@ -0,0 +1,38 @@
+class c {
+  items = [];
+  prio = [];
+  get size() {
+    return this.items.length;
+  }
+  push(s, e) {
+    const h = this.items, o = this.prio;
+    h.push(s), o.push(e);
+    let i = h.length - 1;
+    for (; i > 0; ) {
+      const t = i - 1 >> 1;
+      if (o[t] <= o[i]) break;
+      [h[t], h[i]] = [h[i], h[t]], [o[t], o[i]] = [o[i], o[t]], i = t;
+    }
+  }
+  /** The index with the lowest priority, removed. Only call while `size > 0`. */
+  pop() {
+    const s = this.items, e = this.prio, h = s[0], o = s.pop(), i = e.pop();
+    if (s.length > 0) {
+      s[0] = o, e[0] = i;
+      let t = 0;
+      for (; ; ) {
+        const p = t * 2 + 1, l = p + 1;
+        let n = t;
+        if (p < s.length && e[p] < e[n] && (n = p), l < s.length && e[l] < e[n] && (n = l), n === t) break;
+        [s[t], s[n]] = [s[n], s[t]], [e[t], e[n]] = [e[n], e[t]], t = n;
+      }
+    }
+    return h;
+  }
+  clear() {
+    this.items.length = 0, this.prio.length = 0;
+  }
+}
+export {
+  c as MinHeap
+};

package/dist/nav/findPath.js

@@ -0,0 +1,77 @@
+import { MinHeap as z } from "./MinHeap.js";
+import { isOpen as C, NAV_STEPS as N, canStep as P } from "./navGrid.js";
+import { nearestOpen as T } from "./nearestOpen.js";
+function U(t, n) {
+  const e = Math.abs(t), c = Math.abs(n);
+  return e + c + (Math.SQRT2 - 2) * Math.min(e, c);
+}
+function W(t) {
+  if ("test" in t) return { test: t.test, estimate: t.estimate ?? (() => 0) };
+  const n = t.reach ?? 0;
+  return {
+    test: (e, c) => Math.hypot(e - t.x, c - t.y) <= n + 1e-9,
+    // less the goal's own radius: never more than the real remaining cost
+    estimate: (e, c) => Math.max(0, U(t.x - e, t.y - c) - n)
+  };
+}
+function Q(t, n, e, c = {}) {
+  const { cost: f, endOnly: S, maxNodes: w = 14e3 } = c, s = C(t, n.x, n.y) ? n : T(t, n.x, n.y);
+  if (!s) return null;
+  const i = W(e);
+  if (i.test(s.x, s.y)) return [{ x: s.x, y: s.y }];
+  const r = t.width, m = r * t.height, y = new Float64Array(m).fill(1 / 0), M = new Int32Array(m).fill(-1), I = new Uint8Array(m), u = new z(), h = s.y * r + s.x;
+  y[h] = 0, u.push(h, i.estimate(s.x, s.y));
+  let x = 0;
+  for (; u.size > 0 && x < w; ) {
+    const o = u.pop();
+    if (I[o]) continue;
+    I[o] = 1, x++;
+    const l = o % r, O = o / r | 0;
+    if (i.test(l, O)) {
+      const p = [];
+      for (let a = o; a !== -1; a = M[a]) p.push({ x: a % r, y: a / r | 0 });
+      return p.reverse();
+    }
+    for (const [p, a, A] of N) {
+      if (!P(t, l, O, p, a, S, i.test)) continue;
+      const d = l + p, b = O + a, F = b * r + d;
+      if (I[F]) continue;
+      const v = y[o] + A + (f ? f(d, b) : 0);
+      v >= y[F] || (y[F] = v, M[F] = o, u.push(F, v + i.estimate(d, b)));
+    }
+  }
+  return null;
+}
+function R(t, n, e = {}) {
+  const { cost: c, endOnly: f, maxCost: S = 1 / 0 } = e, w = t.width, s = w * t.height, i = new Float32Array(s).fill(1 / 0), r = C(t, n.x, n.y) ? n : T(t, n.x, n.y);
+  if (!r) return i;
+  const m = new Uint8Array(s), y = new z(), M = r.y * w + r.x;
+  i[M] = 0, y.push(M, 0);
+  const I = () => !0;
+  for (; y.size > 0; ) {
+    const u = y.pop();
+    if (m[u]) continue;
+    m[u] = 1;
+    const h = u % w, x = u / w | 0;
+    if (!(u !== M && f?.(h, x)))
+      for (const [o, l, O] of N) {
+        if (!P(t, h, x, o, l, f, I) || f && o !== 0 && l !== 0 && (f(h + o, x) || f(h, x + l))) continue;
+        const p = h + o, a = x + l, A = a * w + p;
+        if (m[A]) continue;
+        const d = i[u] + O + (c ? c(p, a) : 0);
+        d >= i[A] || d > S || (i[A] = d, y.push(A, d));
+      }
+  }
+  return i;
+}
+function V(t) {
+  let n = 0;
+  for (let e = 0; e < t.length; e++) t[e] !== 1 / 0 && n++;
+  return n;
+}
+export {
+  Q as findPath,
+  R as floodFill,
+  U as octile,
+  V as reachedCount
+};

package/dist/nav/navGrid.js

@@ -0,0 +1,35 @@
+import { isSolidTile as s } from "../net/movement.js";
+function S(r, n, t) {
+  return { width: r, height: n, walkable: t };
+}
+function T(r) {
+  return { width: r.width, height: r.height, walkable: (n, t) => !s(r, n, t) };
+}
+function e(r, n, t) {
+  return n >= 0 && t >= 0 && n < r.width && t < r.height && r.walkable(n, t);
+}
+function w(r, n = 1.4) {
+  return (t, i) => !e(r, t + 1, i) || !e(r, t - 1, i) || !e(r, t, i + 1) || !e(r, t, i - 1) ? n : 0;
+}
+const p = [
+  [1, 0, 1],
+  [-1, 0, 1],
+  [0, 1, 1],
+  [0, -1, 1],
+  [1, 1, Math.SQRT2],
+  [1, -1, Math.SQRT2],
+  [-1, 1, Math.SQRT2],
+  [-1, -1, Math.SQRT2]
+];
+function M(r, n, t, i, a, f, u) {
+  const o = n + i, h = t + a;
+  return !(!e(r, o, h) || f && f(o, h) && !u(o, h) || i !== 0 && a !== 0 && (!e(r, n + i, t) || !e(r, n, t + a) || f && (f(n + i, t) && !u(n + i, t) || f(n, t + a) && !u(n, t + a))));
+}
+export {
+  p as NAV_STEPS,
+  M as canStep,
+  e as isOpen,
+  S as navGrid,
+  T as navGridFromCollision,
+  w as nearWallCost
+};

package/dist/nav/nearestOpen.js

@@ -0,0 +1,18 @@
+import { isOpen as b } from "./navGrid.js";
+function c(s, f, i, u = 12, l = (e, t) => b(s, e, t)) {
+  if (l(f, i)) return { x: f, y: i };
+  for (let e = 1; e <= u; e++) {
+    let t = null, o = 1 / 0;
+    for (let n = -e; n <= e; n++)
+      for (let r = -e; r <= e; r++) {
+        if (Math.max(Math.abs(r), Math.abs(n)) !== e || !l(f + r, i + n)) continue;
+        const a = r * r + n * n;
+        a < o && (o = a, t = { x: f + r, y: i + n });
+      }
+    if (t) return t;
+  }
+  return null;
+}
+export {
+  c as nearestOpen
+};

package/dist/nav/straightenPath.js

@@ -0,0 +1,50 @@
+import { canStep as S } from "./navGrid.js";
+const T = 48;
+function C(o, t, l = {}) {
+  if (t.length < 3) return t.slice();
+  const u = l.cost, i = (n, s, c) => (c ? Math.SQRT2 : 1) + (u ? u(n, s) : 0), r = [0];
+  for (let n = 1; n < t.length; n++) {
+    const s = t[n - 1], c = t[n];
+    r.push(r[n - 1] + i(c.x, c.y, s.x !== c.x && s.y !== c.y));
+  }
+  const b = t[t.length - 1], f = [t[0]];
+  let e = 0;
+  for (; e < t.length - 1; ) {
+    let n = !1;
+    for (let s = Math.min(t.length - 1, e + T); s >= e + 2 && !n; s--) {
+      const c = r[s] - r[e] + 1e-6;
+      for (const h of [!0, !1]) {
+        const g = W(o, t[e], t[s], h, l.endOnly, b, c, i);
+        if (g) {
+          f.push(...g), e = s, n = !0;
+          break;
+        }
+      }
+    }
+    n || f.push(t[++e]);
+  }
+  return f;
+}
+function W(o, t, l, u, i, r, b, f) {
+  const e = l.x - t.x, n = l.y - t.y, s = Math.min(Math.abs(e), Math.abs(n)), c = Math.max(Math.abs(e), Math.abs(n)) - s, h = [Math.sign(e), Math.sign(n)], g = Math.abs(e) > Math.abs(n) ? [Math.sign(e), 0] : [0, Math.sign(n)], w = u ? [[h, s], [g, c]] : [[g, c], [h, s]], O = (x, y) => x === r.x && y === r.y, d = [];
+  let a = t.x, M = t.y, m = 0;
+  for (const [[x, y], P] of w)
+    for (let k = 0; k < P; k++) {
+      if (!S(o, a, M, x, y, i, O) || (a += x, M += y, m += f(a, M, x !== 0 && y !== 0), m > b)) return null;
+      d.push({ x: a, y: M });
+    }
+  return d;
+}
+function D(o) {
+  if (o.length < 3) return o.slice();
+  const t = [o[0]];
+  for (let l = 1; l < o.length - 1; l++) {
+    const u = t[t.length - 1], i = o[l], r = o[l + 1];
+    (i.x - u.x) * (r.y - i.y) !== (i.y - u.y) * (r.x - i.x) && t.push(i);
+  }
+  return t.push(o[o.length - 1]), t;
+}
+export {
+  D as simplifyPath,
+  C as straightenPath
+};