1681-engine 0.0.0-stage → 0.5.9

package/dist/physics/collide.js

@@ -0,0 +1,75 @@
+import { circlePolygon as _, polygonPolygon as W } from "./collidePolygon.js";
+import { FACE_RIGHT as m, FACE_LEFT as C, FACE_BOTTOM as E, FACE_TOP as O } from "./types.js";
+function L() {
+  return { nx: 0, ny: 0, depth: 0, count: 0, px: [0, 0], py: [0, 0], pd: [0, 0], id: [0, 0] };
+}
+function R(n, s, t, r) {
+  const i = n.shape, e = s.shape;
+  return i.kind === "circle" && e.kind === "circle" ? v(n, i, s, e, t, r) ? (X(r, n.x + r.nx * (i.radius - r.depth / 2), n.y + r.ny * (i.radius - r.depth / 2)), !0) : !1 : i.kind === "circle" ? s.axisAligned ? I(n, i, s, e, t, r) ? (r.nx = -r.nx, r.ny = -r.ny, X(r, n.x + r.nx * (i.radius - r.depth / 2), n.y + r.ny * (i.radius - r.depth / 2)), !0) : !1 : _(n, i.radius, s, t, !0, r) : e.kind === "circle" ? n.axisAligned ? I(s, e, n, i, t, r) ? (X(r, s.x - r.nx * (e.radius - r.depth / 2), s.y - r.ny * (e.radius - r.depth / 2)), !0) : !1 : _(s, e.radius, n, t, !1, r) : n.axisAligned && s.axisAligned && n.invInertia === 0 && s.invInertia === 0 ? q(n, i, s, e, t, r) ? (X(r, (Math.max(n.minX, s.minX) + Math.min(n.maxX, s.maxX)) / 2, (Math.max(n.minY, s.minY) + Math.min(n.maxY, s.maxY)) / 2), !0) : !1 : W(n, s, t, r);
+}
+function X(n, s, t) {
+  n.count = 1, n.px[0] = s, n.py[0] = t, n.pd[0] = n.depth, n.id[0] = 0;
+}
+function w(n, s, t) {
+  return t > 0 ? !(n.internalFaces & m) && !(s.internalFaces & C) : !(n.internalFaces & C) && !(s.internalFaces & m);
+}
+function B(n, s, t) {
+  return t > 0 ? !(n.internalFaces & E) && !(s.internalFaces & O) : !(n.internalFaces & O) && !(s.internalFaces & E);
+}
+function q(n, s, t, r, i, e) {
+  const d = t.x - n.x, h = t.y - n.y, c = s.halfWidth + r.halfWidth - Math.abs(d), f = s.halfHeight + r.halfHeight - Math.abs(h);
+  if (c <= -i || f <= -i || c < 0 && f < 0) return !1;
+  const a = d < 0 ? -1 : 1, M = h < 0 ? -1 : 1;
+  let x;
+  if (c < 0) x = !0;
+  else if (f < 0) x = !1;
+  else {
+    const p = w(n, t, a), y = B(n, t, M);
+    x = p && y ? c < f : p ? !0 : y ? !1 : c < f;
+  }
+  if (x) {
+    if (c < 0 && !w(n, t, a)) return !1;
+    e.nx = a, e.ny = 0, e.depth = c;
+  } else {
+    if (f < 0 && !B(n, t, M)) return !1;
+    e.nx = 0, e.ny = M, e.depth = f;
+  }
+  return !0;
+}
+function v(n, s, t, r, i, e) {
+  const d = t.x - n.x, h = t.y - n.y, c = s.radius + r.radius, f = d * d + h * h;
+  if (f >= (c + i) * (c + i)) return !1;
+  const a = Math.sqrt(f);
+  return a > 1e-9 ? (e.nx = d / a, e.ny = h / a) : (e.nx = 0, e.ny = 1), e.depth = c - a, !0;
+}
+function I(n, s, t, r, i, e) {
+  const d = r.halfWidth, h = r.halfHeight, c = s.radius, f = n.x - t.x, a = n.y - t.y, M = t.internalFaces, x = f < 0 ? -1 : 1, p = a < 0 ? -1 : 1, y = !(M & (x > 0 ? m : C)), u = !(M & (p > 0 ? E : O)), T = Math.abs(f) <= d, H = Math.abs(a) <= h;
+  if (T && H) {
+    const l = d - Math.abs(f) + c, Y = h - Math.abs(a) + c, k = y && u ? l < Y : y ? !0 : u ? !1 : l < Y;
+    return e.nx = k ? x : 0, e.ny = k ? 0 : p, e.depth = k ? l : Y, !0;
+  }
+  if (H) {
+    if (!y) return !1;
+    const l = Math.abs(f) - d;
+    return l >= c + i ? !1 : (e.nx = x, e.ny = 0, e.depth = c - l, !0);
+  }
+  if (T) {
+    if (!u) return !1;
+    const l = Math.abs(a) - h;
+    return l >= c + i ? !1 : (e.nx = 0, e.ny = p, e.depth = c - l, !0);
+  }
+  const o = f - x * d, A = a - p * h;
+  if (!y && !u) return !1;
+  if (!y || !u) {
+    const l = Math.abs(y ? o : A);
+    return l >= c + i ? !1 : (e.nx = y ? x : 0, e.ny = y ? 0 : p, e.depth = c - l, !0);
+  }
+  const P = o * o + A * A;
+  if (P >= (c + i) * (c + i)) return !1;
+  const F = Math.sqrt(P);
+  return e.nx = F > 1e-9 ? o / F : x, e.ny = F > 1e-9 ? A / F : 0, e.depth = c - F, !0;
+}
+export {
+  R as collide,
+  L as emptyManifold
+};

package/dist/physics/collidePolygon.js

@@ -0,0 +1,93 @@
+import { FACE_TOP as D, FACE_RIGHT as G, FACE_BOTTOM as H, FACE_LEFT as N } from "./types.js";
+const Y = [D, G, H, N], L = 0.05;
+function M(t, e, c) {
+  if (!t.internalFaces || !t.axisAligned) return !1;
+  for (let n = 0; n < 4; n++)
+    if (t.internalFaces & Y[n] && t.wnx[n] * e + t.wny[n] * c > 0.999) return !0;
+  return !1;
+}
+function S(t, e, c, n) {
+  return !M(t, c, n) && !M(e, -c, -n);
+}
+function X(t, e, c) {
+  const n = t.wnx[e], r = t.wny[e], o = t.wx[e], s = t.wy[e];
+  let i = 1 / 0;
+  for (let f = 0; f < c.corners; f++) {
+    const l = (c.wx[f] - o) * n + (c.wy[f] - s) * r;
+    l < i && (i = l);
+  }
+  return i;
+}
+function g(t, e, c, n) {
+  let r = -1 / 0;
+  n.sep = -1 / 0, n.face = -1;
+  for (let o = 0; o < t.corners; o++) {
+    const s = X(t, o, e);
+    s > r && (r = s);
+    const i = c ? t.wnx[o] : -t.wnx[o], f = c ? t.wny[o] : -t.wny[o];
+    (c ? S(t, e, i, f) : S(e, t, i, f)) && s > n.sep && (n.sep = s, n.face = o);
+  }
+  return r;
+}
+const h = { sep: 0, face: -1 }, m = { sep: 0, face: -1 }, p = [0, 0], u = [0, 0], k = [0, 0];
+function z(t, e, c, n) {
+  const r = g(t, e, !0, h);
+  if (r > c) return !1;
+  const o = g(e, t, !1, m);
+  if (o > c) return !1;
+  let s;
+  h.face < 0 && m.face < 0 ? (s = o > r + L, s ? m.face = j(e, t, o) : h.face = j(t, e, r)) : h.face < 0 ? s = !0 : m.face < 0 ? s = !1 : s = m.sep > h.sep + L;
+  const i = s ? e : t, f = s ? t : e, l = s ? m.face : h.face, d = i.wnx[l], F = i.wny[l];
+  let A = 0, B = 1 / 0;
+  for (let x = 0; x < f.corners; x++) {
+    const w = f.wnx[x] * d + f.wny[x] * F;
+    w < B && (B = w, A = x);
+  }
+  const E = (A + 1) % f.corners;
+  p[0] = f.wx[A], u[0] = f.wy[A], k[0] = A, p[1] = f.wx[E], u[1] = f.wy[E], k[1] = E;
+  const a = (l + 1) % i.corners, y = i.wx[l], v = i.wy[l], T = i.wx[a], _ = i.wy[a], C = Math.hypot(T - y, _ - v), O = (T - y) / C, I = (_ - v) / C;
+  if (!R(-O, -I, -(O * y + I * v), 16) || !R(O, I, O * T + I * _, 17)) return !1;
+  n.nx = s ? -d : d, n.ny = s ? -F : F, n.count = 0, n.depth = -1 / 0;
+  for (let x = 0; x < 2; x++) {
+    const w = (p[x] - y) * d + (u[x] - v) * F;
+    if (w > c) continue;
+    const P = n.count++;
+    n.px[P] = p[x] - d * w * 0.5, n.py[P] = u[x] - F * w * 0.5, n.pd[P] = -w, n.id[P] = (s ? 1 : 0) << 12 | l << 6 | k[x], -w > n.depth && (n.depth = -w);
+  }
+  return n.count > 0;
+}
+function j(t, e, c) {
+  for (let n = 0; n < t.corners; n++) if (X(t, n, e) === c) return n;
+  return 0;
+}
+function R(t, e, c, n) {
+  const r = t * p[0] + e * u[0] - c, o = t * p[1] + e * u[1] - c;
+  if (r > 0 && o > 0) return !1;
+  if (r <= 0 && o <= 0) return !0;
+  const s = r / (r - o), i = p[0] + (p[1] - p[0]) * s, f = u[0] + (u[1] - u[0]) * s;
+  return r > 0 ? (p[0] = i, u[0] = f, k[0] = n) : (p[1] = i, u[1] = f, k[1] = n), !0;
+}
+function J(t, e, c, n, r, o) {
+  const s = t.x, i = t.y;
+  let f = 0, l = -1 / 0;
+  for (let a = 0; a < c.corners; a++) {
+    const y = (s - c.wx[a]) * c.wnx[a] + (i - c.wy[a]) * c.wny[a];
+    y > l && (l = y, f = a);
+  }
+  if (l > e + n) return !1;
+  let d = c.wnx[f], F = c.wny[f], A = l, B = f;
+  if (l > 0) {
+    const a = (f + 1) % c.corners, y = c.wx[f], v = c.wy[f], T = c.wx[a], _ = c.wy[a], C = (s - y) * (T - y) + (i - v) * (_ - v), O = (s - T) * (y - T) + (i - _) * (v - _);
+    if (C <= 0 || O <= 0) {
+      const I = C <= 0 ? y : T, x = C <= 0 ? v : _, w = Math.hypot(s - I, i - x);
+      if (w > e + n) return !1;
+      w > 1e-9 && (d = (s - I) / w, F = (i - x) / w), A = w, B = 32 + (C <= 0 ? f : a);
+    }
+  }
+  const E = e - A;
+  return o.nx = r ? -d : d, o.ny = r ? -F : F, o.depth = E, o.count = 1, o.px[0] = s - d * (e - E / 2), o.py[0] = i - F * (e - E / 2), o.pd[0] = E, o.id[0] = B, !0;
+}
+export {
+  J as circlePolygon,
+  z as polygonPolygon
+};

package/dist/physics/contactReport.js

@@ -0,0 +1,13 @@
+function u(n, e, r) {
+  if (n.grounded) return;
+  n.grounded = !0, n.ground = e;
+  const t = n === r.b ? 1 : -1;
+  n.groundNx = r.nx * t, n.groundNy = r.ny * t;
+}
+function o(n) {
+  return { a: n.a, b: n.b, nx: n.nx, ny: n.ny, depth: n.depth, sensor: n.sensor, points: n.points };
+}
+export {
+  o as info,
+  u as setGround
+};

package/dist/physics/drawColliders.js

@@ -0,0 +1,30 @@
+const a = {
+  static: 4259680,
+  kinematic: 4251903,
+  grounded: 16777056,
+  airborne: 16736352,
+  sleeping: 8421504,
+  sensor: 16736480
+};
+function m(e, n, c = {}, d, o) {
+  const u = { ...a, ...c };
+  for (const r of e.bodies) {
+    const s = d?.(r) ?? f(r, u);
+    if (o && r.corners > 0 && !r.axisAligned) {
+      for (let i = 0; i < r.corners; i++) {
+        const t = (i + 1) % r.corners;
+        o(r.wx[i], r.wy[i], r.wx[t], r.wy[t], s);
+      }
+      continue;
+    }
+    n(r.minX, r.minY, r.maxX - r.minX, r.maxY - r.minY, s), o && r.shape.kind === "circle" && r.rotates && o(r.x, r.y, r.x + r.cos * r.shape.radius, r.y + r.sin * r.shape.radius, s);
+  }
+}
+function f(e, n = a) {
+  return e.sensor ? n.sensor : e.type === "static" ? n.static : e.type === "kinematic" ? n.kinematic : e.awake ? e.grounded ? n.grounded : n.airborne : n.sleeping;
+}
+export {
+  a as COLLIDER_COLORS,
+  f as colliderColor,
+  m as drawColliders
+};

package/dist/physics/physicsSystem.js

@@ -0,0 +1,7 @@
+import { system as i } from "../ecs/World.js";
+function r(s, t = "physics") {
+  return i(t, "fixed", ({ dt: e }) => s.step(e));
+}
+export {
+  r as physicsSystem
+};

package/dist/physics/polygon.js

@@ -0,0 +1,79 @@
+const O = 16;
+function M(s) {
+  let t = 0;
+  for (let n = 0; n < s.length; n++) {
+    const o = s[n], r = s[(n + 1) % s.length];
+    t += o.x * r.y - r.x * o.y;
+  }
+  return t;
+}
+function d(s) {
+  const t = E(s);
+  let n = 0, o = 0, r = 0;
+  for (let c = 0; c < t.length; c++) {
+    const e = t[c], l = t[(c + 1) % t.length], y = e.x * l.y - l.x * e.y;
+    r += y, n += (e.x + l.x) * y, o += (e.y + l.y) * y;
+  }
+  if (Math.abs(r) < 1e-9) throw new Error("polygonShape: the points enclose no area");
+  return { x: n / (3 * r), y: o / (3 * r) };
+}
+function m(s) {
+  const t = E(s);
+  if (t.length < 3) throw new Error("polygonShape: needs at least three points not on one line");
+  if (t.length > 16) throw new Error(`polygonShape: at most 16 corners, got ${t.length}`);
+  const n = d(t);
+  return { kind: "polygon", vertices: t.map((o) => ({ x: o.x - n.x, y: o.y - n.y })) };
+}
+function S(s, t) {
+  const n = Math.max(3, Math.min(16, Math.round(s))), o = [];
+  for (let r = 0; r < n; r++) {
+    const c = -Math.PI / 2 + r * 2 * Math.PI / n;
+    o.push({ x: Math.cos(c) * t, y: Math.sin(c) * t });
+  }
+  return m(o);
+}
+function E(s) {
+  const t = s.map((e) => ({ x: e.x, y: e.y })).sort((e, l) => e.x - l.x || e.y - l.y);
+  if (t.length < 3) return t;
+  const n = (e, l, y) => (l.x - e.x) * (y.y - e.y) - (l.y - e.y) * (y.x - e.x), o = [];
+  for (const e of t) {
+    for (; o.length >= 2 && n(o[o.length - 2], o[o.length - 1], e) <= 1e-9; ) o.pop();
+    o.push(e);
+  }
+  const r = [];
+  for (let e = t.length - 1; e >= 0; e--) {
+    const l = t[e];
+    for (; r.length >= 2 && n(r[r.length - 2], r[r.length - 1], l) <= 1e-9; ) r.pop();
+    r.push(l);
+  }
+  const c = o.slice(0, -1).concat(r.slice(0, -1));
+  return M(c) < 0 ? c.reverse() : c;
+}
+const w = /* @__PURE__ */ new WeakMap();
+function _(s) {
+  let t = w.get(s);
+  if (t) return t;
+  const n = s.vertices;
+  if (n.length < 3 || n.length > 16) throw new Error(`Body: a polygon needs 3–16 corners, got ${n.length}`);
+  if (M(n) <= 0) throw new Error("Body: polygon corners must run clockwise on screen (make the shape with polygonShape)");
+  const o = [];
+  let r = 0, c = 0, e = 0, l = 1 / 0;
+  for (let y = 0; y < n.length; y++) {
+    const h = n[y], a = n[(y + 1) % n.length], p = a.x - h.x, g = a.y - h.y, x = Math.hypot(p, g);
+    if (x < 1e-9) throw new Error("Body: a polygon has two corners in one place");
+    const i = { x: g / x, y: -p / x };
+    o.push(i);
+    const u = n[(y + 2) % n.length];
+    if ((u.x - h.x) * i.x + (u.y - h.y) * i.y > 1e-6) throw new Error("Body: a polygon must be convex (make the shape with polygonShape)");
+    const f = h.x * a.y - a.x * h.y;
+    c += f / 2, r += f * (h.x * h.x + h.x * a.x + a.x * a.x + h.y * h.y + h.y * a.y + a.y * a.y) / 12, e = Math.max(e, Math.hypot(h.x, h.y)), l = Math.min(l, h.x * i.x + h.y * i.y);
+  }
+  return t = { vertices: n, normals: o, inertiaPerMass: r / c, radius: e, inradius: l }, w.set(s, t), t;
+}
+export {
+  O as MAX_POLYGON_VERTICES,
+  d as polygonCentroid,
+  _ as polygonData,
+  m as polygonShape,
+  S as regularPolygon
+};

package/dist/physics/raycast.js

@@ -0,0 +1,61 @@
+const p = { t: 0, nx: 0, ny: 0 };
+function L(t, r, a, u, m, x, i) {
+  const o = t.shape;
+  if (o.kind === "circle") {
+    const n = r - t.x, e = a - t.y, l = u * u + m * m, X = n * n + e * e - o.radius * o.radius;
+    if (X <= 0 || l === 0) return !1;
+    const M = n * u + e * m, Y = M * M - l * X;
+    if (Y < 0 || M > 0) return !1;
+    const w = (-M - Math.sqrt(Y)) / l;
+    return w < 0 || w > x ? !1 : (i.t = w, i.nx = (n + u * w) / o.radius, i.ny = (e + m * w) / o.radius, !0);
+  }
+  if (!t.axisAligned) return P(t, r, a, u, m, x, i);
+  if (r > t.minX && r < t.maxX && a > t.minY && a < t.maxY) return !1;
+  let c = -1 / 0, s = 1 / 0, h = 0, f = 0;
+  if (u !== 0) {
+    const n = (t.minX - r) / u, e = (t.maxX - r) / u, l = Math.min(n, e);
+    l > c && (c = l, h = u > 0 ? -1 : 1, f = 0), s = Math.min(s, Math.max(n, e));
+  } else if (r < t.minX || r > t.maxX) return !1;
+  if (m !== 0) {
+    const n = (t.minY - a) / m, e = (t.maxY - a) / m, l = Math.min(n, e);
+    l > c && (c = l, h = 0, f = m > 0 ? -1 : 1), s = Math.min(s, Math.max(n, e));
+  } else if (a < t.minY || a > t.maxY) return !1;
+  return c > s || c < 0 || c > x ? !1 : (i.t = c, i.nx = h, i.ny = f, !0);
+}
+function P(t, r, a, u, m, x, i) {
+  let o = 0, c = x, s = -1, h = !0;
+  for (let f = 0; f < t.corners; f++) {
+    const n = t.wnx[f], e = t.wny[f], l = (r - t.wx[f]) * n + (a - t.wy[f]) * e, X = u * n + m * e;
+    if (l > 0 && (h = !1), X === 0) {
+      if (l > 0) return !1;
+      continue;
+    }
+    const M = -l / X;
+    if (X < 0 ? M > o && (o = M, s = f) : M < c && (c = M), o > c) return !1;
+  }
+  return h || s < 0 ? !1 : (i.t = o, i.nx = t.wnx[s], i.ny = t.wny[s], !0);
+}
+let R = 0;
+function v(t, r, a, u, m, x = {}) {
+  const i = t[0];
+  if (!i) return null;
+  const o = x.mask ?? 4294967295, c = ++R, s = u - r, h = m - a, f = i.cellSize;
+  let n = i.cellOf(r), e = i.cellOf(a);
+  const l = i.cellOf(u), X = i.cellOf(m), M = s > 0 ? 1 : s < 0 ? -1 : 0, Y = h > 0 ? 1 : h < 0 ? -1 : 0, w = M !== 0 ? f / Math.abs(s) : 1 / 0, q = Y !== 0 ? f / Math.abs(h) : 1 / 0;
+  let O = M > 0 ? ((n + 1) * f - r) / s : M < 0 ? (n * f - r) / s : 1 / 0, g = Y > 0 ? ((e + 1) * f - a) / h : Y < 0 ? (e * f - a) / h : 1 / 0, S = null, I = 1, z = 0, D = 0, A = Math.abs(l - n) + Math.abs(X - e) + 1;
+  for (; ; ) {
+    for (const C of t) {
+      const N = C.at(n, e);
+      if (N)
+        for (const k of N)
+          k.rayStamp !== c && (k.rayStamp = c, k.layer & o && (k.sensor && !x.includeSensors || x.filter && !x.filter(k) || L(k, r, a, s, h, I, p) && (!S || p.t < I) && (S = k, I = p.t, z = p.nx, D = p.ny)));
+    }
+    if (--A <= 0 || Math.min(O, g) > I) break;
+    O < g ? (n += M, O += w) : (e += Y, g += q);
+  }
+  return S ? { body: S, x: r + s * I, y: a + h * I, nx: z, ny: D, fraction: I } : null;
+}
+export {
+  v as castRay,
+  L as rayShape
+};

package/dist/physics/syncToBody.js

@@ -0,0 +1,18 @@
+function s(l, n, c, a = 0, e = 0, g = !1) {
+  let r = n.prevX + (n.x - n.prevX) * c, M = n.prevY + (n.y - n.prevY) * c;
+  if (n.rotates || n.angle !== 0) {
+    let t = n.angle - n.prevAngle;
+    (t > Math.PI || t < -Math.PI) && (t -= Math.round(t / (2 * Math.PI)) * 2 * Math.PI);
+    const h = n.prevAngle + t * c;
+    if (a !== 0 || e !== 0) {
+      const p = Math.cos(h), i = Math.sin(h);
+      r += p * a - i * e, M += i * a + p * e;
+    }
+    l.rotation = h;
+  } else
+    r += a, M += e;
+  l.x = g ? Math.round(r) : r, l.y = g ? Math.round(M) : M;
+}
+export {
+  s as syncToBody
+};

package/dist/physics/tileBodies.js

@@ -0,0 +1,58 @@
+import { Body as m } from "./Body.js";
+import { FACE_TOP as d, FACE_BOTTOM as w, FACE_LEFT as F, FACE_RIGHT as T } from "./types.js";
+function p(n, f, i) {
+  const s = [];
+  let t = /* @__PURE__ */ new Map();
+  for (let o = 0; o < f; o++) {
+    const l = /* @__PURE__ */ new Map();
+    let c = 0;
+    for (; c < n; ) {
+      if (!i(c, o)) {
+        c++;
+        continue;
+      }
+      const e = c;
+      for (; c < n && i(c, o); ) c++;
+      const u = c - 1, r = e * 1048576 + u, a = t.get(r);
+      a ? (a.y1 = o, t.delete(r), l.set(r, a)) : l.set(r, { x0: e, y0: o, x1: u, y1: o });
+    }
+    for (const e of t.values()) s.push(e);
+    t = l;
+  }
+  for (const o of t.values()) s.push(o);
+  return s;
+}
+function E(n, f, i, s, t = {}) {
+  const o = (e, u) => e >= 0 && u >= 0 && e < n && u < f && s(e, u), l = t.originX ?? 0, c = t.originY ?? 0;
+  return p(n, f, o).map((e) => {
+    const u = (e.x1 - e.x0 + 1) * i, r = (e.y1 - e.y0 + 1) * i, a = new m({
+      type: "static",
+      shape: { kind: "box", halfWidth: u / 2, halfHeight: r / 2 },
+      x: l + e.x0 * i + u / 2,
+      y: c + e.y0 * i + r / 2,
+      friction: t.friction,
+      restitution: t.restitution,
+      layer: t.layer,
+      mask: t.mask,
+      userData: t.userData
+    });
+    let y = 0;
+    return x(o, e.x0, e.x1, e.y0 - 1) && (y |= d), x(o, e.x0, e.x1, e.y1 + 1) && (y |= w), h(o, e.x0 - 1, e.y0, e.y1) && (y |= F), h(o, e.x1 + 1, e.y0, e.y1) && (y |= T), a.internalFaces = y, a;
+  });
+}
+function B(n, f = {}) {
+  return E(n.width, n.height, n.tileSize, (i, s) => n.solid[s * n.width + i] === 1, f);
+}
+function x(n, f, i, s) {
+  for (let t = f; t <= i; t++) if (!n(t, s)) return !1;
+  return !0;
+}
+function h(n, f, i, s) {
+  for (let t = i; t <= s; t++) if (!n(f, t)) return !1;
+  return !0;
+}
+export {
+  p as mergeTileRects,
+  E as tileBodies,
+  B as tileBodiesFromGrid
+};

package/dist/physics/types.js

@@ -0,0 +1,7 @@
+const o = 1, t = 2, E = 4, F = 8;
+export {
+  F as FACE_BOTTOM,
+  o as FACE_LEFT,
+  t as FACE_RIGHT,
+  E as FACE_TOP
+};

package/dist/pixel/Darkness.js

@@ -0,0 +1,169 @@
+import { Sprite as y, Texture as v, RenderTexture as E, Container as x } from "pixi.js";
+import { liveLights as _, lightRadius as k } from "./lights.js";
+import { isTouchUi as R } from "../platform/touch.js";
+const D = 66, K = 33, p = 8, W = (h) => Math.min(1, Math.pow(Math.max(0, 1 - h * h), 1.5) * 1.15), z = (h) => Math.pow(Math.max(0, 1 - h), 2), P = 4, G = 3, U = 0.3, S = 0.85, $ = 16761466, Y = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5].map((h) => (h + 0.5) / 16), I = (h) => h <= 24 ? Math.max(2, Math.round(h / 2) * 2) : Math.round(h / 8) * 8, B = [...new Set(Array.from({ length: 160 }, (h, t) => I(t + 1)))], F = 33, C = /* @__PURE__ */ new Map();
+let H = !1;
+function N() {
+  if (H) return;
+  H = !0;
+  const h = B.flatMap((s) => [["hole", s], ["wash", s]]), t = () => {
+    const s = h.shift();
+    s && (g(s[0], s[1]), setTimeout(t, 0));
+  };
+  setTimeout(t, 0);
+}
+function g(h, t) {
+  const s = `${h}${t}`, i = C.get(s);
+  if (i) return i;
+  const e = t * 2, a = Math.max(2, Math.round(t * 2 * S)), r = h === "hole" ? P : G, w = h === "hole" ? W : z, o = document.createElement("canvas");
+  o.width = e, o.height = a;
+  const c = o.getContext("2d");
+  if (!c) return v.EMPTY;
+  const u = c.createImageData(e, a);
+  for (let f = 0; f < a; f++)
+    for (let l = 0; l < e; l++) {
+      const L = Math.hypot((l + 0.5 - e / 2) / t, (f + 0.5 - a / 2) / (t * S));
+      if (L >= 1) continue;
+      const A = Math.min(r, Math.floor(w(L) * r + Y[f % 4 * 4 + l % 4])) / r, d = (f * e + l) * 4;
+      u.data[d] = u.data[d + 1] = u.data[d + 2] = 255, u.data[d + 3] = Math.round(A * 255);
+    }
+  c.putImageData(u, 0, 0);
+  const M = v.from(o);
+  return M.source.scaleMode = "nearest", C.set(s, M), M;
+}
+class q {
+  constructor(t, s, i, e = {}) {
+    this.stage = t, this.color = s, this.alpha = i, this.carriedLight = e.carriedLight ?? V, this.sheet = new y({ texture: v.WHITE }), this.scratch.addChild(this.sheet, this.holes, this.washes), this.carried = this.light(16773340), this.rt = E.create({ width: 1, height: 1 }), this.view = new y({ texture: this.rt }), this.layer.addChild(this.view), t.screen.addChild(this.layer), t.cameras.main.follow(this.layer), this.unsubscribeResize = t.onResize(() => this.dirty = !0), N();
+  }
+  stage;
+  color;
+  alpha;
+  scratch = new x();
+  sheet;
+  /** Every hole is erased before any colour is laid, or a later hole would wipe an earlier light's colour away. */
+  holes = new x();
+  washes = new x();
+  lamps = [];
+  /** The transient lights (`lights.ts`), reused frame to frame. */
+  flashes = [];
+  rt;
+  /**
+   * On the screen layer, laid over the world with its exact transform by the camera (`Camera.follow`), shake included:
+   * the night is drawn in world pixels round the unshaken camera and only this layer moves with a shake, so a shaking
+   * screen does not redraw the night every frame.
+   */
+  layer = new x();
+  view;
+  /** The light the player carries: the only one that follows them, and the last one they lose. */
+  carried;
+  unsubscribeResize;
+  /** Lamps that flicker: while one does (or the player carries a light) every frame differs. */
+  flickering = 0;
+  /** Something other than the camera changed what the night looks like (a lamp added, dimmed, the window resized). */
+  dirty = !0;
+  /** What the last drawn frame was drawn from: the texture, the camera's texel and the shade. */
+  drawn = "";
+  /** The carried light's place at the last redraw (it follows the body). */
+  carriedAt = "";
+  /** When the sheet was last redrawn. */
+  drawnAt = -1 / 0;
+  /** The world pixel the night's top-left texel stands on. */
+  ox = 0;
+  oy = 0;
+  /** The night texture's size in world pixels, and the zoom it was made for. */
+  rtKey = "";
+  /** The lamps' colour turned down (`setLampsDimmed`). */
+  dimLamps = !1;
+  /** A phone redraws the night at most `PHONE_MS` apart, whatever moves (`isTouchUi`). */
+  phone = R();
+  /** The radius `update` uses when it is given none (`DarknessOptions.carriedLight`). */
+  carriedLight;
+  /** A hole and its colour, added to the night's layers. */
+  light(t) {
+    const s = new y({ texture: g("hole", 8) });
+    s.blendMode = "erase", this.holes.addChild(s);
+    const i = new y({ texture: g("wash", 8) });
+    return i.tint = t, this.washes.addChild(i), { hole: s, wash: i };
+  }
+  /** A lamp fixed in the world: a torch on a wall, the seep in its chamber, a crystal in a seam, in its own colour. */
+  addLamp(t, s, i, e = 0, a = $) {
+    this.lamps.push({ sprites: this.light(a), x: t, y: s, r: i, flicker: e }), e && this.flickering++, this.dirty = !0;
+  }
+  /**
+   * Changes how dark and what colour the sheet is (the outdoor night, `NightShade`, deepens and lifts with the
+   * world clock). A sheet with no alpha left is neither drawn nor redrawn, so a map at noon pays nothing for its night.
+   */
+  setShade(t, s) {
+    this.color = t, this.alpha = s, this.layer.visible = s > 4e-3;
+  }
+  /**
+   * Dimmed lamps lay only `LAMP_DIM` of their colour on the dark (a "fewer ambient lights" setting). The holes they
+   * cut stay as wide, so a dark place is still seen by them.
+   */
+  setLampsDimmed(t) {
+    t !== this.dimLamps && (this.dimLamps = t, this.dirty = !0);
+  }
+  /**
+   * The night's own texture, one texel a world pixel and `MARGIN` to spare on each side (a shake, or a camera that
+   * moved while a phone waits for its next redraw, never shows its edge), remade when the window or the zoom changes:
+   * at zoom 2 or 3 it is a quarter or a ninth of the screen's pixels. True when it was remade.
+   */
+  fit(t, s, i) {
+    const e = Math.ceil(t / i) + p * 2, a = Math.ceil(s / i) + p * 2, r = `${e},${a},${i}`;
+    return r === this.rtKey ? !1 : (this.rtKey = r, this.rt.destroy(!0), this.rt = E.create({ width: e, height: a }), this.rt.source.scaleMode = "nearest", this.view.texture = this.rt, !0);
+  }
+  /**
+   * Redraws the night with this frame's holes in it, when anything in it changed. `px`/`py` is where the player stands;
+   * `carriedRadius` is the light they carry (default the `carriedLight` option, 0 for none).
+   */
+  update(t, s, i, e = this.carriedLight) {
+    if (!this.layer.visible) return;
+    const a = this.stage.cameras.main, r = a.zoom || 1, w = this.fit(this.stage.width, this.stage.height, r), o = Math.floor(a.scrollX) - p, c = Math.floor(a.scrollY) - p, u = `${o},${c},${this.rtKey},${this.color},${this.alpha}`, M = _(t), f = e > 0 ? `${Math.round(s)},${Math.round(i)},${Math.round(e)}` : "", l = t - this.drawnAt;
+    if (!(this.dirty || u !== this.drawn || f !== this.carriedAt || M.length > 0 && l >= F || (e > 0 || this.flickering > 0) && l >= D)) return;
+    const A = Math.abs(o - this.ox) >= p - 1 || Math.abs(c - this.oy) >= p - 1;
+    if (this.phone && l < K && !w && !A) return;
+    this.dirty = !1, this.drawn = u, this.carriedAt = f, this.drawnAt = t, this.ox = o, this.oy = c, this.view.position.set(o, c), this.sheet.width = this.rt.width, this.sheet.height = this.rt.height, this.sheet.position.set(0, 0), this.sheet.tint = this.color, this.sheet.alpha = this.alpha;
+    const d = U * Math.min(1, this.alpha * 1.4);
+    e <= 0 ? this.hide(this.carried) : this.place(this.carried, s, i - 6, e * (1 + Math.sin(t / 260) * 0.03 + Math.sin(t / 90) * 0.015), d * 0.5);
+    const T = this.dimLamps ? d * O : d;
+    for (const n of this.lamps) {
+      const m = n.flicker ? 1 + Math.sin(t / 190 + n.flicker) * 0.05 + Math.sin(t / 71 + n.flicker) * 0.03 : 1;
+      this.place(n.sprites, n.x, n.y, n.r * m, T * (n.flicker ? 0.9 + (m - 1) * 2 : 1));
+    }
+    for (; this.flashes.length < M.length; ) this.flashes.push(this.light($));
+    for (let n = 0; n < this.flashes.length; n++) {
+      const m = M[n], b = this.flashes[n];
+      if (!m) {
+        this.hide(b);
+        continue;
+      }
+      b.wash.tint = m.color, this.place(b, m.x, m.y, k(m, t), Math.min(0.6, d * 1.6));
+    }
+    this.stage.app.renderer.render({ container: this.scratch, target: this.rt, clear: !0 });
+  }
+  hide(t) {
+    t.hole.visible = !1, t.wash.visible = !1;
+  }
+  /** Lays light `l` at world (wx, wy), `r` px across its radius, in the night's world-pixel grid. */
+  place(t, s, i, e, a) {
+    const r = I(e), w = Math.round(s) - this.ox, o = Math.round(i) - this.oy;
+    if (e < 1 || w < -r || o < -r || w > this.rt.width + r || o > this.rt.height + r) {
+      this.hide(t);
+      return;
+    }
+    t.hole.texture = g("hole", r), t.wash.texture = g("wash", r);
+    for (const c of [t.hole, t.wash])
+      c.visible = !0, c.position.set(w - r, o - Math.round(r * S));
+    t.wash.alpha = a, t.wash.visible = a > 0.01;
+  }
+  destroy() {
+    this.unsubscribeResize(), this.stage.cameras.main.unfollow(this.layer), this.layer.destroy({ children: !0 }), this.rt.destroy(!0), this.scratch.destroy({ children: !0, context: !0 });
+  }
+}
+const O = 0.35, V = 80;
+export {
+  V as CARRIED_LIGHT,
+  q as Darkness,
+  O as LAMP_DIM,
+  $ as WARM_LIGHT
+};

package/dist/pixel/DitherVignette.js

@@ -0,0 +1,56 @@
+import { Sprite as x, Texture as g } from "pixi.js";
+import { vignetteMask as M } from "./vignetteMask.js";
+const o = /* @__PURE__ */ new Map(), k = 12;
+function w(d, t, e = 1, h = 0.55) {
+  const i = Math.max(1, Math.ceil(d)), s = Math.max(1, Math.ceil(t)), m = `${i}x${s}|${e.toFixed(2)}|${h}`, l = o.get(m);
+  if (l) return l;
+  const r = document.createElement("canvas");
+  r.width = i, r.height = s;
+  const n = r.getContext("2d");
+  if (!n) return g.EMPTY;
+  const f = M(i, s, e, h), u = n.createImageData(i, s);
+  for (let a = 0; a < f.length; a++) f[a] && u.data.fill(255, a * 4, a * 4 + 4);
+  n.putImageData(u, 0, 0);
+  const c = g.from(r);
+  if (c.source.scaleMode = "nearest", o.size >= k) {
+    for (const a of o.values()) a.destroy(!0);
+    o.clear();
+  }
+  return o.set(m, c), c;
+}
+class y {
+  constructor(t, e = {}) {
+    this.stage = t, this.from = e.from ?? 0.55, this.edge.tint = e.color ?? 0, this.edge.visible = !1, t.screen.addChild(this.edge), this.making = setTimeout(() => {
+      this.making = null, this.make();
+    }, 0);
+  }
+  stage;
+  edge = new x();
+  madeFor = "";
+  making = null;
+  from;
+  setColor(t) {
+    this.edge.tint = t;
+  }
+  make() {
+    if (this.edge.destroyed) return;
+    const t = Math.max(1, this.stage.cameras.main.zoom), e = this.stage.width / t, h = this.stage.height / t, i = `${Math.ceil(e)}x${Math.ceil(h)}`;
+    if (i === this.madeFor) return;
+    const s = w(e, h, 1, this.from);
+    this.edge.texture = s, s !== g.EMPTY && (this.madeFor = i);
+  }
+  /** Shows the edge at `alpha` (0..1); call each frame it shows. */
+  show(t) {
+    this.edge.visible = t > 0, this.edge.visible && (this.make(), this.edge.alpha = t, this.edge.width = this.stage.width, this.edge.height = this.stage.height);
+  }
+  hide() {
+    this.edge.visible = !1;
+  }
+  destroy() {
+    this.making && clearTimeout(this.making), this.edge.destroy();
+  }
+}
+export {
+  y as DitherVignette,
+  w as ditherVignette
+};