1681-engine 0.0.0-stage → 0.5.8

package/dist/input/keyChord.js

@@ -0,0 +1,29 @@
+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
+};
+//# sourceMappingURL=keyChord.js.map

package/dist/input/keyChord.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyChord.js","sources":["../../src/input/keyChord.ts"],"sourcesContent":["/**\n * A key binding with modifiers: `Shift+Tab`, `Ctrl+KeyS`, `Ctrl+Shift+KeyZ`. The last part is the key's\n * `KeyboardEvent.code`; before it, any of `Shift`, `Ctrl`, `Alt`, `Meta`, either side of the keyboard counting.\n * A chord matches while its key and every modifier it names are held; modifiers it does not name are not looked at.\n */\nexport interface KeyChord {\n  code: string;\n  /** The modifiers' key codes, each a pair: either one held counts. */\n  modifiers: readonly (readonly [string, string])[];\n}\n\nconst MODIFIERS: Readonly<Record<string, readonly [string, string]>> = {\n  Shift: ['ShiftLeft', 'ShiftRight'],\n  Ctrl: ['ControlLeft', 'ControlRight'],\n  Alt: ['AltLeft', 'AltRight'],\n  Meta: ['MetaLeft', 'MetaRight'],\n};\n\n/** The chord a binding names, or null for a plain key (no `+`) or a malformed one (an unknown modifier). */\nexport function parseChord(binding: string): KeyChord | null {\n  const parts = binding.split('+');\n  if (parts.length < 2) return null;\n  const code = parts[parts.length - 1]!;\n  if (!code) return null;\n  const modifiers: (readonly [string, string])[] = [];\n  for (const name of parts.slice(0, -1)) {\n    const pair = MODIFIERS[name];\n    if (!pair) return null;\n    modifiers.push(pair);\n  }\n  return { code, modifiers };\n}\n\n/** Whether `chord` is held, given which keys are down. */\nexport function chordHeld(chord: KeyChord, down: (code: string) => boolean): boolean {\n  if (!down(chord.code)) return false;\n  for (const [left, right] of chord.modifiers) if (!down(left) && !down(right)) return false;\n  return true;\n}\n"],"names":["MODIFIERS","parseChord","binding","parts","code","modifiers","name","pair","chordHeld","chord","down","left","right"],"mappings":"AAWA,MAAMA,IAAiE;AAAA,EACrE,OAAO,CAAC,aAAa,YAAY;AAAA,EACjC,MAAM,CAAC,eAAe,cAAc;AAAA,EACpC,KAAK,CAAC,WAAW,UAAU;AAAA,EAC3B,MAAM,CAAC,YAAY,WAAW;AAChC;AAGO,SAASC,EAAWC,GAAkC;AAC3D,QAAMC,IAAQD,EAAQ,MAAM,GAAG;AAC/B,MAAIC,EAAM,SAAS,EAAG,QAAO;AAC7B,QAAMC,IAAOD,EAAMA,EAAM,SAAS,CAAC;AACnC,MAAI,CAACC,EAAM,QAAO;AAClB,QAAMC,IAA2C,CAAA;AACjD,aAAWC,KAAQH,EAAM,MAAM,GAAG,EAAE,GAAG;AACrC,UAAMI,IAAOP,EAAUM,CAAI;AAC3B,QAAI,CAACC,EAAM,QAAO;AAClB,IAAAF,EAAU,KAAKE,CAAI;AAAA,EACrB;AACA,SAAO,EAAE,MAAAH,GAAM,WAAAC,EAAA;AACjB;AAGO,SAASG,EAAUC,GAAiBC,GAA0C;AACnF,MAAI,CAACA,EAAKD,EAAM,IAAI,EAAG,QAAO;AAC9B,aAAW,CAACE,GAAMC,CAAK,KAAKH,EAAM,UAAW,KAAI,CAACC,EAAKC,CAAI,KAAK,CAACD,EAAKE,CAAK,EAAG,QAAO;AACrF,SAAO;AACT;"}

package/dist/input/longPress.js

@@ -0,0 +1,32 @@
+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
+};
+//# sourceMappingURL=longPress.js.map

package/dist/input/longPress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"longPress.js","sources":["../../src/input/longPress.ts"],"sourcesContent":["/**\n * A long press, as pure timing so it can be tested: a finger that stays down `ms` without moving more than `slop`\n * CSS px fires once, where it went down. A second finger, a move past the slop or a lift before the time is up is\n * not a long press — a tap stays a tap. The caller owns the clock (`fire(now)` from a timer or a frame).\n */\nexport class LongPress {\n  private finger: { id: number; x: number; y: number; at: number } | null = null;\n  private done = false;\n\n  constructor(\n    readonly ms = 480,\n    readonly slop = 10,\n  ) {}\n\n  down(id: number, x: number, y: number, now: number): void {\n    // a second finger means a pinch or the other thumb, never a press on one body\n    if (this.finger) {\n      this.finger = null;\n      this.done = true;\n      return;\n    }\n    this.finger = { id, x, y, at: now };\n    this.done = false;\n  }\n\n  move(id: number, x: number, y: number): void {\n    const f = this.finger;\n    if (f && f.id === id && Math.hypot(x - f.x, y - f.y) > this.slop) this.finger = null;\n  }\n\n  up(id: number): void {\n    if (this.finger?.id === id) this.finger = null;\n    if (!this.finger) this.done = false;\n  }\n\n  /** Where the press is, the first time this is asked at or after `ms`; null otherwise. */\n  fire(now: number): { x: number; y: number } | null {\n    const f = this.finger;\n    if (!f || this.done || now - f.at < this.ms) return null;\n    this.done = true;\n    return { x: f.x, y: f.y };\n  }\n}\n"],"names":["LongPress","ms","slop","id","x","y","now","f"],"mappings":"AAKO,MAAMA,EAAU;AAAA,EAIrB,YACWC,IAAK,KACLC,IAAO,IAChB;AAFS,SAAA,KAAAD,GACA,KAAA,OAAAC;AAAA,EACR;AAAA,EAFQ;AAAA,EACA;AAAA,EALH,SAAkE;AAAA,EAClE,OAAO;AAAA,EAOf,KAAKC,GAAYC,GAAWC,GAAWC,GAAmB;AAExD,QAAI,KAAK,QAAQ;AACf,WAAK,SAAS,MACd,KAAK,OAAO;AACZ;AAAA,IACF;AACA,SAAK,SAAS,EAAE,IAAAH,GAAI,GAAAC,GAAG,GAAAC,GAAG,IAAIC,EAAA,GAC9B,KAAK,OAAO;AAAA,EACd;AAAA,EAEA,KAAKH,GAAYC,GAAWC,GAAiB;AAC3C,UAAME,IAAI,KAAK;AACf,IAAIA,KAAKA,EAAE,OAAOJ,KAAM,KAAK,MAAMC,IAAIG,EAAE,GAAGF,IAAIE,EAAE,CAAC,IAAI,KAAK,cAAW,SAAS;AAAA,EAClF;AAAA,EAEA,GAAGJ,GAAkB;AACnB,IAAI,KAAK,QAAQ,OAAOA,WAAS,SAAS,OACrC,KAAK,WAAQ,KAAK,OAAO;AAAA,EAChC;AAAA;AAAA,EAGA,KAAKG,GAA8C;AACjD,UAAMC,IAAI,KAAK;AACf,WAAI,CAACA,KAAK,KAAK,QAAQD,IAAMC,EAAE,KAAK,KAAK,KAAW,QACpD,KAAK,OAAO,IACL,EAAE,GAAGA,EAAE,GAAG,GAAGA,EAAE,EAAA;AAAA,EACxB;AACF;"}

package/dist/input/stickAxis.js

@@ -0,0 +1,23 @@
+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
+};
+//# sourceMappingURL=stickAxis.js.map

package/dist/input/stickAxis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stickAxis.js","sources":["../../src/input/stickAxis.ts"],"sourcesContent":["/**\n * The virtual joystick's arithmetic, kept pure so it can be tested. The stick hands the game the **same** axis\n * the keyboard does — `stepMover` clamps every step to -1/0/1 on each axis (movement is eight-way, and the server\n * reads it the same way), so an analog stick would only be rounded there anyway. The rounding happens here instead,\n * by eight 45° sectors, so a thumb held a little off the horizontal walks straight rather than flickering between\n * east and north-east.\n */\n\n/** Below this share of the stick's radius the thumb is resting: no movement, and the aim falls back (touchAim.ts). */\nexport const STICK_DEAD_ZONE = 0.28;\n\nexport interface StickVector {\n  x: number;\n  y: number;\n}\n\n/** The thumb's offset from where the stick was planted, as a vector of length at most 1 (radius = full tilt). */\nexport function stickVector(dx: number, dy: number, radius: number): StickVector {\n  if (radius <= 0) return { x: 0, y: 0 };\n  const len = Math.hypot(dx, dy);\n  if (len === 0) return { x: 0, y: 0 };\n  const k = len > radius ? 1 / len : 1 / radius;\n  return { x: dx * k, y: dy * k };\n}\n\n/** True when the stick is tilted past the dead zone. */\nexport function stickActive(v: StickVector, deadZone = STICK_DEAD_ZONE): boolean {\n  return Math.hypot(v.x, v.y) >= deadZone;\n}\n\n/**\n * The keyboard-shaped axis for a stick vector: each of dx, dy is -1, 0 or 1 (screen y grows downward, as the\n * keyboard's \"down\" does), nothing inside the dead zone, and the nearest of the eight directions otherwise.\n */\nexport function stickToAxis(v: StickVector, deadZone = STICK_DEAD_ZONE): { dx: number; dy: number } {\n  if (!stickActive(v, deadZone)) return { dx: 0, dy: 0 };\n  const sector = Math.round(Math.atan2(v.y, v.x) / (Math.PI / 4));\n  const angle = sector * (Math.PI / 4);\n  const round = (n: number) => (Math.abs(n) < 1e-9 ? 0 : Math.sign(n));\n  return { dx: round(Math.cos(angle)), dy: round(Math.sin(angle)) };\n}\n"],"names":["STICK_DEAD_ZONE","stickVector","dx","dy","radius","len","k","stickActive","v","deadZone","stickToAxis","angle","round","n"],"mappings":"AASO,MAAMA,IAAkB;AAQxB,SAASC,EAAYC,GAAYC,GAAYC,GAA6B;AAC/E,MAAIA,KAAU,EAAG,QAAO,EAAE,GAAG,GAAG,GAAG,EAAA;AACnC,QAAMC,IAAM,KAAK,MAAMH,GAAIC,CAAE;AAC7B,MAAIE,MAAQ,EAAG,QAAO,EAAE,GAAG,GAAG,GAAG,EAAA;AACjC,QAAMC,IAAID,IAAMD,IAAS,IAAIC,IAAM,IAAID;AACvC,SAAO,EAAE,GAAGF,IAAKI,GAAG,GAAGH,IAAKG,EAAA;AAC9B;AAGO,SAASC,EAAYC,GAAgBC,IAAW,MAA0B;AAC/E,SAAO,KAAK,MAAMD,EAAE,GAAGA,EAAE,CAAC,KAAKC;AACjC;AAMO,SAASC,EAAYF,GAAgBC,IAAW,MAA6C;AAClG,MAAI,CAACF,EAAYC,GAAGC,CAAQ,UAAU,EAAE,IAAI,GAAG,IAAI,EAAA;AAEnD,QAAME,IADS,KAAK,MAAM,KAAK,MAAMH,EAAE,GAAGA,EAAE,CAAC,KAAK,KAAK,KAAK,EAAE,KACtC,KAAK,KAAK,IAC5BI,IAAQ,CAACC,MAAe,KAAK,IAAIA,CAAC,IAAI,OAAO,IAAI,KAAK,KAAKA,CAAC;AAClE,SAAO,EAAE,IAAID,EAAM,KAAK,IAAID,CAAK,CAAC,GAAG,IAAIC,EAAM,KAAK,IAAID,CAAK,CAAC,EAAA;AAChE;"}

package/dist/input/touchDetect.js

@@ -0,0 +1,7 @@
+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
+};
+//# sourceMappingURL=touchDetect.js.map

package/dist/input/touchDetect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"touchDetect.js","sources":["../../src/input/touchDetect.ts"],"sourcesContent":["/** What decides whether the touch controls are shown; read off the browser by `isTouchUi` (`platform/touch.ts`). */\nexport interface TouchEnv {\n  /** Running inside a native shell (`setNativeShell`: Capacitor, a kiosk…). */\n  native: boolean;\n  /** `(pointer: coarse)` matches: the **primary** pointer is a finger. */\n  coarse: boolean;\n  /** `navigator.maxTouchPoints`. */\n  touchPoints: number;\n  /** `?touch=1|0` in the URL or `localStorage` (`setTouchOverrideKey`), for trying the controls on a desktop browser. */\n  override: string | null;\n}\n\n/**\n * Touch controls only where a finger is the main way in: the native app always, a browser whose primary pointer\n * is coarse and that reports touch points (a phone or tablet), never a desktop — a laptop with a touch screen\n * still has a fine primary pointer and keeps its mouse and keyboard.\n */\nexport function detectTouch(env: TouchEnv): boolean {\n  if (env.override === '1' || env.override === 'on') return true;\n  if (env.override === '0' || env.override === 'off') return false;\n  if (env.native) return true;\n  return env.coarse && env.touchPoints > 0;\n}\n"],"names":["detectTouch","env"],"mappings":"AAiBO,SAASA,EAAYC,GAAwB;AAClD,SAAIA,EAAI,aAAa,OAAOA,EAAI,aAAa,OAAa,KACtDA,EAAI,aAAa,OAAOA,EAAI,aAAa,QAAc,KACvDA,EAAI,SAAe,KAChBA,EAAI,UAAUA,EAAI,cAAc;AACzC;"}

package/dist/light/LightLayer.js

@@ -0,0 +1,84 @@
+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
+};
+//# sourceMappingURL=LightLayer.js.map

package/dist/light/LightLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightLayer.js","sources":["../../src/light/LightLayer.ts"],"sourcesContent":["import { Container, RenderTexture, Sprite, Texture } from 'pixi.js';\nimport type { Stage } from '../core/Stage';\n\n/** A light in the world. Change its fields any time (follow a body by writing `x`/`y` each frame). */\nexport interface Light {\n  x: number;\n  y: number;\n  /** World px. */\n  radius: number;\n  /** The colour it casts on what it lights (default warm white). */\n  color?: number;\n  /** 0–1: how much of the dark it takes away, and how strong its colour (default 1). */\n  intensity?: number;\n  /** Radius wobble, 0–1 (a torch ≈ 0.08). */\n  flicker?: number;\n  /** A light off is kept but not drawn. */\n  on?: boolean;\n}\n\nexport interface LightLayerOptions {\n  /** Colour of the dark (default deep blue). */\n  ambient?: number;\n  /** 0 no dark at all, 1 black where nothing is lit (default 0.85). */\n  darkness?: number;\n  /** How strongly lights tint what they light, 0–1 (default 0.35). */\n  tint?: number;\n  /** A light's height over its width: the ground is seen at a slant (default 1, round; a 3/4 view ≈ 0.85). */\n  squash?: number;\n}\n\nlet gradient: Texture | null = null;\n\n/** One soft radial falloff, white with alpha, shared by every light. */\nfunction falloff(): Texture {\n  if (gradient) return gradient;\n  const size = 256;\n  const canvas = document.createElement('canvas');\n  canvas.width = canvas.height = size;\n  const ctx = canvas.getContext('2d');\n  if (!ctx) return Texture.EMPTY;\n  const g = ctx.createRadialGradient(size / 2, size / 2, 0, size / 2, size / 2, size / 2);\n  // a bright core and a long, eased tail: reads as light, not as a disc\n  g.addColorStop(0, 'rgba(255,255,255,1)');\n  g.addColorStop(0.35, 'rgba(255,255,255,0.75)');\n  g.addColorStop(0.7, 'rgba(255,255,255,0.25)');\n  g.addColorStop(1, 'rgba(255,255,255,0)');\n  ctx.fillStyle = g;\n  ctx.fillRect(0, 0, size, size);\n  gradient = Texture.from(canvas);\n  gradient.source.scaleMode = 'linear';\n  return gradient;\n}\n\n/**\n * Smooth darkness with lights cut out of it, for art that is not pixel art (the pixel module has its own dithered\n * `Darkness`). The dark is a screen-sized texture: each light erases a soft hole in it, and lays its colour over what\n * shows through. It sits on the screen layer, over the world and under the HUD you add after it.\n *\n * ```ts\n * const night = new LightLayer(stage, { darkness: 0.9 });\n * const torch = night.add({ x: 100, y: 80, radius: 90, color: 0xffb060, flicker: 0.08 });\n * // each frame: torch.x = hero.x; night.update(now);\n * ```\n */\nexport class LightLayer {\n  private readonly lights = new Set<Light>();\n  private readonly scratch = new Container();\n  private readonly sheet = new Sprite(Texture.WHITE);\n  private readonly holes = new Container();\n  private readonly washes = new Container();\n  private readonly view: Sprite;\n  private rt: RenderTexture;\n  private readonly pool: { hole: Sprite; wash: Sprite }[] = [];\n  private ambient: number;\n  private darkness: number;\n  private readonly tint: number;\n  private readonly squash: number;\n  private readonly unsubscribe: () => void;\n\n  constructor(\n    private readonly stage: Stage,\n    options: LightLayerOptions = {},\n  ) {\n    this.ambient = options.ambient ?? 0x0a0c24;\n    this.darkness = options.darkness ?? 0.85;\n    this.tint = options.tint ?? 0.35;\n    this.squash = options.squash ?? 1;\n    this.scratch.addChild(this.sheet, this.holes);\n    this.rt = RenderTexture.create({ width: 1, height: 1 });\n    this.view = new Sprite(this.rt);\n    // the colour washes sit over the dark, added to what they light\n    this.washes.blendMode = 'add';\n    stage.screen.addChild(this.view, this.washes);\n    this.unsubscribe = stage.onResize(() => this.fit());\n    this.fit();\n  }\n\n  add(light: Light): Light {\n    this.lights.add(light);\n    return light;\n  }\n\n  remove(light: Light): void {\n    this.lights.delete(light);\n  }\n\n  clear(): void {\n    this.lights.clear();\n  }\n\n  /** Changes the dark: its colour and how dark (a day/night cycle eases these). */\n  setAmbient(color: number, darkness: number): void {\n    this.ambient = color;\n    this.darkness = Math.min(1, Math.max(0, darkness));\n  }\n\n  /** Redraws the dark with this frame's lights. Call once a frame, after the camera moved. */\n  update(now = performance.now()): void {\n    const on = this.darkness > 0.004;\n    this.view.visible = on;\n    this.washes.visible = on;\n    if (!on) return;\n    const cam = this.stage.cameras.main;\n    const z = cam.zoom;\n    this.sheet.tint = this.ambient;\n    this.sheet.alpha = this.darkness;\n    let used = 0;\n    for (const l of this.lights) {\n      if (l.on === false || l.radius <= 0) continue;\n      const sx = (l.x - cam.scrollX) * z;\n      const sy = (l.y - cam.scrollY) * z;\n      const wobble = l.flicker ? 1 + Math.sin(now / 97 + l.x) * Math.sin(now / 53 + l.y) * l.flicker : 1;\n      const r = l.radius * z * wobble;\n      // off screen by more than its radius: nothing of it shows\n      if (sx < -r || sy < -r || sx > cam.width + r || sy > cam.height + r) continue;\n      const s = this.sprites(used++);\n      const intensity = Math.min(1, Math.max(0, l.intensity ?? 1));\n      for (const sprite of [s.hole, s.wash]) {\n        sprite.visible = true;\n        sprite.position.set(sx, sy);\n        sprite.width = r * 2;\n        sprite.height = r * 2 * this.squash;\n      }\n      s.hole.alpha = intensity;\n      s.wash.tint = l.color ?? 0xfff0dc;\n      s.wash.alpha = intensity * this.tint;\n    }\n    for (let i = used; i < this.pool.length; i++) {\n      this.pool[i]!.hole.visible = false;\n      this.pool[i]!.wash.visible = false;\n    }\n    this.stage.app.renderer.render({ container: this.scratch, target: this.rt, clear: true });\n  }\n\n  destroy(): void {\n    this.unsubscribe();\n    this.view.destroy();\n    this.washes.destroy({ children: true });\n    this.scratch.destroy({ children: true });\n    this.rt.destroy(true);\n    this.lights.clear();\n  }\n\n  private sprites(i: number): { hole: Sprite; wash: Sprite } {\n    let s = this.pool[i];\n    if (!s) {\n      const hole = new Sprite(falloff());\n      hole.anchor.set(0.5);\n      hole.blendMode = 'erase';\n      const wash = new Sprite(falloff());\n      wash.anchor.set(0.5);\n      this.holes.addChild(hole);\n      this.washes.addChild(wash);\n      s = { hole, wash };\n      this.pool.push(s);\n    }\n    return s;\n  }\n\n  private fit(): void {\n    const w = Math.max(1, Math.ceil(this.stage.width));\n    const h = Math.max(1, Math.ceil(this.stage.height));\n    this.rt.resize(w, h);\n    this.sheet.width = w;\n    this.sheet.height = h;\n  }\n}\n"],"names":["gradient","falloff","size","canvas","ctx","Texture","g","LightLayer","stage","options","RenderTexture","Sprite","Container","light","color","darkness","now","on","cam","z","used","l","sx","sy","wobble","s","intensity","sprite","i","hole","wash","w","h"],"mappings":"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"}

package/dist/nav/MinHeap.js

@@ -0,0 +1,39 @@
+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
+};
+//# sourceMappingURL=MinHeap.js.map

package/dist/nav/MinHeap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinHeap.js","sources":["../../src/nav/MinHeap.ts"],"sourcesContent":["/**\n * A binary min-heap of (index, priority) pairs, kept as two parallel arrays so a search over a big grid pushes\n * numbers, not objects. A stale entry (pushed again at a lower priority) is left in and skipped by the caller's\n * closed set, which is cheaper than a decrease-key.\n */\nexport class MinHeap {\n  private items: number[] = [];\n  private prio: number[] = [];\n\n  get size(): number {\n    return this.items.length;\n  }\n\n  push(index: number, priority: number): void {\n    const a = this.items;\n    const p = this.prio;\n    a.push(index);\n    p.push(priority);\n    let c = a.length - 1;\n    while (c > 0) {\n      const u = (c - 1) >> 1;\n      if (p[u]! <= p[c]!) break;\n      [a[u], a[c]] = [a[c]!, a[u]!];\n      [p[u], p[c]] = [p[c]!, p[u]!];\n      c = u;\n    }\n  }\n\n  /** The index with the lowest priority, removed. Only call while `size > 0`. */\n  pop(): number {\n    const a = this.items;\n    const p = this.prio;\n    const top = a[0]!;\n    const lastI = a.pop()!;\n    const lastF = p.pop()!;\n    if (a.length > 0) {\n      a[0] = lastI;\n      p[0] = lastF;\n      let u = 0;\n      for (;;) {\n        const l = u * 2 + 1;\n        const r = l + 1;\n        let s = u;\n        if (l < a.length && p[l]! < p[s]!) s = l;\n        if (r < a.length && p[r]! < p[s]!) s = r;\n        if (s === u) break;\n        [a[u], a[s]] = [a[s]!, a[u]!];\n        [p[u], p[s]] = [p[s]!, p[u]!];\n        u = s;\n      }\n    }\n    return top;\n  }\n\n  clear(): void {\n    this.items.length = 0;\n    this.prio.length = 0;\n  }\n}\n"],"names":["MinHeap","index","priority","a","p","c","u","top","lastI","lastF","l","r","s"],"mappings":"AAKO,MAAMA,EAAQ;AAAA,EACX,QAAkB,CAAA;AAAA,EAClB,OAAiB,CAAA;AAAA,EAEzB,IAAI,OAAe;AACjB,WAAO,KAAK,MAAM;AAAA,EACpB;AAAA,EAEA,KAAKC,GAAeC,GAAwB;AAC1C,UAAMC,IAAI,KAAK,OACTC,IAAI,KAAK;AACf,IAAAD,EAAE,KAAKF,CAAK,GACZG,EAAE,KAAKF,CAAQ;AACf,QAAIG,IAAIF,EAAE,SAAS;AACnB,WAAOE,IAAI,KAAG;AACZ,YAAMC,IAAKD,IAAI,KAAM;AACrB,UAAID,EAAEE,CAAC,KAAMF,EAAEC,CAAC,EAAI;AACpB,OAACF,EAAEG,CAAC,GAAGH,EAAEE,CAAC,CAAC,IAAI,CAACF,EAAEE,CAAC,GAAIF,EAAEG,CAAC,CAAE,GAC5B,CAACF,EAAEE,CAAC,GAAGF,EAAEC,CAAC,CAAC,IAAI,CAACD,EAAEC,CAAC,GAAID,EAAEE,CAAC,CAAE,GAC5BD,IAAIC;AAAA,IACN;AAAA,EACF;AAAA;AAAA,EAGA,MAAc;AACZ,UAAMH,IAAI,KAAK,OACTC,IAAI,KAAK,MACTG,IAAMJ,EAAE,CAAC,GACTK,IAAQL,EAAE,IAAA,GACVM,IAAQL,EAAE,IAAA;AAChB,QAAID,EAAE,SAAS,GAAG;AAChB,MAAAA,EAAE,CAAC,IAAIK,GACPJ,EAAE,CAAC,IAAIK;AACP,UAAIH,IAAI;AACR,iBAAS;AACP,cAAMI,IAAIJ,IAAI,IAAI,GACZK,IAAID,IAAI;AACd,YAAIE,IAAIN;AAGR,YAFII,IAAIP,EAAE,UAAUC,EAAEM,CAAC,IAAKN,EAAEQ,CAAC,MAAIA,IAAIF,IACnCC,IAAIR,EAAE,UAAUC,EAAEO,CAAC,IAAKP,EAAEQ,CAAC,MAAIA,IAAID,IACnCC,MAAMN,EAAG;AACb,SAACH,EAAEG,CAAC,GAAGH,EAAES,CAAC,CAAC,IAAI,CAACT,EAAES,CAAC,GAAIT,EAAEG,CAAC,CAAE,GAC5B,CAACF,EAAEE,CAAC,GAAGF,EAAEQ,CAAC,CAAC,IAAI,CAACR,EAAEQ,CAAC,GAAIR,EAAEE,CAAC,CAAE,GAC5BA,IAAIM;AAAA,MACN;AAAA,IACF;AACA,WAAOL;AAAA,EACT;AAAA,EAEA,QAAc;AACZ,SAAK,MAAM,SAAS,GACpB,KAAK,KAAK,SAAS;AAAA,EACrB;AACF;"}

package/dist/nav/findPath.js

@@ -0,0 +1,78 @@
+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
+};
+//# sourceMappingURL=findPath.js.map

package/dist/nav/findPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"findPath.js","sources":["../../src/nav/findPath.ts"],"sourcesContent":["import { MinHeap } from './MinHeap';\nimport { canStep, isOpen, NAV_STEPS, type NavGrid, type NavOptions, type TilePoint } from './navGrid';\nimport { nearestOpen } from './nearestOpen';\n\n/**\n * Where a path ends. A point goal is met anywhere within `reach` tiles of its tile (centre to centre; 0 = that tile\n * only): aiming at an exact tile sent auto-walks into a spot inside a hut and left them shuffling against its wall a\n * step from where they were already close enough. A custom goal names its own tiles, with an `estimate` of the\n * tiles left that must never be more than the real cost (0, the default, makes the search a plain Dijkstra).\n */\nexport type NavGoal = { x: number; y: number; reach?: number } | { test: (tx: number, ty: number) => boolean; estimate?: (tx: number, ty: number) => number };\n\nexport interface FindPathOptions extends NavOptions {\n  /** Tiles settled before giving up, so a goal walled off on a big map cannot stall a frame. */\n  maxNodes?: number;\n}\n\n/** Octile distance: the cost of the cheapest eight-way walk over open ground. */\nexport function octile(dx: number, dy: number): number {\n  const ax = Math.abs(dx);\n  const ay = Math.abs(dy);\n  return ax + ay + (Math.SQRT2 - 2) * Math.min(ax, ay);\n}\n\nfunction goalOf(goal: NavGoal): { test: (x: number, y: number) => boolean; estimate: (x: number, y: number) => number } {\n  if ('test' in goal) return { test: goal.test, estimate: goal.estimate ?? (() => 0) };\n  const r = goal.reach ?? 0;\n  return {\n    test: (x, y) => Math.hypot(x - goal.x, y - goal.y) <= r + 1e-9,\n    // less the goal's own radius: never more than the real remaining cost\n    estimate: (x, y) => Math.max(0, octile(goal.x - x, goal.y - y) - r),\n  };\n}\n\n/**\n * A* over the grid: the tiles from `from` to the goal, both included, or null when there is no way through. A start\n * on a wall is moved to the nearest open tile. The path is the cheapest by `cost`, but among equally cheap ones it\n * is whichever the heap settled on — often a staircase; `straightenPath` irons that out.\n */\nexport function findPath(g: NavGrid, from: TilePoint, to: NavGoal, options: FindPathOptions = {}): TilePoint[] | null {\n  const { cost, endOnly, maxNodes = 14_000 } = options;\n  const start = isOpen(g, from.x, from.y) ? from : nearestOpen(g, from.x, from.y);\n  if (!start) return null;\n  const goal = goalOf(to);\n  if (goal.test(start.x, start.y)) return [{ x: start.x, y: start.y }];\n\n  const W = g.width;\n  const n = W * g.height;\n  const best = new Float64Array(n).fill(Infinity);\n  const cameFrom = new Int32Array(n).fill(-1);\n  const closed = new Uint8Array(n);\n  const heap = new MinHeap();\n  const s = start.y * W + start.x;\n  best[s] = 0;\n  heap.push(s, goal.estimate(start.x, start.y));\n  let visited = 0;\n  while (heap.size > 0 && visited < maxNodes) {\n    const i = heap.pop();\n    if (closed[i]) continue;\n    closed[i] = 1;\n    visited++;\n    const cx = i % W;\n    const cy = (i / W) | 0;\n    if (goal.test(cx, cy)) {\n      const out: TilePoint[] = [];\n      for (let k = i; k !== -1; k = cameFrom[k]!) out.push({ x: k % W, y: (k / W) | 0 });\n      return out.reverse();\n    }\n    for (const [dx, dy, step] of NAV_STEPS) {\n      if (!canStep(g, cx, cy, dx, dy, endOnly, goal.test)) continue;\n      const nx = cx + dx;\n      const ny = cy + dy;\n      const ni = ny * W + nx;\n      if (closed[ni]) continue;\n      const tentative = best[i]! + step + (cost ? cost(nx, ny) : 0);\n      if (tentative >= best[ni]!) continue;\n      best[ni] = tentative;\n      cameFrom[ni] = i;\n      heap.push(ni, tentative + goal.estimate(nx, ny));\n    }\n  }\n  return null;\n}\n\n/**\n * Walking cost from one tile to every tile of the grid (row-major, `Infinity` where unreachable), by the same steps\n * and costs `findPath` takes — for weighing several destinations by real distance rather than by a straight line. An\n * end-only tile gets a cost (it can be stepped onto) but nothing is reached through it. `maxCost` stops the spread.\n */\nexport function floodFill(g: NavGrid, from: TilePoint, options: NavOptions & { maxCost?: number } = {}): Float32Array {\n  const { cost, endOnly, maxCost = Infinity } = options;\n  const W = g.width;\n  const n = W * g.height;\n  const out = new Float32Array(n).fill(Infinity);\n  const start = isOpen(g, from.x, from.y) ? from : nearestOpen(g, from.x, from.y);\n  if (!start) return out;\n  const closed = new Uint8Array(n);\n  const heap = new MinHeap();\n  const s = start.y * W + start.x;\n  out[s] = 0;\n  heap.push(s, 0);\n  // every end-only tile counts as a goal here, so it is reached; the check below keeps it from being passed through\n  const always = () => true;\n  while (heap.size > 0) {\n    const i = heap.pop();\n    if (closed[i]) continue;\n    closed[i] = 1;\n    const cx = i % W;\n    const cy = (i / W) | 0;\n    if (i !== s && endOnly?.(cx, cy)) continue;\n    for (const [dx, dy, step] of NAV_STEPS) {\n      if (!canStep(g, cx, cy, dx, dy, endOnly, always)) continue;\n      // a diagonal may still not brush past an end-only tile\n      if (endOnly && dx !== 0 && dy !== 0 && (endOnly(cx + dx, cy) || endOnly(cx, cy + dy))) continue;\n      const nx = cx + dx;\n      const ny = cy + dy;\n      const ni = ny * W + nx;\n      if (closed[ni]) continue;\n      const c = out[i]! + step + (cost ? cost(nx, ny) : 0);\n      if (c >= out[ni]! || c > maxCost) continue;\n      out[ni] = c;\n      heap.push(ni, c);\n    }\n  }\n  return out;\n}\n\n/** How many tiles a flood reached: a quick test that a change to the ground walled nothing off. */\nexport function reachedCount(costs: Float32Array): number {\n  let n = 0;\n  for (let i = 0; i < costs.length; i++) if (costs[i] !== Infinity) n++;\n  return n;\n}\n"],"names":["octile","dx","dy","ax","ay","goalOf","goal","r","x","y","findPath","g","from","to","options","cost","endOnly","maxNodes","start","isOpen","nearestOpen","W","n","best","cameFrom","closed","heap","MinHeap","s","visited","i","cx","cy","out","k","step","NAV_STEPS","canStep","nx","ny","ni","tentative","floodFill","maxCost","always","c","reachedCount","costs"],"mappings":"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"}

package/dist/nav/navGrid.js

@@ -0,0 +1,36 @@
+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
+};
+//# sourceMappingURL=navGrid.js.map

package/dist/nav/navGrid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navGrid.js","sources":["../../src/nav/navGrid.ts"],"sourcesContent":["import { isSolidTile, type CollisionGrid } from '../net/movement';\n\n/** A tile coordinate. */\nexport interface TilePoint {\n  x: number;\n  y: number;\n}\n\n/**\n * The ground a search walks: a width, a height and whether a body may stand on a tile. `walkable` is never asked\n * about a tile outside the grid, so a game's own test needs no bounds check.\n */\nexport interface NavGrid {\n  readonly width: number;\n  readonly height: number;\n  walkable(tx: number, ty: number): boolean;\n}\n\n/** What a search may be told beyond the grid, shared by `findPath`, `floodFill` and `straightenPath`. */\nexport interface NavOptions {\n  /**\n   * Extra cost of stepping onto a tile, on top of the step itself (1 straight, √2 diagonal). Must not be negative,\n   * or A* stops being exact. `nearWallCost` is one: it keeps a route off the edges of a clearing.\n   */\n  cost?: (tx: number, ty: number) => number;\n  /**\n   * Tiles a path may end on but never pass through or brush past diagonally: a door that throws a body onto another\n   * map, a trap, a ledge. A start standing on one may still leave it.\n   */\n  endOnly?: (tx: number, ty: number) => boolean;\n}\n\n/** A grid over any walkability test. */\nexport function navGrid(width: number, height: number, walkable: (tx: number, ty: number) => boolean): NavGrid {\n  return { width, height, walkable };\n}\n\n/** The engine's own collision grid as ground to search: a tile a body cannot stand on is a wall. */\nexport function navGridFromCollision(grid: CollisionGrid): NavGrid {\n  return { width: grid.width, height: grid.height, walkable: (tx, ty) => !isSolidTile(grid, tx, ty) };\n}\n\n/** Inside the grid and walkable. */\nexport function isOpen(g: NavGrid, tx: number, ty: number): boolean {\n  return tx >= 0 && ty >= 0 && tx < g.width && ty < g.height && g.walkable(tx, ty);\n}\n\n/**\n * A `cost` that charges `extra` for a tile with a wall beside it (four-way), so a route prefers the middle of a\n * clearing to the gap between two obstacles — the narrow way is where an auto-walking body wedges itself. 1.4 was\n * high enough to go round a thicket and low enough to still take a gate.\n */\nexport function nearWallCost(g: NavGrid, extra = 1.4): (tx: number, ty: number) => number {\n  return (x, y) => (!isOpen(g, x + 1, y) || !isOpen(g, x - 1, y) || !isOpen(g, x, y + 1) || !isOpen(g, x, y - 1) ? extra : 0);\n}\n\n/** Eight-way steps; the diagonals cost √2 so a path does not zig-zag where a straight line would do. */\nexport const NAV_STEPS: readonly (readonly [number, number, number])[] = [\n  [1, 0, 1],\n  [-1, 0, 1],\n  [0, 1, 1],\n  [0, -1, 1],\n  [1, 1, Math.SQRT2],\n  [1, -1, Math.SQRT2],\n  [-1, 1, Math.SQRT2],\n  [-1, -1, Math.SQRT2],\n];\n\n/**\n * May a body step from (cx, cy) by (dx, dy)? The tile must be open and, when it is end-only, be the goal; a diagonal\n * may not cut the corner between two walls, nor brush an end-only tile on the way past.\n */\nexport function canStep(\n  g: NavGrid,\n  cx: number,\n  cy: number,\n  dx: number,\n  dy: number,\n  endOnly: ((tx: number, ty: number) => boolean) | undefined,\n  isGoal: (tx: number, ty: number) => boolean,\n): boolean {\n  const nx = cx + dx;\n  const ny = cy + dy;\n  if (!isOpen(g, nx, ny)) return false;\n  if (endOnly && endOnly(nx, ny) && !isGoal(nx, ny)) return false;\n  if (dx !== 0 && dy !== 0) {\n    if (!isOpen(g, cx + dx, cy) || !isOpen(g, cx, cy + dy)) return false;\n    if (endOnly && ((endOnly(cx + dx, cy) && !isGoal(cx + dx, cy)) || (endOnly(cx, cy + dy) && !isGoal(cx, cy + dy)))) return false;\n  }\n  return true;\n}\n"],"names":["navGrid","width","height","walkable","navGridFromCollision","grid","tx","ty","isSolidTile","isOpen","g","nearWallCost","extra","x","y","NAV_STEPS","canStep","cx","cy","dx","dy","endOnly","isGoal","nx","ny"],"mappings":";AAiCO,SAASA,EAAQC,GAAeC,GAAgBC,GAAwD;AAC7G,SAAO,EAAE,OAAAF,GAAO,QAAAC,GAAQ,UAAAC,EAAA;AAC1B;AAGO,SAASC,EAAqBC,GAA8B;AACjE,SAAO,EAAE,OAAOA,EAAK,OAAO,QAAQA,EAAK,QAAQ,UAAU,CAACC,GAAIC,MAAO,CAACC,EAAYH,GAAMC,GAAIC,CAAE,EAAA;AAClG;AAGO,SAASE,EAAOC,GAAYJ,GAAYC,GAAqB;AAClE,SAAOD,KAAM,KAAKC,KAAM,KAAKD,IAAKI,EAAE,SAASH,IAAKG,EAAE,UAAUA,EAAE,SAASJ,GAAIC,CAAE;AACjF;AAOO,SAASI,EAAaD,GAAYE,IAAQ,KAAyC;AACxF,SAAO,CAACC,GAAGC,MAAO,CAACL,EAAOC,GAAGG,IAAI,GAAGC,CAAC,KAAK,CAACL,EAAOC,GAAGG,IAAI,GAAGC,CAAC,KAAK,CAACL,EAAOC,GAAGG,GAAGC,IAAI,CAAC,KAAK,CAACL,EAAOC,GAAGG,GAAGC,IAAI,CAAC,IAAIF,IAAQ;AAC3H;AAGO,MAAMG,IAA4D;AAAA,EACvE,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,IAAI,GAAG,CAAC;AAAA,EACT,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,IAAI,CAAC;AAAA,EACT,CAAC,GAAG,GAAG,KAAK,KAAK;AAAA,EACjB,CAAC,GAAG,IAAI,KAAK,KAAK;AAAA,EAClB,CAAC,IAAI,GAAG,KAAK,KAAK;AAAA,EAClB,CAAC,IAAI,IAAI,KAAK,KAAK;AACrB;AAMO,SAASC,EACdN,GACAO,GACAC,GACAC,GACAC,GACAC,GACAC,GACS;AACT,QAAMC,IAAKN,IAAKE,GACVK,IAAKN,IAAKE;AAGhB,SAFI,GAACX,EAAOC,GAAGa,GAAIC,CAAE,KACjBH,KAAWA,EAAQE,GAAIC,CAAE,KAAK,CAACF,EAAOC,GAAIC,CAAE,KAC5CL,MAAO,KAAKC,MAAO,MACjB,CAACX,EAAOC,GAAGO,IAAKE,GAAID,CAAE,KAAK,CAACT,EAAOC,GAAGO,GAAIC,IAAKE,CAAE,KACjDC,MAAaA,EAAQJ,IAAKE,GAAID,CAAE,KAAK,CAACI,EAAOL,IAAKE,GAAID,CAAE,KAAOG,EAAQJ,GAAIC,IAAKE,CAAE,KAAK,CAACE,EAAOL,GAAIC,IAAKE,CAAE;AAGlH;"}

package/dist/nav/nearestOpen.js

@@ -0,0 +1,19 @@
+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
+};
+//# sourceMappingURL=nearestOpen.js.map

package/dist/nav/nearestOpen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nearestOpen.js","sources":["../../src/nav/nearestOpen.ts"],"sourcesContent":["import { isOpen, type NavGrid, type TilePoint } from './navGrid';\n\n/**\n * The open tile nearest to (tx, ty) within `maxRadius` rings, or null: a start or a goal inside a rock still gets a\n * route. `ok` narrows what counts (an open tile that is not a door, say). On each ring the closest tile wins, not\n * the first scanned — scanning order once always picked the ring's top-left corner.\n */\nexport function nearestOpen(\n  g: NavGrid,\n  tx: number,\n  ty: number,\n  maxRadius = 12,\n  ok: (x: number, y: number) => boolean = (x, y) => isOpen(g, x, y),\n): TilePoint | null {\n  if (ok(tx, ty)) return { x: tx, y: ty };\n  for (let r = 1; r <= maxRadius; r++) {\n    let best: TilePoint | null = null;\n    let bestD = Infinity;\n    for (let dy = -r; dy <= r; dy++)\n      for (let dx = -r; dx <= r; dx++) {\n        if (Math.max(Math.abs(dx), Math.abs(dy)) !== r || !ok(tx + dx, ty + dy)) continue;\n        const d = dx * dx + dy * dy;\n        if (d < bestD) {\n          bestD = d;\n          best = { x: tx + dx, y: ty + dy };\n        }\n      }\n    if (best) return best;\n  }\n  return null;\n}\n"],"names":["nearestOpen","g","tx","ty","maxRadius","ok","x","y","isOpen","r","best","bestD","dy","dx","d"],"mappings":";AAOO,SAASA,EACdC,GACAC,GACAC,GACAC,IAAY,IACZC,IAAwC,CAACC,GAAGC,MAAMC,EAAOP,GAAGK,GAAGC,CAAC,GAC9C;AAClB,MAAIF,EAAGH,GAAIC,CAAE,UAAU,EAAE,GAAGD,GAAI,GAAGC,EAAA;AACnC,WAASM,IAAI,GAAGA,KAAKL,GAAWK,KAAK;AACnC,QAAIC,IAAyB,MACzBC,IAAQ;AACZ,aAASC,IAAK,CAACH,GAAGG,KAAMH,GAAGG;AACzB,eAASC,IAAK,CAACJ,GAAGI,KAAMJ,GAAGI,KAAM;AAC/B,YAAI,KAAK,IAAI,KAAK,IAAIA,CAAE,GAAG,KAAK,IAAID,CAAE,CAAC,MAAMH,KAAK,CAACJ,EAAGH,IAAKW,GAAIV,IAAKS,CAAE,EAAG;AACzE,cAAME,IAAID,IAAKA,IAAKD,IAAKA;AACzB,QAAIE,IAAIH,MACNA,IAAQG,GACRJ,IAAO,EAAE,GAAGR,IAAKW,GAAI,GAAGV,IAAKS,EAAA;AAAA,MAEjC;AACF,QAAIF,EAAM,QAAOA;AAAA,EACnB;AACA,SAAO;AACT;"}

package/dist/nav/straightenPath.js

@@ -0,0 +1,51 @@
+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
+};
+//# sourceMappingURL=straightenPath.js.map

package/dist/nav/straightenPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"straightenPath.js","sources":["../../src/nav/straightenPath.ts"],"sourcesContent":["import { canStep, type NavGrid, type NavOptions, type TilePoint } from './navGrid';\n\n/** How many tiles ahead `straightenPath` looks for a straighter way: enough for a long staircase, cheap per re-solve. */\nconst WINDOW = 48;\n\n/**\n * The same route with fewer turns. An eight-way search finds many equally short paths and hands back whichever its\n * heap settled on, often a staircase — diagonal, straight, diagonal, straight — and a body walking one turns on every\n * tile. Each stretch that can be is replaced with the plainest equal way through it: one diagonal run and one straight\n * run. A replacement must cost no more than the stretch did (by the same `cost`, so it never trades the middle of a\n * clearing for the edge of a wall), step only where the search could, and touch no end-only tile short of the end.\n * Pass the options the path was found with.\n */\nexport function straightenPath(g: NavGrid, path: readonly TilePoint[], options: NavOptions = {}): TilePoint[] {\n  if (path.length < 3) return path.slice();\n  const extra = options.cost;\n  const stepCost = (x: number, y: number, diagonal: boolean) => (diagonal ? Math.SQRT2 : 1) + (extra ? extra(x, y) : 0);\n  const upTo = [0];\n  for (let k = 1; k < path.length; k++) {\n    const a = path[k - 1]!;\n    const b = path[k]!;\n    upTo.push(upTo[k - 1]! + stepCost(b.x, b.y, a.x !== b.x && a.y !== b.y));\n  }\n  const last = path[path.length - 1]!;\n  const out: TilePoint[] = [path[0]!];\n  let i = 0;\n  while (i < path.length - 1) {\n    let taken = false;\n    for (let j = Math.min(path.length - 1, i + WINDOW); j >= i + 2 && !taken; j--) {\n      const budget = upTo[j]! - upTo[i]! + 1e-6;\n      for (const diagonalFirst of [true, false]) {\n        const legs = twoLegs(g, path[i]!, path[j]!, diagonalFirst, options.endOnly, last, budget, stepCost);\n        if (!legs) continue;\n        out.push(...legs);\n        i = j;\n        taken = true;\n        break;\n      }\n    }\n    if (!taken) out.push(path[++i]!);\n  }\n  return out;\n}\n\n/** The tiles after `a` up to `b` along one diagonal run and one straight run, or null when that way is shut or dearer. */\nfunction twoLegs(\n  g: NavGrid,\n  a: TilePoint,\n  b: TilePoint,\n  diagonalFirst: boolean,\n  endOnly: ((tx: number, ty: number) => boolean) | undefined,\n  last: TilePoint,\n  budget: number,\n  stepCost: (x: number, y: number, diagonal: boolean) => number,\n): TilePoint[] | null {\n  const dx = b.x - a.x;\n  const dy = b.y - a.y;\n  const diag = Math.min(Math.abs(dx), Math.abs(dy));\n  const straight = Math.max(Math.abs(dx), Math.abs(dy)) - diag;\n  const d: [number, number] = [Math.sign(dx), Math.sign(dy)];\n  const s: [number, number] = Math.abs(dx) > Math.abs(dy) ? [Math.sign(dx), 0] : [0, Math.sign(dy)];\n  const runs: [[number, number], number][] = diagonalFirst ? [[d, diag], [s, straight]] : [[s, straight], [d, diag]];\n  // only the path's own last tile may be end-only\n  const isEnd = (x: number, y: number) => x === last.x && y === last.y;\n  const tiles: TilePoint[] = [];\n  let x = a.x;\n  let y = a.y;\n  let cost = 0;\n  for (const [[sx, sy], n] of runs) {\n    for (let k = 0; k < n; k++) {\n      if (!canStep(g, x, y, sx, sy, endOnly, isEnd)) return null;\n      x += sx;\n      y += sy;\n      cost += stepCost(x, y, sx !== 0 && sy !== 0);\n      if (cost > budget) return null;\n      tiles.push({ x, y });\n    }\n  }\n  return tiles;\n}\n\n/** Drops the tiles a straight line already covers, so a trail is drawn as a few long legs rather than tile by tile. */\nexport function simplifyPath(path: readonly TilePoint[]): TilePoint[] {\n  if (path.length < 3) return path.slice();\n  const out: TilePoint[] = [path[0]!];\n  for (let i = 1; i < path.length - 1; i++) {\n    const a = out[out.length - 1]!;\n    const b = path[i]!;\n    const c = path[i + 1]!;\n    if ((b.x - a.x) * (c.y - b.y) !== (b.y - a.y) * (c.x - b.x)) out.push(b);\n  }\n  out.push(path[path.length - 1]!);\n  return out;\n}\n"],"names":["WINDOW","straightenPath","g","path","options","extra","stepCost","x","y","diagonal","upTo","k","a","b","last","out","i","taken","j","budget","diagonalFirst","legs","twoLegs","endOnly","dx","dy","diag","straight","d","s","runs","isEnd","tiles","cost","sx","sy","n","canStep","simplifyPath","c"],"mappings":"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"}

package/dist/net/Connection.js

@@ -0,0 +1,84 @@
+import { EventBus as o } from "../events/EventBus.js";
+import { noteServerTime as r } from "./serverClock.js";
+import { decodeSnapshotFrame as h } from "./snapshotCodec.js";
+class m {
+  constructor(e, t = {}) {
+    this.url = e, this.options = t;
+  }
+  url;
+  options;
+  events = new o();
+  /** The last measured round trip, ms. */
+  rtt = 0;
+  socket = null;
+  batch = null;
+  closedByUs = !1;
+  attempt = 0;
+  pingTimer = null;
+  retryTimer = null;
+  get open() {
+    return this.socket?.readyState === 1;
+  }
+  connect() {
+    this.closedByUs = !1;
+    const e = this.options.WebSocket ?? globalThis.WebSocket;
+    if (!e) throw new Error("Connection: no WebSocket in this environment");
+    const t = new e(this.url);
+    return t.binaryType = "arraybuffer", this.socket = t, t.onopen = () => {
+      this.attempt = 0, this.send({ t: "hello", data: this.options.hello?.() }), this.ping(), this.pingTimer = setInterval(() => this.ping(), this.options.pingMs ?? 1e3), this.events.emit("open", void 0);
+    }, t.onmessage = (s) => this.receive(s.data), t.onclose = (s) => {
+      this.pingTimer && clearInterval(this.pingTimer), this.pingTimer = null, this.socket = null;
+      const i = !this.closedByUs && this.options.reconnect !== !1;
+      if (this.events.emit("close", { code: s.code, reason: s.reason, willRetry: i }), i) {
+        const n = Math.min(this.options.maxBackoffMs ?? 1e4, 250 * 2 ** this.attempt++);
+        this.retryTimer = setTimeout(() => this.connect(), n);
+      }
+    }, this;
+  }
+  /** Sends a message now (dropped while closed: input is resent by the prediction's own state, not by the socket). */
+  send(e) {
+    this.socket?.readyState === 1 && this.socket.send(JSON.stringify(e));
+  }
+  /** Adds one input step to this frame's batch; `flush` sends it. Steps must come in sequence order. */
+  queueInput(e, t) {
+    this.batch || (this.batch = { seq: e, steps: [] }), this.batch.steps.push([t[0], t[1], t[2]]);
+  }
+  /** Sends this frame's input steps as one message. Call once a frame. */
+  flush() {
+    this.batch && (this.send({ t: "input", seq: this.batch.seq, steps: this.batch.steps }), this.batch = null);
+  }
+  close() {
+    this.closedByUs = !0, this.retryTimer && clearTimeout(this.retryTimer), this.pingTimer && clearInterval(this.pingTimer), this.socket?.close(), this.socket = null;
+  }
+  ping() {
+    this.send({ t: "ping", c: Date.now() });
+  }
+  receive(e) {
+    let t;
+    try {
+      t = typeof e == "string" ? JSON.parse(e) : h(e);
+    } catch (s) {
+      console.error("[net] could not read a message", s);
+      return;
+    }
+    switch (t.t) {
+      case "pong": {
+        const s = t;
+        this.rtt = Date.now() - s.c, r(s.st, this.rtt);
+        return;
+      }
+      case "welcome":
+        this.events.emit("welcome", t);
+        return;
+      case "snap":
+        this.events.emit("snapshot", t);
+        return;
+      default:
+        this.events.emit("message", t);
+    }
+  }
+}
+export {
+  m as Connection
+};
+//# sourceMappingURL=Connection.js.map