1681-engine 0.0.0-stage → 0.5.8

package/dist/physics/Contact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Contact.js","sources":["../../src/physics/Contact.ts"],"sourcesContent":["import type { Body } from './Body';\nimport type { ContactInfo, Vec2 } from './types';\n\n/** One point of a contact and the solver's terms for it. */\nexport class ContactPoint {\n  /** World position when measured, and the depth there (px, < 0 a gap). */\n  x = 0;\n  y = 0;\n  depth = 0;\n  /** Which corners or faces made it: matched from step to step to carry the impulses over. */\n  id = 0;\n  /** Accumulated normal and friction impulses. */\n  jn = 0;\n  jt = 0;\n  /** Per sub-step solver terms. */\n  massN = 0;\n  massT = 0;\n  target = 0;\n  /** Offsets from each body's centre, refreshed every sub-step. */\n  rax = 0;\n  ray = 0;\n  rbx = 0;\n  rby = 0;\n  /** The point in each body's own frame when measured, so position correction can track its depth as they move and turn. */\n  lax = 0;\n  lay = 0;\n  lbx = 0;\n  lby = 0;\n}\n\n/**\n * One touching pair, kept from step to step while they touch: the impulses it ended the last step with start the\n * next one (warm starting), which is what lets a stack settle in a few solver iterations instead of shivering.\n */\nexport class Contact implements ContactInfo {\n  nx = 0;\n  ny = 1;\n  depth = 0;\n  /** One or two points; only the first `count` are in use. */\n  readonly pts: [ContactPoint, ContactPoint] = [new ContactPoint(), new ContactPoint()];\n  count = 0;\n  mu = 0;\n  /** Solved this sub-step (false when the pre-solve hook turned it off). */\n  enabled = true;\n  /** The world step and sub-step that last found it. */\n  seenStep = -1;\n  seenSub = -1;\n  /** Reported as touching (a `begin` went out and no `end` yet). */\n  reported = false;\n\n  constructor(\n    readonly a: Body,\n    readonly b: Body,\n    readonly key: number,\n  ) {}\n\n  get sensor(): boolean {\n    return this.a.sensor || this.b.sensor;\n  }\n\n  /** Where the two touch, world px. */\n  get points(): Vec2[] {\n    const out: Vec2[] = [];\n    for (let i = 0; i < this.count; i++) out.push({ x: this.pts[i]!.x, y: this.pts[i]!.y });\n    return out;\n  }\n\n  /** Accumulated normal impulse over the points: how hard the pair pressed together on the last sub-step. */\n  get normalImpulse(): number {\n    let j = 0;\n    for (let i = 0; i < this.count; i++) j += this.pts[i]!.jn;\n    return j;\n  }\n\n  /** The other body of the pair. */\n  other(body: Body): Body {\n    return body === this.a ? this.b : this.a;\n  }\n\n  /** A stable number for the pair, whichever order it is asked in. */\n  static keyOf(a: Body, b: Body): number {\n    const lo = a.id < b.id ? a.id : b.id;\n    const hi = a.id < b.id ? b.id : a.id;\n    return lo * 0x4000000 + hi;\n  }\n}\n"],"names":["ContactPoint","Contact","a","b","key","out","i","j","body","lo","hi"],"mappings":"AAIO,MAAMA,EAAa;AAAA;AAAA,EAExB,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,QAAQ;AAAA;AAAA,EAER,KAAK;AAAA;AAAA,EAEL,KAAK;AAAA,EACL,KAAK;AAAA;AAAA,EAEL,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA;AAAA,EAET,MAAM;AAAA,EACN,MAAM;AAAA,EACN,MAAM;AAAA,EACN,MAAM;AAAA;AAAA,EAEN,MAAM;AAAA,EACN,MAAM;AAAA,EACN,MAAM;AAAA,EACN,MAAM;AACR;AAMO,MAAMC,EAA+B;AAAA,EAgB1C,YACWC,GACAC,GACAC,GACT;AAHS,SAAA,IAAAF,GACA,KAAA,IAAAC,GACA,KAAA,MAAAC;AAAA,EACR;AAAA,EAHQ;AAAA,EACA;AAAA,EACA;AAAA,EAlBX,KAAK;AAAA,EACL,KAAK;AAAA,EACL,QAAQ;AAAA;AAAA,EAEC,MAAoC,CAAC,IAAIJ,KAAgB,IAAIA,GAAc;AAAA,EACpF,QAAQ;AAAA,EACR,KAAK;AAAA;AAAA,EAEL,UAAU;AAAA;AAAA,EAEV,WAAW;AAAA,EACX,UAAU;AAAA;AAAA,EAEV,WAAW;AAAA,EAQX,IAAI,SAAkB;AACpB,WAAO,KAAK,EAAE,UAAU,KAAK,EAAE;AAAA,EACjC;AAAA;AAAA,EAGA,IAAI,SAAiB;AACnB,UAAMK,IAAc,CAAA;AACpB,aAASC,IAAI,GAAGA,IAAI,KAAK,OAAOA,IAAK,CAAAD,EAAI,KAAK,EAAE,GAAG,KAAK,IAAIC,CAAC,EAAG,GAAG,GAAG,KAAK,IAAIA,CAAC,EAAG,GAAG;AACtF,WAAOD;AAAA,EACT;AAAA;AAAA,EAGA,IAAI,gBAAwB;AAC1B,QAAIE,IAAI;AACR,aAASD,IAAI,GAAGA,IAAI,KAAK,OAAOA,IAAK,CAAAC,KAAK,KAAK,IAAID,CAAC,EAAG;AACvD,WAAOC;AAAA,EACT;AAAA;AAAA,EAGA,MAAMC,GAAkB;AACtB,WAAOA,MAAS,KAAK,IAAI,KAAK,IAAI,KAAK;AAAA,EACzC;AAAA;AAAA,EAGA,OAAO,MAAMN,GAASC,GAAiB;AACrC,UAAMM,IAAKP,EAAE,KAAKC,EAAE,KAAKD,EAAE,KAAKC,EAAE,IAC5BO,IAAKR,EAAE,KAAKC,EAAE,KAAKA,EAAE,KAAKD,EAAE;AAClC,WAAOO,IAAK,WAAYC;AAAA,EAC1B;AACF;"}

package/dist/physics/ContactSolver.js

@@ -0,0 +1,70 @@
+const g = (l, e, s, i) => l * i - e * s, N = (l) => l.awake ? l.invInertia : 0;
+class z {
+  constructor(e) {
+    this.settings = e;
+  }
+  settings;
+  /** Mass, friction and the velocity target of every enabled contact point; then the impulses carried over from the last sub-step are applied (warm start). */
+  prepare(e, s) {
+    const { restitutionThreshold: i } = this.settings;
+    for (const c of e) {
+      if (!c.enabled) continue;
+      const a = c.a, n = c.b, r = a.solverInvMass, y = n.solverInvMass, f = N(a), h = N(n);
+      c.mu = Math.sqrt(a.friction * n.friction);
+      const u = c.nx, x = c.ny, b = -x, o = u, v = Math.max(a.restitution, n.restitution);
+      for (let M = 0; M < c.count; M++) {
+        const t = c.pts[M];
+        t.rax = t.x - a.x, t.ray = t.y - a.y, t.rbx = t.x - n.x, t.rby = t.y - n.y;
+        const d = g(t.rax, t.ray, u, x), I = g(t.rbx, t.rby, u, x), m = r + y + f * d * d + h * I * I;
+        t.massN = m > 0 ? 1 / m : 0;
+        const j = g(t.rax, t.ray, b, o), p = g(t.rbx, t.rby, b, o), V = r + y + f * j * j + h * p * p;
+        t.massT = V > 0 ? 1 / V : 0;
+        const T = A(a, n, t) * u + B(a, n, t) * x;
+        t.depth < 0 ? t.target = t.depth / s : t.target = T < -i ? -v * T : 0, C(a, n, t, t.jn * u + t.jt * b, t.jn * x + t.jt * o, r, y, f, h);
+      }
+    }
+  }
+  solveVelocities(e) {
+    for (const s of e) {
+      if (!s.enabled) continue;
+      const i = s.a, c = s.b, a = i.solverInvMass, n = c.solverInvMass, r = N(i), y = N(c), f = s.nx, h = s.ny, u = -h, x = f;
+      for (let b = 0; b < s.count; b++) {
+        const o = s.pts[b];
+        if (o.massN === 0) continue;
+        const v = A(i, c, o) * u + B(i, c, o) * x, M = s.mu * o.jn, t = Math.max(-M, Math.min(M, o.jt - v * o.massT)), d = t - o.jt;
+        o.jt = t, C(i, c, o, d * u, d * x, a, n, r, y);
+        const I = A(i, c, o) * f + B(i, c, o) * h, m = Math.max(0, o.jn + (o.target - I) * o.massN), j = m - o.jn;
+        o.jn = m, C(i, c, o, j * f, j * h, a, n, r, y);
+      }
+    }
+  }
+  /** Pushes overlapping pairs apart along their normals, by position (and angle) only. */
+  solvePositions(e) {
+    const { slop: s, correction: i, maxCorrection: c } = this.settings;
+    for (const a of e) {
+      if (!a.enabled) continue;
+      const n = a.a, r = a.b, y = n.solverInvMass, f = r.solverInvMass, h = N(n), u = N(r), x = a.nx, b = a.ny;
+      for (let o = 0; o < a.count; o++) {
+        const v = a.pts[o], M = n.rotates ? Math.cos(n.angle) : n.cos, t = n.rotates ? Math.sin(n.angle) : n.sin, d = r.rotates ? Math.cos(r.angle) : r.cos, I = r.rotates ? Math.sin(r.angle) : r.sin, m = M * v.lax - t * v.lay, j = t * v.lax + M * v.lay, p = d * v.lbx - I * v.lby, V = I * v.lbx + d * v.lby, T = (r.x + p - (n.x + m)) * x + (r.y + V - (n.y + j)) * b, q = v.depth - T;
+        if (q <= s) continue;
+        const P = g(m, j, x, b), S = g(p, V, x, b), X = y + f + h * P * P + u * S * S;
+        if (X === 0) continue;
+        const Y = Math.min(c, i * (q - s)) / X, k = Y * x, w = Y * b;
+        n.x -= k * y, n.y -= w * y, r.x += k * f, r.y += w * f, h > 0 && (n.angle -= h * g(m, j, k, w)), u > 0 && (r.angle += u * g(p, V, k, w));
+      }
+    }
+  }
+}
+function A(l, e, s) {
+  return e.vx - e.angularVelocity * s.rby - (l.vx - l.angularVelocity * s.ray);
+}
+function B(l, e, s) {
+  return e.vy + e.angularVelocity * s.rbx - (l.vy + l.angularVelocity * s.rax);
+}
+function C(l, e, s, i, c, a, n, r, y) {
+  l.vx -= i * a, l.vy -= c * a, e.vx += i * n, e.vy += c * n, r > 0 && (l.angularVelocity -= r * g(s.rax, s.ray, i, c)), y > 0 && (e.angularVelocity += y * g(s.rbx, s.rby, i, c));
+}
+export {
+  z as ContactSolver
+};
+//# sourceMappingURL=ContactSolver.js.map

package/dist/physics/ContactSolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContactSolver.js","sources":["../../src/physics/ContactSolver.ts"],"sourcesContent":["import type { Body } from './Body';\nimport type { Contact, ContactPoint } from './Contact';\n\n/** Tuning the solver reads; `PhysicsWorld` owns the values. */\nexport interface SolverSettings {\n  /** Approach speed (px/s) below which nothing bounces, so a resting body does not hop on gravity's own step. */\n  restitutionThreshold: number;\n  /** Overlap (px) left alone by position correction: a little keeps resting contacts alive and steady. */\n  slop: number;\n  /** Share of the remaining overlap removed per position iteration. */\n  correction: number;\n  /** The most one position iteration moves a pair apart (px), so a deep overlap is undone over a few steps, not flung. */\n  maxCorrection: number;\n}\n\nconst cross = (ax: number, ay: number, bx: number, by: number): number => ax * by - ay * bx;\n\n/** Angular inverse mass as the solver sees it: a sleeping body holds still like ground. */\nconst solverInvInertia = (b: Body): number => (b.awake ? b.invInertia : 0);\n\n/**\n * Sequential impulses: each contact point is a normal constraint (no approach, plus bounce) and a friction constraint\n * clamped by its normal impulse (Coulomb), applied at the point so a body that rotates is turned by it. Penetration\n * is not fed back into the velocities (no Baumgarte energy): it is removed afterwards by moving positions and angles\n * only, tracked as the bodies move (a \"split impulse\" in its simplest form), so resting bodies do not bounce off their\n * own correction. Bodies that do not rotate have no inverse inertia, and every angular term drops out.\n */\nexport class ContactSolver {\n  constructor(private readonly settings: SolverSettings) {}\n\n  /** Mass, friction and the velocity target of every enabled contact point; then the impulses carried over from the last sub-step are applied (warm start). */\n  prepare(contacts: readonly Contact[], dt: number): void {\n    const { restitutionThreshold } = this.settings;\n    for (const c of contacts) {\n      if (!c.enabled) continue;\n      const a = c.a;\n      const b = c.b;\n      const ia = a.solverInvMass;\n      const ib = b.solverInvMass;\n      const iia = solverInvInertia(a);\n      const iib = solverInvInertia(b);\n      c.mu = Math.sqrt(a.friction * b.friction);\n      const nx = c.nx;\n      const ny = c.ny;\n      const tx = -ny;\n      const ty = nx;\n      const e = Math.max(a.restitution, b.restitution);\n      for (let i = 0; i < c.count; i++) {\n        const p = c.pts[i]!;\n        p.rax = p.x - a.x;\n        p.ray = p.y - a.y;\n        p.rbx = p.x - b.x;\n        p.rby = p.y - b.y;\n        const rnA = cross(p.rax, p.ray, nx, ny);\n        const rnB = cross(p.rbx, p.rby, nx, ny);\n        const kn = ia + ib + iia * rnA * rnA + iib * rnB * rnB;\n        p.massN = kn > 0 ? 1 / kn : 0;\n        const rtA = cross(p.rax, p.ray, tx, ty);\n        const rtB = cross(p.rbx, p.rby, tx, ty);\n        const kt = ia + ib + iia * rtA * rtA + iib * rtB * rtB;\n        p.massT = kt > 0 ? 1 / kt : 0;\n        const vn = relX(a, b, p) * nx + relY(a, b, p) * ny;\n        if (p.depth < 0) {\n          // still a hair apart: let them close the gap this sub-step, no more (a speculative contact)\n          p.target = p.depth / dt;\n        } else {\n          p.target = vn < -restitutionThreshold ? -e * vn : 0;\n        }\n        apply(a, b, p, p.jn * nx + p.jt * tx, p.jn * ny + p.jt * ty, ia, ib, iia, iib);\n      }\n    }\n  }\n\n  solveVelocities(contacts: readonly Contact[]): void {\n    for (const c of contacts) {\n      if (!c.enabled) continue;\n      const a = c.a;\n      const b = c.b;\n      const ia = a.solverInvMass;\n      const ib = b.solverInvMass;\n      const iia = solverInvInertia(a);\n      const iib = solverInvInertia(b);\n      const nx = c.nx;\n      const ny = c.ny;\n      const tx = -ny;\n      const ty = nx;\n      for (let i = 0; i < c.count; i++) {\n        const p = c.pts[i]!;\n        if (p.massN === 0) continue;\n        // friction first, bounded by the normal impulse of the last iteration\n        const vt = relX(a, b, p) * tx + relY(a, b, p) * ty;\n        const maxT = c.mu * p.jn;\n        const jtNew = Math.max(-maxT, Math.min(maxT, p.jt - vt * p.massT));\n        const dT = jtNew - p.jt;\n        p.jt = jtNew;\n        apply(a, b, p, dT * tx, dT * ty, ia, ib, iia, iib);\n\n        const vn = relX(a, b, p) * nx + relY(a, b, p) * ny;\n        const jnNew = Math.max(0, p.jn + (p.target - vn) * p.massN);\n        const dn = jnNew - p.jn;\n        p.jn = jnNew;\n        apply(a, b, p, dn * nx, dn * ny, ia, ib, iia, iib);\n      }\n    }\n  }\n\n  /** Pushes overlapping pairs apart along their normals, by position (and angle) only. */\n  solvePositions(contacts: readonly Contact[]): void {\n    const { slop, correction, maxCorrection } = this.settings;\n    for (const c of contacts) {\n      if (!c.enabled) continue;\n      const a = c.a;\n      const b = c.b;\n      const ia = a.solverInvMass;\n      const ib = b.solverInvMass;\n      const iia = solverInvInertia(a);\n      const iib = solverInvInertia(b);\n      const nx = c.nx;\n      const ny = c.ny;\n      for (let i = 0; i < c.count; i++) {\n        const p = c.pts[i]!;\n        // where the point's two anchors are now: their drift apart along the normal is what the depth has lost\n        const ca = a.rotates ? Math.cos(a.angle) : a.cos;\n        const sa = a.rotates ? Math.sin(a.angle) : a.sin;\n        const cb = b.rotates ? Math.cos(b.angle) : b.cos;\n        const sb = b.rotates ? Math.sin(b.angle) : b.sin;\n        const rax = ca * p.lax - sa * p.lay;\n        const ray = sa * p.lax + ca * p.lay;\n        const rbx = cb * p.lbx - sb * p.lby;\n        const rby = sb * p.lbx + cb * p.lby;\n        const moved = (b.x + rbx - (a.x + rax)) * nx + (b.y + rby - (a.y + ray)) * ny;\n        const depth = p.depth - moved;\n        if (depth <= slop) continue;\n        const rnA = cross(rax, ray, nx, ny);\n        const rnB = cross(rbx, rby, nx, ny);\n        const k = ia + ib + iia * rnA * rnA + iib * rnB * rnB;\n        if (k === 0) continue;\n        const push = Math.min(maxCorrection, correction * (depth - slop)) / k;\n        const px = push * nx;\n        const py = push * ny;\n        a.x -= px * ia;\n        a.y -= py * ia;\n        b.x += px * ib;\n        b.y += py * ib;\n        if (iia > 0) a.angle -= iia * cross(rax, ray, px, py);\n        if (iib > 0) b.angle += iib * cross(rbx, rby, px, py);\n      }\n    }\n  }\n}\n\n/** Velocity of b's material at the point less a's. */\nfunction relX(a: Body, b: Body, p: ContactPoint): number {\n  return b.vx - b.angularVelocity * p.rby - (a.vx - a.angularVelocity * p.ray);\n}\n\nfunction relY(a: Body, b: Body, p: ContactPoint): number {\n  return b.vy + b.angularVelocity * p.rbx - (a.vy + a.angularVelocity * p.rax);\n}\n\n/** Impulse (px, py) on b at the point, its opposite on a. */\nfunction apply(a: Body, b: Body, p: ContactPoint, px: number, py: number, ia: number, ib: number, iia: number, iib: number): void {\n  a.vx -= px * ia;\n  a.vy -= py * ia;\n  b.vx += px * ib;\n  b.vy += py * ib;\n  if (iia > 0) a.angularVelocity -= iia * cross(p.rax, p.ray, px, py);\n  if (iib > 0) b.angularVelocity += iib * cross(p.rbx, p.rby, px, py);\n}\n"],"names":["cross","ax","ay","bx","by","solverInvInertia","b","ContactSolver","settings","contacts","dt","restitutionThreshold","ia","ib","iia","iib","nx","ny","tx","ty","e","i","p","rnA","rnB","kn","rtA","rtB","kt","vn","relX","relY","apply","c","a","vt","maxT","jtNew","dT","jnNew","dn","slop","correction","maxCorrection","ca","sa","cb","sb","rax","ray","rbx","rby","moved","depth","k","push","px","py"],"mappings":"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"}

package/dist/physics/PhysicsWorld.js

@@ -0,0 +1,221 @@
+import { EventBus as k } from "../events/EventBus.js";
+import { Body as x } from "./Body.js";
+import { BroadPhase as M } from "./BroadPhase.js";
+import { emptyManifold as w, collide as C } from "./collide.js";
+import { Contact as b } from "./Contact.js";
+import { ContactSolver as I } from "./ContactSolver.js";
+import { info as p, setGround as S } from "./contactReport.js";
+import { castRay as j } from "./raycast.js";
+class O {
+  gravityX;
+  gravityY;
+  events = new k();
+  /** Called for each touching solid pair every sub-step; returning false skips its response this sub-step (one-way platforms). */
+  preSolve = null;
+  list = [];
+  broad;
+  solver;
+  contacts = /* @__PURE__ */ new Map();
+  active = [];
+  manifold = w();
+  removals = [];
+  settings;
+  velocityIterations;
+  positionIterations;
+  maxSubsteps;
+  maxSpeed;
+  margin;
+  groundNormal;
+  allowSleep;
+  sleepSpeed;
+  sleepTime;
+  stepCount = 0;
+  subCount = 0;
+  stepping = !1;
+  constructor(e = {}) {
+    this.gravityX = e.gravityX ?? 0, this.gravityY = e.gravityY ?? 980, this.margin = e.contactMargin ?? 0.5, this.settings = {
+      restitutionThreshold: e.restitutionThreshold ?? 40,
+      slop: e.slop ?? 0.05,
+      correction: e.correction ?? 0.4,
+      maxCorrection: e.maxCorrection ?? 4
+    }, this.solver = new I(this.settings), this.broad = new M(e.cellSize ?? 64, this.margin), this.velocityIterations = e.velocityIterations ?? 8, this.positionIterations = e.positionIterations ?? 3, this.maxSubsteps = Math.max(1, e.maxSubsteps ?? 16), this.maxSpeed = e.maxSpeed ?? 4e3, this.groundNormal = e.groundNormal ?? 0.7, this.allowSleep = e.allowSleep ?? !1, this.sleepSpeed = e.sleepSpeed ?? 4, this.sleepTime = e.sleepTime ?? 0.5;
+  }
+  /** Adds a body (or makes one from options) and returns it. */
+  add(e) {
+    const i = e instanceof x ? e : new x(e);
+    return i.inWorld || (i.inWorld = !0, i.updateBounds(), i.wake(), this.list.push(i), i.isStatic && this.broad.markStaticsDirty()), i;
+  }
+  addAll(e) {
+    for (const i of e) this.add(i);
+  }
+  /** Takes a body out; its contacts end (with `end` events). During a step it waits until the step is over. */
+  remove(e) {
+    if (!e.inWorld) return;
+    if (this.stepping) {
+      this.removals.push(e);
+      return;
+    }
+    e.inWorld = !1;
+    const i = this.list.indexOf(e);
+    i >= 0 && this.list.splice(i, 1), e.isStatic && this.broad.markStaticsDirty(), e.grounded = !1, e.ground = null;
+    const t = [];
+    for (const [n, s] of this.contacts)
+      s.a !== e && s.b !== e || (s.other(e).wake(), s.reported && t.push(p(s)), this.contacts.delete(n));
+    for (const n of t) this.events.emit("end", n);
+  }
+  /** Call after moving, resizing or retyping a static body by hand. */
+  staticsChanged() {
+    this.broad.markStaticsDirty();
+  }
+  get bodyCount() {
+    return this.list.length;
+  }
+  /**
+   * Every body in the world, in the order added: for tools (a debug drawing, an inspector) that would otherwise keep
+   * a second list beside the world's. Read it, never hold it across a step: adding and removing change it in place.
+   */
+  get bodies() {
+    return this.list;
+  }
+  /** Advances the world by `dt` seconds; call it with the fixed step (`FixedLoop.stepSeconds`). */
+  step(e) {
+    if (!(!(e > 0) || !Number.isFinite(e))) {
+      this.stepping = !0;
+      try {
+        this.stepCount++;
+        for (const t of this.list)
+          t.prevX = t.x, t.prevY = t.y, t.prevAngle = t.angle;
+        const i = this.substepsFor(e);
+        for (let t = 0; t < i; t++) this.substep(e / i);
+        for (const t of this.list)
+          t.fx = 0, t.fy = 0, t.torque = 0;
+        this.allowSleep && this.updateSleep(e);
+      } finally {
+        this.stepping = !1;
+      }
+      this.finishContacts();
+      for (const i of this.removals.splice(0)) this.remove(i);
+    }
+  }
+  /** The first body on the segment from (x0, y0) to (x1, y1). Bodies the ray starts inside are skipped. */
+  raycast(e, i, t, n, s) {
+    for (const r of this.list) r.isStatic || r.updateBounds();
+    return this.broad.rebuild(this.list), j([this.broad.statics, this.broad.movers], e, i, t, n, s);
+  }
+  /** The pairs touching `body` after the last step (sensors' overlaps included). */
+  contactsOf(e, i = []) {
+    i.length = 0;
+    for (const t of this.contacts.values()) t.reported && (t.a === e || t.b === e) && i.push(t);
+    return i;
+  }
+  /** Whether `body` stood on something at the end of the last step (also `body.grounded`). */
+  isGrounded(e) {
+    return e.grounded;
+  }
+  substepsFor(e) {
+    const i = this.gravityX, t = this.gravityY;
+    let n = 0;
+    for (const s of this.list) {
+      if (!s.moving) continue;
+      const r = s.isDynamic ? Math.hypot(i, t) * Math.abs(s.gravityScale) * e : 0, l = Math.min(this.maxSpeed, Math.hypot(s.vx, s.vy) + r + Math.abs(s.angularVelocity) * s.maxExtent);
+      n = Math.max(n, l * e / Math.max(0.5, s.minHalfExtent));
+    }
+    return Math.min(this.maxSubsteps, Math.max(1, Math.ceil(n)));
+  }
+  substep(e) {
+    this.subCount++;
+    const i = this.maxSpeed * this.maxSpeed;
+    for (const t of this.list) {
+      if (!t.isDynamic || !t.awake) continue;
+      if (t.vx += (this.gravityX * t.gravityScale + t.fx * t.invMass) * e, t.vy += (this.gravityY * t.gravityScale + t.fy * t.invMass) * e, t.linearDamping > 0) {
+        const s = 1 / (1 + t.linearDamping * e);
+        t.vx *= s, t.vy *= s;
+      }
+      const n = t.vx * t.vx + t.vy * t.vy;
+      if (n > i) {
+        const s = this.maxSpeed / Math.sqrt(n);
+        t.vx *= s, t.vy *= s;
+      }
+      if (t.invInertia > 0) {
+        t.angularVelocity += t.torque * t.invInertia * e, t.angularDamping > 0 && (t.angularVelocity /= 1 + t.angularDamping * e);
+        const s = this.maxSpeed / Math.max(1, t.maxExtent);
+        Math.abs(t.angularVelocity) > s && (t.angularVelocity = Math.sign(t.angularVelocity) * s);
+      }
+    }
+    this.broad.rebuild(this.list), this.active.length = 0, this.broad.pairs(this.list, this.visitPair), this.solver.prepare(this.active, e);
+    for (let t = 0; t < this.velocityIterations; t++) this.solver.solveVelocities(this.active);
+    for (const t of this.list)
+      t.moving && (t.x += t.vx * e, t.y += t.vy * e, t.rotates && (t.angle += t.angularVelocity * e));
+    for (let t = 0; t < this.positionIterations; t++) this.solver.solvePositions(this.active);
+    for (const t of this.list) t.moving && t.updateBounds();
+  }
+  visitPair = (e, i) => {
+    if (!(e.layer & i.mask) || !(i.layer & e.mask)) return;
+    const t = e.sensor || i.sensor;
+    if (e.invMass === 0 && i.invMass === 0 && !t) return;
+    const n = e.id < i.id ? e : i, s = n === e ? i : e, r = this.manifold;
+    if (!C(n, s, t ? 0 : this.margin, r) || t && r.depth <= 0) return;
+    const l = b.keyOf(n, s);
+    let o = this.contacts.get(l);
+    if (o || (o = new b(n, s, l), this.contacts.set(l, o)), this.takeManifold(o, r, o.seenSub === this.subCount - 1), o.seenSub = this.subCount, o.seenStep = this.stepCount, t) {
+      o.enabled = !1;
+      return;
+    }
+    n.awake !== s.awake && this.wakeOnImpact(n, s), o.enabled = this.preSolve ? this.preSolve(o) !== !1 : !0, o.enabled && this.active.push(o);
+  };
+  /**
+   * Copies the narrow phase's points into the contact, carrying each point's impulses over from the last sub-step
+   * when the same feature touches again (`warm`: the pair touched on the last sub-step).
+   */
+  takeManifold(e, i, t) {
+    const n = e.a, s = e.b;
+    let r = 0, l = 0, o = 0, d = 0, f = -1, u = -1;
+    t && (e.count > 0 && (f = e.pts[0].id, r = e.pts[0].jn, l = e.pts[0].jt), e.count > 1 && (u = e.pts[1].id, o = e.pts[1].jn, d = e.pts[1].jt)), e.nx = i.nx, e.ny = i.ny, e.depth = i.depth, e.count = i.count;
+    for (let c = 0; c < i.count; c++) {
+      const a = e.pts[c], h = i.id[c];
+      a.x = i.px[c], a.y = i.py[c], a.depth = i.pd[c], a.id = h, a.jn = h === f ? r : h === u ? o : 0, a.jt = h === f ? l : h === u ? d : 0;
+      const v = a.x - n.x, m = a.y - n.y;
+      a.lax = n.cos * v + n.sin * m, a.lay = -n.sin * v + n.cos * m;
+      const g = a.x - s.x, y = a.y - s.y;
+      a.lbx = s.cos * g + s.sin * y, a.lby = -s.sin * g + s.cos * y;
+    }
+  }
+  /** A sleeping body wakes when something meets it faster than the sleep speed (a kinematic platform always does). */
+  wakeOnImpact(e, i) {
+    const t = e.awake ? i : e, n = e.awake ? e : i;
+    if (t.isStatic) return;
+    const s = Math.hypot(n.vx - t.vx, n.vy - t.vy);
+    (n.type === "kinematic" || s > this.sleepSpeed) && t.wake();
+  }
+  updateSleep(e) {
+    const i = this.sleepSpeed * this.sleepSpeed;
+    for (const t of this.list) {
+      if (!t.isDynamic || !t.awake) continue;
+      const n = t.angularVelocity * t.maxExtent;
+      if (t.vx * t.vx + t.vy * t.vy + n * n > i || t.fx !== 0 || t.fy !== 0 || t.torque !== 0) {
+        t.restTime = 0;
+        continue;
+      }
+      t.restTime += e, t.restTime >= this.sleepTime && (t.awake = !1, t.vx = 0, t.vy = 0, t.angularVelocity = 0);
+    }
+  }
+  /** Ends pairs no longer touching, starts new ones, refreshes `grounded`, then emits the events. */
+  finishContacts() {
+    for (const n of this.list)
+      n.grounded = !1, n.ground = null;
+    const e = [], i = [], t = this.groundNormal;
+    for (const [n, s] of this.contacts) {
+      if (!(s.seenStep === this.stepCount || s.reported && !s.a.moving && !s.b.moving)) {
+        s.reported && i.push(p(s)), this.contacts.delete(n);
+        continue;
+      }
+      s.reported || (s.reported = !0, e.push(p(s))), !(s.sensor || !s.enabled) && (s.ny < -t ? S(s.b, s.a, s) : s.ny > t && S(s.a, s.b, s));
+    }
+    for (const n of i) this.events.emit("end", n);
+    for (const n of e) this.events.emit("begin", n);
+  }
+}
+export {
+  O as PhysicsWorld
+};
+//# sourceMappingURL=PhysicsWorld.js.map

package/dist/physics/PhysicsWorld.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsWorld.js","sources":["../../src/physics/PhysicsWorld.ts"],"sourcesContent":["import { EventBus } from '../events/EventBus';\nimport { Body } from './Body';\nimport { BroadPhase } from './BroadPhase';\nimport { collide, emptyManifold, type Manifold } from './collide';\nimport { Contact } from './Contact';\nimport { ContactSolver, type SolverSettings } from './ContactSolver';\nimport { info, setGround } from './contactReport';\nimport type { PhysicsWorldOptions } from './PhysicsWorldOptions';\nimport { castRay } from './raycast';\nimport type { BodyOptions, ContactInfo, PhysicsEvents, RayHit, RaycastOptions } from './types';\n\n/**\n * A rigid-body world for platformers and physics toys: dynamic, static and kinematic circles, boxes and convex\n * polygons, turned by contacts when made with `rotates: true`, stepped at a fixed dt (`physicsSystem` runs it as a\n * `fixed` system). Each step: forces and gravity (semi-implicit Euler), broad phase, narrow phase, sequential impulses\n * with warm starting, then positions, then overlap removed by moving positions. Fast bodies are handled by\n * sub-stepping, not swept tests.\n *\n * Not deterministic across machines: the solver's results depend on body order and floating point, which is fine for\n * a single player's world but not for one a server must replay (use `net/movement` for that).\n */\nexport class PhysicsWorld {\n  gravityX: number;\n  gravityY: number;\n  readonly events = new EventBus<PhysicsEvents>();\n  /** Called for each touching solid pair every sub-step; returning false skips its response this sub-step (one-way platforms). */\n  preSolve: ((contact: Contact) => boolean) | null = null;\n  private readonly list: Body[] = [];\n  private readonly broad: BroadPhase;\n  private readonly solver: ContactSolver;\n  private readonly contacts = new Map<number, Contact>();\n  private readonly active: Contact[] = [];\n  private readonly manifold = emptyManifold();\n  private readonly removals: Body[] = [];\n  private readonly settings: SolverSettings;\n  private readonly velocityIterations: number;\n  private readonly positionIterations: number;\n  private readonly maxSubsteps: number;\n  private readonly maxSpeed: number;\n  private readonly margin: number;\n  private readonly groundNormal: number;\n  private readonly allowSleep: boolean;\n  private readonly sleepSpeed: number;\n  private readonly sleepTime: number;\n  private stepCount = 0;\n  private subCount = 0;\n  private stepping = false;\n\n  constructor(options: PhysicsWorldOptions = {}) {\n    this.gravityX = options.gravityX ?? 0;\n    this.gravityY = options.gravityY ?? 980;\n    this.margin = options.contactMargin ?? 0.5;\n    this.settings = {\n      restitutionThreshold: options.restitutionThreshold ?? 40,\n      slop: options.slop ?? 0.05,\n      correction: options.correction ?? 0.4,\n      maxCorrection: options.maxCorrection ?? 4,\n    };\n    this.solver = new ContactSolver(this.settings);\n    this.broad = new BroadPhase(options.cellSize ?? 64, this.margin);\n    this.velocityIterations = options.velocityIterations ?? 8;\n    this.positionIterations = options.positionIterations ?? 3;\n    this.maxSubsteps = Math.max(1, options.maxSubsteps ?? 16);\n    this.maxSpeed = options.maxSpeed ?? 4000;\n    this.groundNormal = options.groundNormal ?? 0.7;\n    this.allowSleep = options.allowSleep ?? false;\n    this.sleepSpeed = options.sleepSpeed ?? 4;\n    this.sleepTime = options.sleepTime ?? 0.5;\n  }\n\n  /** Adds a body (or makes one from options) and returns it. */\n  add(body: Body | BodyOptions): Body {\n    const b = body instanceof Body ? body : new Body(body);\n    if (b.inWorld) return b;\n    b.inWorld = true;\n    b.updateBounds();\n    b.wake();\n    this.list.push(b);\n    if (b.isStatic) this.broad.markStaticsDirty();\n    return b;\n  }\n\n  addAll(bodies: Iterable<Body>): void {\n    for (const b of bodies) this.add(b);\n  }\n\n  /** Takes a body out; its contacts end (with `end` events). During a step it waits until the step is over. */\n  remove(body: Body): void {\n    if (!body.inWorld) return;\n    if (this.stepping) {\n      this.removals.push(body);\n      return;\n    }\n    body.inWorld = false;\n    const i = this.list.indexOf(body);\n    if (i >= 0) this.list.splice(i, 1);\n    if (body.isStatic) this.broad.markStaticsDirty();\n    body.grounded = false;\n    body.ground = null;\n    const ended: ContactInfo[] = [];\n    for (const [key, c] of this.contacts) {\n      if (c.a !== body && c.b !== body) continue;\n      c.other(body).wake();\n      if (c.reported) ended.push(info(c));\n      this.contacts.delete(key);\n    }\n    for (const e of ended) this.events.emit('end', e);\n  }\n\n  /** Call after moving, resizing or retyping a static body by hand. */\n  staticsChanged(): void {\n    this.broad.markStaticsDirty();\n  }\n\n  get bodyCount(): number {\n    return this.list.length;\n  }\n\n  /**\n   * Every body in the world, in the order added: for tools (a debug drawing, an inspector) that would otherwise keep\n   * a second list beside the world's. Read it, never hold it across a step: adding and removing change it in place.\n   */\n  get bodies(): readonly Body[] {\n    return this.list;\n  }\n\n  /** Advances the world by `dt` seconds; call it with the fixed step (`FixedLoop.stepSeconds`). */\n  step(dt: number): void {\n    if (!(dt > 0) || !Number.isFinite(dt)) return;\n    this.stepping = true;\n    try {\n      this.stepCount++;\n      for (const b of this.list) {\n        b.prevX = b.x;\n        b.prevY = b.y;\n        b.prevAngle = b.angle;\n      }\n      const n = this.substepsFor(dt);\n      for (let i = 0; i < n; i++) this.substep(dt / n);\n      for (const b of this.list) {\n        b.fx = 0;\n        b.fy = 0;\n        b.torque = 0;\n      }\n      if (this.allowSleep) this.updateSleep(dt);\n    } finally {\n      this.stepping = false;\n    }\n    this.finishContacts();\n    for (const b of this.removals.splice(0)) this.remove(b);\n  }\n\n  /** The first body on the segment from (x0, y0) to (x1, y1). Bodies the ray starts inside are skipped. */\n  raycast(x0: number, y0: number, x1: number, y1: number, options?: RaycastOptions): RayHit | null {\n    for (const b of this.list) if (!b.isStatic) b.updateBounds();\n    this.broad.rebuild(this.list);\n    return castRay([this.broad.statics, this.broad.movers], x0, y0, x1, y1, options);\n  }\n\n  /** The pairs touching `body` after the last step (sensors' overlaps included). */\n  contactsOf(body: Body, out: ContactInfo[] = []): ContactInfo[] {\n    out.length = 0;\n    for (const c of this.contacts.values()) if (c.reported && (c.a === body || c.b === body)) out.push(c);\n    return out;\n  }\n\n  /** Whether `body` stood on something at the end of the last step (also `body.grounded`). */\n  isGrounded(body: Body): boolean {\n    return body.grounded;\n  }\n\n  private substepsFor(dt: number): number {\n    const gx = this.gravityX;\n    const gy = this.gravityY;\n    let worst = 0;\n    for (const b of this.list) {\n      if (!b.moving) continue;\n      const g = b.isDynamic ? Math.hypot(gx, gy) * Math.abs(b.gravityScale) * dt : 0;\n      // a turning body's corners sweep too\n      const speed = Math.min(this.maxSpeed, Math.hypot(b.vx, b.vy) + g + Math.abs(b.angularVelocity) * b.maxExtent);\n      worst = Math.max(worst, (speed * dt) / Math.max(0.5, b.minHalfExtent));\n    }\n    return Math.min(this.maxSubsteps, Math.max(1, Math.ceil(worst)));\n  }\n\n  private substep(h: number): void {\n    this.subCount++;\n    const max2 = this.maxSpeed * this.maxSpeed;\n    for (const b of this.list) {\n      if (!b.isDynamic || !b.awake) continue;\n      b.vx += (this.gravityX * b.gravityScale + b.fx * b.invMass) * h;\n      b.vy += (this.gravityY * b.gravityScale + b.fy * b.invMass) * h;\n      if (b.linearDamping > 0) {\n        const k = 1 / (1 + b.linearDamping * h);\n        b.vx *= k;\n        b.vy *= k;\n      }\n      const s2 = b.vx * b.vx + b.vy * b.vy;\n      if (s2 > max2) {\n        const k = this.maxSpeed / Math.sqrt(s2);\n        b.vx *= k;\n        b.vy *= k;\n      }\n      if (b.invInertia > 0) {\n        b.angularVelocity += b.torque * b.invInertia * h;\n        if (b.angularDamping > 0) b.angularVelocity /= 1 + b.angularDamping * h;\n        // no corner faster than the speed limit\n        const maxW = this.maxSpeed / Math.max(1, b.maxExtent);\n        if (Math.abs(b.angularVelocity) > maxW) b.angularVelocity = Math.sign(b.angularVelocity) * maxW;\n      }\n    }\n    this.broad.rebuild(this.list);\n    this.active.length = 0;\n    this.broad.pairs(this.list, this.visitPair);\n    this.solver.prepare(this.active, h);\n    for (let i = 0; i < this.velocityIterations; i++) this.solver.solveVelocities(this.active);\n    for (const b of this.list) {\n      if (!b.moving) continue;\n      b.x += b.vx * h;\n      b.y += b.vy * h;\n      if (b.rotates) b.angle += b.angularVelocity * h;\n    }\n    for (let i = 0; i < this.positionIterations; i++) this.solver.solvePositions(this.active);\n    for (const b of this.list) if (b.moving) b.updateBounds();\n  }\n\n  private readonly visitPair = (p: Body, q: Body): void => {\n    if (!(p.layer & q.mask) || !(q.layer & p.mask)) return;\n    const sensor = p.sensor || q.sensor;\n    // two bodies nothing can push: only a sensor among them has anything to report\n    if (p.invMass === 0 && q.invMass === 0 && !sensor) return;\n    const a = p.id < q.id ? p : q;\n    const b = a === p ? q : p;\n    const m = this.manifold;\n    if (!collide(a, b, sensor ? 0 : this.margin, m)) return;\n    if (sensor && m.depth <= 0) return;\n    const key = Contact.keyOf(a, b);\n    let c = this.contacts.get(key);\n    if (!c) {\n      c = new Contact(a, b, key);\n      this.contacts.set(key, c);\n    }\n    this.takeManifold(c, m, c.seenSub === this.subCount - 1);\n    c.seenSub = this.subCount;\n    c.seenStep = this.stepCount;\n    if (sensor) {\n      c.enabled = false;\n      return;\n    }\n    if (a.awake !== b.awake) this.wakeOnImpact(a, b);\n    c.enabled = this.preSolve ? this.preSolve(c) !== false : true;\n    if (c.enabled) this.active.push(c);\n  };\n\n  /**\n   * Copies the narrow phase's points into the contact, carrying each point's impulses over from the last sub-step\n   * when the same feature touches again (`warm`: the pair touched on the last sub-step).\n   */\n  private takeManifold(c: Contact, m: Manifold, warm: boolean): void {\n    const a = c.a;\n    const b = c.b;\n    let j0n = 0;\n    let j0t = 0;\n    let j1n = 0;\n    let j1t = 0;\n    let id0 = -1;\n    let id1 = -1;\n    if (warm) {\n      if (c.count > 0) {\n        id0 = c.pts[0].id;\n        j0n = c.pts[0].jn;\n        j0t = c.pts[0].jt;\n      }\n      if (c.count > 1) {\n        id1 = c.pts[1].id;\n        j1n = c.pts[1].jn;\n        j1t = c.pts[1].jt;\n      }\n    }\n    c.nx = m.nx;\n    c.ny = m.ny;\n    c.depth = m.depth;\n    c.count = m.count;\n    for (let i = 0; i < m.count; i++) {\n      const p = c.pts[i]!;\n      const id = m.id[i]!;\n      p.x = m.px[i]!;\n      p.y = m.py[i]!;\n      p.depth = m.pd[i]!;\n      p.id = id;\n      p.jn = id === id0 ? j0n : id === id1 ? j1n : 0;\n      p.jt = id === id0 ? j0t : id === id1 ? j1t : 0;\n      const dax = p.x - a.x;\n      const day = p.y - a.y;\n      p.lax = a.cos * dax + a.sin * day;\n      p.lay = -a.sin * dax + a.cos * day;\n      const dbx = p.x - b.x;\n      const dby = p.y - b.y;\n      p.lbx = b.cos * dbx + b.sin * dby;\n      p.lby = -b.sin * dbx + b.cos * dby;\n    }\n  }\n\n  /** A sleeping body wakes when something meets it faster than the sleep speed (a kinematic platform always does). */\n  private wakeOnImpact(a: Body, b: Body): void {\n    const sleeper = a.awake ? b : a;\n    const mover = a.awake ? a : b;\n    if (sleeper.isStatic) return;\n    const rv = Math.hypot(mover.vx - sleeper.vx, mover.vy - sleeper.vy);\n    if (mover.type === 'kinematic' || rv > this.sleepSpeed) sleeper.wake();\n  }\n\n  private updateSleep(dt: number): void {\n    const s2 = this.sleepSpeed * this.sleepSpeed;\n    for (const b of this.list) {\n      if (!b.isDynamic || !b.awake) continue;\n      const spin = b.angularVelocity * b.maxExtent;\n      if (b.vx * b.vx + b.vy * b.vy + spin * spin > s2 || b.fx !== 0 || b.fy !== 0 || b.torque !== 0) {\n        b.restTime = 0;\n        continue;\n      }\n      b.restTime += dt;\n      if (b.restTime >= this.sleepTime) {\n        b.awake = false;\n        b.vx = 0;\n        b.vy = 0;\n        b.angularVelocity = 0;\n      }\n    }\n  }\n\n  /** Ends pairs no longer touching, starts new ones, refreshes `grounded`, then emits the events. */\n  private finishContacts(): void {\n    for (const b of this.list) {\n      b.grounded = false;\n      b.ground = null;\n    }\n    const begun: ContactInfo[] = [];\n    const ended: ContactInfo[] = [];\n    const cos = this.groundNormal;\n    for (const [key, c] of this.contacts) {\n      // a pair of bodies that are both at rest is not re-tested: it keeps touching as it was\n      const touching = c.seenStep === this.stepCount || (c.reported && !c.a.moving && !c.b.moving);\n      if (!touching) {\n        if (c.reported) ended.push(info(c));\n        this.contacts.delete(key);\n        continue;\n      }\n      if (!c.reported) {\n        c.reported = true;\n        begun.push(info(c));\n      }\n      if (c.sensor || !c.enabled) continue;\n      if (c.ny < -cos) setGround(c.b, c.a, c);\n      else if (c.ny > cos) setGround(c.a, c.b, c);\n    }\n    for (const e of ended) this.events.emit('end', e);\n    for (const e of begun) this.events.emit('begin', e);\n  }\n}\n"],"names":["PhysicsWorld","EventBus","emptyManifold","options","ContactSolver","BroadPhase","body","b","Body","bodies","ended","key","c","info","e","dt","n","i","x0","y0","x1","y1","castRay","out","gx","gy","worst","g","speed","h","max2","k","s2","maxW","p","q","sensor","a","m","collide","Contact","warm","j0n","j0t","j1n","j1t","id0","id1","id","dax","day","dbx","dby","sleeper","mover","rv","spin","begun","cos","setGround"],"mappings":"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"}

package/dist/physics/SpatialHash.js

@@ -0,0 +1,39 @@
+class i {
+  cellSize;
+  inv;
+  cells = /* @__PURE__ */ new Map();
+  /** Lists emptied by `clear`, kept for reuse so a rebuild every step allocates nothing once warm. */
+  spare = [];
+  constructor(t) {
+    if (!(t > 0)) throw new Error(`SpatialHash: cell size must be positive, got ${t}`);
+    this.cellSize = t, this.inv = 1 / t;
+  }
+  static key(t, s) {
+    return (t + 32768 & 65535) * 65536 + (s + 32768 & 65535);
+  }
+  cellOf(t) {
+    return Math.floor(t * this.inv);
+  }
+  clear() {
+    for (const t of this.cells.values())
+      t.length = 0, this.spare.push(t);
+    this.cells.clear();
+  }
+  insert(t, s = 0) {
+    const h = this.cellOf(t.minX - s), n = this.cellOf(t.maxX + s), o = this.cellOf(t.minY - s), f = this.cellOf(t.maxY + s);
+    for (let l = o; l <= f; l++)
+      for (let c = h; c <= n; c++) {
+        const r = i.key(c, l);
+        let e = this.cells.get(r);
+        e || (e = this.spare.pop() ?? [], this.cells.set(r, e)), e.push(t);
+      }
+  }
+  /** The bodies listed in one cell (undefined when empty). Do not keep or edit the array. */
+  at(t, s) {
+    return this.cells.get(i.key(t, s));
+  }
+}
+export {
+  i as SpatialHash
+};
+//# sourceMappingURL=SpatialHash.js.map

package/dist/physics/SpatialHash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpatialHash.js","sources":["../../src/physics/SpatialHash.ts"],"sourcesContent":["import type { Body } from './Body';\n\n/**\n * Broad phase: a uniform grid hashed into a map, each cell listing the bodies whose bounds touch it. A body spans\n * as many cells as its bounds cover, so a long merged floor sits in a row of cells and is still one body.\n *\n * Cells are keyed by their coordinates packed into one number (16 bits each, wrapping): two cells 65,536 cells\n * apart share a list, which only costs a few extra narrow-phase tests, never a missed pair.\n */\nexport class SpatialHash {\n  readonly cellSize: number;\n  private readonly inv: number;\n  private readonly cells = new Map<number, Body[]>();\n  /** Lists emptied by `clear`, kept for reuse so a rebuild every step allocates nothing once warm. */\n  private readonly spare: Body[][] = [];\n\n  constructor(cellSize: number) {\n    if (!(cellSize > 0)) throw new Error(`SpatialHash: cell size must be positive, got ${cellSize}`);\n    this.cellSize = cellSize;\n    this.inv = 1 / cellSize;\n  }\n\n  static key(cx: number, cy: number): number {\n    return ((cx + 0x8000) & 0xffff) * 0x10000 + ((cy + 0x8000) & 0xffff);\n  }\n\n  cellOf(v: number): number {\n    return Math.floor(v * this.inv);\n  }\n\n  clear(): void {\n    for (const list of this.cells.values()) {\n      list.length = 0;\n      this.spare.push(list);\n    }\n    this.cells.clear();\n  }\n\n  insert(body: Body, margin = 0): void {\n    const x0 = this.cellOf(body.minX - margin);\n    const x1 = this.cellOf(body.maxX + margin);\n    const y0 = this.cellOf(body.minY - margin);\n    const y1 = this.cellOf(body.maxY + margin);\n    for (let cy = y0; cy <= y1; cy++) {\n      for (let cx = x0; cx <= x1; cx++) {\n        const k = SpatialHash.key(cx, cy);\n        let list = this.cells.get(k);\n        if (!list) {\n          list = this.spare.pop() ?? [];\n          this.cells.set(k, list);\n        }\n        list.push(body);\n      }\n    }\n  }\n\n  /** The bodies listed in one cell (undefined when empty). Do not keep or edit the array. */\n  at(cx: number, cy: number): readonly Body[] | undefined {\n    return this.cells.get(SpatialHash.key(cx, cy));\n  }\n}\n"],"names":["SpatialHash","cellSize","cx","cy","v","list","body","margin","x0","x1","y0","y1","k"],"mappings":"AASO,MAAMA,EAAY;AAAA,EACd;AAAA,EACQ;AAAA,EACA,4BAAY,IAAA;AAAA;AAAA,EAEZ,QAAkB,CAAA;AAAA,EAEnC,YAAYC,GAAkB;AAC5B,QAAI,EAAEA,IAAW,GAAI,OAAM,IAAI,MAAM,gDAAgDA,CAAQ,EAAE;AAC/F,SAAK,WAAWA,GAChB,KAAK,MAAM,IAAIA;AAAA,EACjB;AAAA,EAEA,OAAO,IAAIC,GAAYC,GAAoB;AACzC,YAASD,IAAK,QAAU,SAAU,SAAYC,IAAK,QAAU;AAAA,EAC/D;AAAA,EAEA,OAAOC,GAAmB;AACxB,WAAO,KAAK,MAAMA,IAAI,KAAK,GAAG;AAAA,EAChC;AAAA,EAEA,QAAc;AACZ,eAAWC,KAAQ,KAAK,MAAM,OAAA;AAC5B,MAAAA,EAAK,SAAS,GACd,KAAK,MAAM,KAAKA,CAAI;AAEtB,SAAK,MAAM,MAAA;AAAA,EACb;AAAA,EAEA,OAAOC,GAAYC,IAAS,GAAS;AACnC,UAAMC,IAAK,KAAK,OAAOF,EAAK,OAAOC,CAAM,GACnCE,IAAK,KAAK,OAAOH,EAAK,OAAOC,CAAM,GACnCG,IAAK,KAAK,OAAOJ,EAAK,OAAOC,CAAM,GACnCI,IAAK,KAAK,OAAOL,EAAK,OAAOC,CAAM;AACzC,aAASJ,IAAKO,GAAIP,KAAMQ,GAAIR;AAC1B,eAASD,IAAKM,GAAIN,KAAMO,GAAIP,KAAM;AAChC,cAAMU,IAAIZ,EAAY,IAAIE,GAAIC,CAAE;AAChC,YAAIE,IAAO,KAAK,MAAM,IAAIO,CAAC;AAC3B,QAAKP,MACHA,IAAO,KAAK,MAAM,IAAA,KAAS,CAAA,GAC3B,KAAK,MAAM,IAAIO,GAAGP,CAAI,IAExBA,EAAK,KAAKC,CAAI;AAAA,MAChB;AAAA,EAEJ;AAAA;AAAA,EAGA,GAAGJ,GAAYC,GAAyC;AACtD,WAAO,KAAK,MAAM,IAAIH,EAAY,IAAIE,GAAIC,CAAE,CAAC;AAAA,EAC/C;AACF;"}

package/dist/physics/collide.js

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

package/dist/physics/collide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collide.js","sources":["../../src/physics/collide.ts"],"sourcesContent":["import type { Body } from './Body';\nimport { circlePolygon, polygonPolygon } from './collidePolygon';\nimport { FACE_BOTTOM, FACE_LEFT, FACE_RIGHT, FACE_TOP, type BoxShape, type CircleShape } from './types';\n\n/**\n * The result of a narrow-phase test: the normal points from `a` to `b`, `depth` > 0 is overlap, < 0 a gap (the\n * deepest of the points). Up to two contact points, each with its own depth and a feature id that stays the same\n * while the same corners touch, so the solver can carry each point's impulse over from step to step.\n */\nexport interface Manifold {\n  nx: number;\n  ny: number;\n  depth: number;\n  count: number;\n  readonly px: [number, number];\n  readonly py: [number, number];\n  readonly pd: [number, number];\n  readonly id: [number, number];\n}\n\nexport function emptyManifold(): Manifold {\n  return { nx: 0, ny: 0, depth: 0, count: 0, px: [0, 0], py: [0, 0], pd: [0, 0], id: [0, 0] };\n}\n\n/**\n * Narrow phase. Fills `out` and returns true when the two shapes overlap or lie closer than `margin`. The margin\n * keeps a resting contact alive while the solver holds the bodies a hair apart, so a body standing on the ground is\n * grounded on every step instead of flickering between touching and not.\n *\n * Two bodies that never turn and sit square (boxes at no angle, circles) take the axis-aligned tests, which know the\n * internal faces of merged tile boxes; anything turned or turning takes the polygon tests (`collidePolygon.ts`).\n */\nexport function collide(a: Body, b: Body, margin: number, out: Manifold): boolean {\n  const sa = a.shape;\n  const sb = b.shape;\n  if (sa.kind === 'circle' && sb.kind === 'circle') {\n    if (!circleCircle(a, sa, b, sb, margin, out)) return false;\n    onePoint(out, a.x + out.nx * (sa.radius - out.depth / 2), a.y + out.ny * (sa.radius - out.depth / 2));\n    return true;\n  }\n  if (sa.kind === 'circle') {\n    if (!b.axisAligned) return circlePolygon(a, sa.radius, b, margin, true, out);\n    if (!circleBox(a, sa, b, sb as BoxShape, margin, out)) return false;\n    out.nx = -out.nx;\n    out.ny = -out.ny;\n    // the normal now runs from the circle (a) to the box: the circle's surface point is ahead of its centre\n    onePoint(out, a.x + out.nx * (sa.radius - out.depth / 2), a.y + out.ny * (sa.radius - out.depth / 2));\n    return true;\n  }\n  if (sb.kind === 'circle') {\n    if (!a.axisAligned) return circlePolygon(b, sb.radius, a, margin, false, out);\n    if (!circleBox(b, sb, a, sa as BoxShape, margin, out)) return false;\n    // circleBox gives the normal from the box (a) to the circle (b): already a → b\n    onePoint(out, b.x - out.nx * (sb.radius - out.depth / 2), b.y - out.ny * (sb.radius - out.depth / 2));\n    return true;\n  }\n  if (a.axisAligned && b.axisAligned && a.invInertia === 0 && b.invInertia === 0) {\n    if (!boxBox(a, sa as BoxShape, b, sb as BoxShape, margin, out)) return false;\n    // neither turns, so where the point lies changes nothing: the middle of the overlap\n    onePoint(out, (Math.max(a.minX, b.minX) + Math.min(a.maxX, b.maxX)) / 2, (Math.max(a.minY, b.minY) + Math.min(a.maxY, b.maxY)) / 2);\n    return true;\n  }\n  return polygonPolygon(a, b, margin, out);\n}\n\nfunction onePoint(out: Manifold, x: number, y: number): void {\n  out.count = 1;\n  out.px[0] = x;\n  out.py[0] = y;\n  out.pd[0] = out.depth;\n  out.id[0] = 0;\n}\n\n/** The narrow phase's three numbers, for the axis-aligned tests below. */\ninterface Normal {\n  nx: number;\n  ny: number;\n  depth: number;\n}\n\n/** Whether a normal along x (sign sx, from a to b) may be used: not out of a face either box marks as internal. */\nfunction xAllowed(a: Body, b: Body, sx: number): boolean {\n  return sx > 0 ? !(a.internalFaces & FACE_RIGHT) && !(b.internalFaces & FACE_LEFT) : !(a.internalFaces & FACE_LEFT) && !(b.internalFaces & FACE_RIGHT);\n}\n\nfunction yAllowed(a: Body, b: Body, sy: number): boolean {\n  return sy > 0 ? !(a.internalFaces & FACE_BOTTOM) && !(b.internalFaces & FACE_TOP) : !(a.internalFaces & FACE_TOP) && !(b.internalFaces & FACE_BOTTOM);\n}\n\nfunction boxBox(a: Body, sa: BoxShape, b: Body, sb: BoxShape, margin: number, out: Normal): boolean {\n  const dx = b.x - a.x;\n  const dy = b.y - a.y;\n  const px = sa.halfWidth + sb.halfWidth - Math.abs(dx);\n  const py = sa.halfHeight + sb.halfHeight - Math.abs(dy);\n  if (px <= -margin || py <= -margin) return false;\n  // corner to corner across a gap: no face faces the other, and a contact here only snags bodies sliding past\n  if (px < 0 && py < 0) return false;\n  const sx = dx < 0 ? -1 : 1;\n  const sy = dy < 0 ? -1 : 1;\n  let useX: boolean;\n  if (px < 0) useX = true;\n  else if (py < 0) useX = false;\n  else {\n    const okX = xAllowed(a, b, sx);\n    const okY = yAllowed(a, b, sy);\n    useX = okX && okY ? px < py : okX ? true : okY ? false : px < py;\n  }\n  if (useX) {\n    if (px < 0 && !xAllowed(a, b, sx)) return false;\n    out.nx = sx;\n    out.ny = 0;\n    out.depth = px;\n  } else {\n    if (py < 0 && !yAllowed(a, b, sy)) return false;\n    out.nx = 0;\n    out.ny = sy;\n    out.depth = py;\n  }\n  return true;\n}\n\nfunction circleCircle(a: Body, sa: CircleShape, b: Body, sb: CircleShape, margin: number, out: Normal): boolean {\n  const dx = b.x - a.x;\n  const dy = b.y - a.y;\n  const r = sa.radius + sb.radius;\n  const d2 = dx * dx + dy * dy;\n  if (d2 >= (r + margin) * (r + margin)) return false;\n  const d = Math.sqrt(d2);\n  if (d > 1e-9) {\n    out.nx = dx / d;\n    out.ny = dy / d;\n  } else {\n    out.nx = 0;\n    out.ny = 1;\n  }\n  out.depth = r - d;\n  return true;\n}\n\n/**\n * Circle `c` against box `b`; the normal is written from the box to the circle. A face the box marks as internal\n * is never pushed out of, and at a corner beside an internal face the other face's axis is used instead, so a ball\n * rolls over the seam between two ground boxes without a bump.\n */\nfunction circleBox(c: Body, sc: CircleShape, b: Body, sb: BoxShape, margin: number, out: Normal): boolean {\n  const hw = sb.halfWidth;\n  const hh = sb.halfHeight;\n  const r = sc.radius;\n  const dx = c.x - b.x;\n  const dy = c.y - b.y;\n  const faces = b.internalFaces;\n  const sx = dx < 0 ? -1 : 1;\n  const sy = dy < 0 ? -1 : 1;\n  const xFaceOpen = !(faces & (sx > 0 ? FACE_RIGHT : FACE_LEFT));\n  const yFaceOpen = !(faces & (sy > 0 ? FACE_BOTTOM : FACE_TOP));\n  const insideX = Math.abs(dx) <= hw;\n  const insideY = Math.abs(dy) <= hh;\n  if (insideX && insideY) {\n    const penX = hw - Math.abs(dx) + r;\n    const penY = hh - Math.abs(dy) + r;\n    const useX = xFaceOpen && yFaceOpen ? penX < penY : xFaceOpen ? true : yFaceOpen ? false : penX < penY;\n    out.nx = useX ? sx : 0;\n    out.ny = useX ? 0 : sy;\n    out.depth = useX ? penX : penY;\n    return true;\n  }\n  if (insideY) {\n    // beside a vertical face\n    if (!xFaceOpen) return false;\n    const gap = Math.abs(dx) - hw;\n    if (gap >= r + margin) return false;\n    out.nx = sx;\n    out.ny = 0;\n    out.depth = r - gap;\n    return true;\n  }\n  if (insideX) {\n    if (!yFaceOpen) return false;\n    const gap = Math.abs(dy) - hh;\n    if (gap >= r + margin) return false;\n    out.nx = 0;\n    out.ny = sy;\n    out.depth = r - gap;\n    return true;\n  }\n  // a corner region\n  const ex = dx - sx * hw;\n  const ey = dy - sy * hh;\n  if (!xFaceOpen && !yFaceOpen) return false;\n  if (!xFaceOpen || !yFaceOpen) {\n    // the corner belongs to a longer surface: collide with that surface's line, not the corner's point\n    const gap = !xFaceOpen ? Math.abs(ey) : Math.abs(ex);\n    if (gap >= r + margin) return false;\n    out.nx = !xFaceOpen ? 0 : sx;\n    out.ny = !xFaceOpen ? sy : 0;\n    out.depth = r - gap;\n    return true;\n  }\n  const d2 = ex * ex + ey * ey;\n  if (d2 >= (r + margin) * (r + margin)) return false;\n  const d = Math.sqrt(d2);\n  out.nx = d > 1e-9 ? ex / d : sx;\n  out.ny = d > 1e-9 ? ey / d : 0;\n  out.depth = r - d;\n  return true;\n}\n"],"names":["emptyManifold","collide","a","b","margin","out","sa","sb","circleCircle","onePoint","circleBox","circlePolygon","boxBox","polygonPolygon","x","y","xAllowed","sx","FACE_RIGHT","FACE_LEFT","yAllowed","sy","FACE_BOTTOM","FACE_TOP","dx","dy","px","py","useX","okX","okY","r","d2","d","c","sc","hw","hh","faces","xFaceOpen","yFaceOpen","insideX","insideY","penX","penY","gap","ex","ey"],"mappings":"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"}

package/dist/physics/collidePolygon.js

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