@melonjs/matter-adapter 1.0.0

package/build/index.js

@@ -0,0 +1,1173 @@
+/*!
+ * melonJS physics adapter for matter-js - 1.0.0
+ * http://www.melonjs.org
+ * @melonjs/matter-adapter is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2026 Olivier Biot (AltByte Pte Ltd)
+ */
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/poly-decomp@0.3.0/node_modules/poly-decomp/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/.pnpm/poly-decomp@0.3.0/node_modules/poly-decomp/src/index.js"(exports, module) {
+    module.exports = {
+      decomp: polygonDecomp,
+      quickDecomp: polygonQuickDecomp,
+      isSimple: polygonIsSimple,
+      removeCollinearPoints: polygonRemoveCollinearPoints,
+      removeDuplicatePoints: polygonRemoveDuplicatePoints,
+      makeCCW: polygonMakeCCW
+    };
+    function lineInt(l1, l2, precision) {
+      precision = precision || 0;
+      var i = [0, 0];
+      var a1, b1, c1, a2, b2, c2, det;
+      a1 = l1[1][1] - l1[0][1];
+      b1 = l1[0][0] - l1[1][0];
+      c1 = a1 * l1[0][0] + b1 * l1[0][1];
+      a2 = l2[1][1] - l2[0][1];
+      b2 = l2[0][0] - l2[1][0];
+      c2 = a2 * l2[0][0] + b2 * l2[0][1];
+      det = a1 * b2 - a2 * b1;
+      if (!scalar_eq(det, 0, precision)) {
+        i[0] = (b2 * c1 - b1 * c2) / det;
+        i[1] = (a1 * c2 - a2 * c1) / det;
+      }
+      return i;
+    }
+    function lineSegmentsIntersect(p1, p2, q1, q2) {
+      var dx = p2[0] - p1[0];
+      var dy = p2[1] - p1[1];
+      var da = q2[0] - q1[0];
+      var db = q2[1] - q1[1];
+      if (da * dy - db * dx === 0) {
+        return false;
+      }
+      var s = (dx * (q1[1] - p1[1]) + dy * (p1[0] - q1[0])) / (da * dy - db * dx);
+      var t = (da * (p1[1] - q1[1]) + db * (q1[0] - p1[0])) / (db * dx - da * dy);
+      return s >= 0 && s <= 1 && t >= 0 && t <= 1;
+    }
+    function triangleArea(a, b, c) {
+      return (b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1]);
+    }
+    function isLeft(a, b, c) {
+      return triangleArea(a, b, c) > 0;
+    }
+    function isLeftOn(a, b, c) {
+      return triangleArea(a, b, c) >= 0;
+    }
+    function isRight(a, b, c) {
+      return triangleArea(a, b, c) < 0;
+    }
+    function isRightOn(a, b, c) {
+      return triangleArea(a, b, c) <= 0;
+    }
+    var tmpPoint1 = [];
+    var tmpPoint2 = [];
+    function collinear(a, b, c, thresholdAngle) {
+      if (!thresholdAngle) {
+        return triangleArea(a, b, c) === 0;
+      } else {
+        var ab = tmpPoint1, bc = tmpPoint2;
+        ab[0] = b[0] - a[0];
+        ab[1] = b[1] - a[1];
+        bc[0] = c[0] - b[0];
+        bc[1] = c[1] - b[1];
+        var dot = ab[0] * bc[0] + ab[1] * bc[1], magA = Math.sqrt(ab[0] * ab[0] + ab[1] * ab[1]), magB = Math.sqrt(bc[0] * bc[0] + bc[1] * bc[1]), angle = Math.acos(dot / (magA * magB));
+        return angle < thresholdAngle;
+      }
+    }
+    function sqdist(a, b) {
+      var dx = b[0] - a[0];
+      var dy = b[1] - a[1];
+      return dx * dx + dy * dy;
+    }
+    function polygonAt(polygon, i) {
+      var s = polygon.length;
+      return polygon[i < 0 ? i % s + s : i % s];
+    }
+    function polygonClear(polygon) {
+      polygon.length = 0;
+    }
+    function polygonAppend(polygon, poly, from, to) {
+      for (var i = from; i < to; i++) {
+        polygon.push(poly[i]);
+      }
+    }
+    function polygonMakeCCW(polygon) {
+      var br = 0, v = polygon;
+      for (var i = 1; i < polygon.length; ++i) {
+        if (v[i][1] < v[br][1] || v[i][1] === v[br][1] && v[i][0] > v[br][0]) {
+          br = i;
+        }
+      }
+      if (!isLeft(polygonAt(polygon, br - 1), polygonAt(polygon, br), polygonAt(polygon, br + 1))) {
+        polygonReverse(polygon);
+        return true;
+      } else {
+        return false;
+      }
+    }
+    function polygonReverse(polygon) {
+      var tmp = [];
+      var N = polygon.length;
+      for (var i = 0; i !== N; i++) {
+        tmp.push(polygon.pop());
+      }
+      for (var i = 0; i !== N; i++) {
+        polygon[i] = tmp[i];
+      }
+    }
+    function polygonIsReflex(polygon, i) {
+      return isRight(polygonAt(polygon, i - 1), polygonAt(polygon, i), polygonAt(polygon, i + 1));
+    }
+    var tmpLine1 = [];
+    var tmpLine2 = [];
+    function polygonCanSee(polygon, a, b) {
+      var p, dist, l1 = tmpLine1, l2 = tmpLine2;
+      if (isLeftOn(polygonAt(polygon, a + 1), polygonAt(polygon, a), polygonAt(polygon, b)) && isRightOn(polygonAt(polygon, a - 1), polygonAt(polygon, a), polygonAt(polygon, b))) {
+        return false;
+      }
+      dist = sqdist(polygonAt(polygon, a), polygonAt(polygon, b));
+      for (var i = 0; i !== polygon.length; ++i) {
+        if ((i + 1) % polygon.length === a || i === a) {
+          continue;
+        }
+        if (isLeftOn(polygonAt(polygon, a), polygonAt(polygon, b), polygonAt(polygon, i + 1)) && isRightOn(polygonAt(polygon, a), polygonAt(polygon, b), polygonAt(polygon, i))) {
+          l1[0] = polygonAt(polygon, a);
+          l1[1] = polygonAt(polygon, b);
+          l2[0] = polygonAt(polygon, i);
+          l2[1] = polygonAt(polygon, i + 1);
+          p = lineInt(l1, l2);
+          if (sqdist(polygonAt(polygon, a), p) < dist) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
+    function polygonCanSee2(polygon, a, b) {
+      for (var i = 0; i !== polygon.length; ++i) {
+        if (i === a || i === b || (i + 1) % polygon.length === a || (i + 1) % polygon.length === b) {
+          continue;
+        }
+        if (lineSegmentsIntersect(polygonAt(polygon, a), polygonAt(polygon, b), polygonAt(polygon, i), polygonAt(polygon, i + 1))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function polygonCopy(polygon, i, j, targetPoly) {
+      var p = targetPoly || [];
+      polygonClear(p);
+      if (i < j) {
+        for (var k = i; k <= j; k++) {
+          p.push(polygon[k]);
+        }
+      } else {
+        for (var k = 0; k <= j; k++) {
+          p.push(polygon[k]);
+        }
+        for (var k = i; k < polygon.length; k++) {
+          p.push(polygon[k]);
+        }
+      }
+      return p;
+    }
+    function polygonGetCutEdges(polygon) {
+      var min = [], tmp1 = [], tmp2 = [], tmpPoly = [];
+      var nDiags = Number.MAX_VALUE;
+      for (var i = 0; i < polygon.length; ++i) {
+        if (polygonIsReflex(polygon, i)) {
+          for (var j = 0; j < polygon.length; ++j) {
+            if (polygonCanSee(polygon, i, j)) {
+              tmp1 = polygonGetCutEdges(polygonCopy(polygon, i, j, tmpPoly));
+              tmp2 = polygonGetCutEdges(polygonCopy(polygon, j, i, tmpPoly));
+              for (var k = 0; k < tmp2.length; k++) {
+                tmp1.push(tmp2[k]);
+              }
+              if (tmp1.length < nDiags) {
+                min = tmp1;
+                nDiags = tmp1.length;
+                min.push([polygonAt(polygon, i), polygonAt(polygon, j)]);
+              }
+            }
+          }
+        }
+      }
+      return min;
+    }
+    function polygonDecomp(polygon) {
+      var edges = polygonGetCutEdges(polygon);
+      if (edges.length > 0) {
+        return polygonSlice(polygon, edges);
+      } else {
+        return [polygon];
+      }
+    }
+    function polygonSlice(polygon, cutEdges) {
+      if (cutEdges.length === 0) {
+        return [polygon];
+      }
+      if (cutEdges instanceof Array && cutEdges.length && cutEdges[0] instanceof Array && cutEdges[0].length === 2 && cutEdges[0][0] instanceof Array) {
+        var polys = [polygon];
+        for (var i = 0; i < cutEdges.length; i++) {
+          var cutEdge = cutEdges[i];
+          for (var j = 0; j < polys.length; j++) {
+            var poly = polys[j];
+            var result = polygonSlice(poly, cutEdge);
+            if (result) {
+              polys.splice(j, 1);
+              polys.push(result[0], result[1]);
+              break;
+            }
+          }
+        }
+        return polys;
+      } else {
+        var cutEdge = cutEdges;
+        var i = polygon.indexOf(cutEdge[0]);
+        var j = polygon.indexOf(cutEdge[1]);
+        if (i !== -1 && j !== -1) {
+          return [
+            polygonCopy(polygon, i, j),
+            polygonCopy(polygon, j, i)
+          ];
+        } else {
+          return false;
+        }
+      }
+    }
+    function polygonIsSimple(polygon) {
+      var path = polygon, i;
+      for (i = 0; i < path.length - 1; i++) {
+        for (var j = 0; j < i - 1; j++) {
+          if (lineSegmentsIntersect(path[i], path[i + 1], path[j], path[j + 1])) {
+            return false;
+          }
+        }
+      }
+      for (i = 1; i < path.length - 2; i++) {
+        if (lineSegmentsIntersect(path[0], path[path.length - 1], path[i], path[i + 1])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function getIntersectionPoint(p1, p2, q1, q2, delta) {
+      delta = delta || 0;
+      var a1 = p2[1] - p1[1];
+      var b1 = p1[0] - p2[0];
+      var c1 = a1 * p1[0] + b1 * p1[1];
+      var a2 = q2[1] - q1[1];
+      var b2 = q1[0] - q2[0];
+      var c2 = a2 * q1[0] + b2 * q1[1];
+      var det = a1 * b2 - a2 * b1;
+      if (!scalar_eq(det, 0, delta)) {
+        return [(b2 * c1 - b1 * c2) / det, (a1 * c2 - a2 * c1) / det];
+      } else {
+        return [0, 0];
+      }
+    }
+    function polygonQuickDecomp(polygon, result, reflexVertices, steinerPoints, delta, maxlevel, level) {
+      maxlevel = maxlevel || 100;
+      level = level || 0;
+      delta = delta || 25;
+      result = typeof result !== "undefined" ? result : [];
+      reflexVertices = reflexVertices || [];
+      steinerPoints = steinerPoints || [];
+      var upperInt = [0, 0], lowerInt = [0, 0], p = [0, 0];
+      var upperDist = 0, lowerDist = 0, d = 0, closestDist = 0;
+      var upperIndex = 0, lowerIndex = 0, closestIndex = 0;
+      var lowerPoly = [], upperPoly = [];
+      var poly = polygon, v = polygon;
+      if (v.length < 3) {
+        return result;
+      }
+      level++;
+      if (level > maxlevel) {
+        console.warn("quickDecomp: max level (" + maxlevel + ") reached.");
+        return result;
+      }
+      for (var i = 0; i < polygon.length; ++i) {
+        if (polygonIsReflex(poly, i)) {
+          reflexVertices.push(poly[i]);
+          upperDist = lowerDist = Number.MAX_VALUE;
+          for (var j = 0; j < polygon.length; ++j) {
+            if (isLeft(polygonAt(poly, i - 1), polygonAt(poly, i), polygonAt(poly, j)) && isRightOn(polygonAt(poly, i - 1), polygonAt(poly, i), polygonAt(poly, j - 1))) {
+              p = getIntersectionPoint(polygonAt(poly, i - 1), polygonAt(poly, i), polygonAt(poly, j), polygonAt(poly, j - 1));
+              if (isRight(polygonAt(poly, i + 1), polygonAt(poly, i), p)) {
+                d = sqdist(poly[i], p);
+                if (d < lowerDist) {
+                  lowerDist = d;
+                  lowerInt = p;
+                  lowerIndex = j;
+                }
+              }
+            }
+            if (isLeft(polygonAt(poly, i + 1), polygonAt(poly, i), polygonAt(poly, j + 1)) && isRightOn(polygonAt(poly, i + 1), polygonAt(poly, i), polygonAt(poly, j))) {
+              p = getIntersectionPoint(polygonAt(poly, i + 1), polygonAt(poly, i), polygonAt(poly, j), polygonAt(poly, j + 1));
+              if (isLeft(polygonAt(poly, i - 1), polygonAt(poly, i), p)) {
+                d = sqdist(poly[i], p);
+                if (d < upperDist) {
+                  upperDist = d;
+                  upperInt = p;
+                  upperIndex = j;
+                }
+              }
+            }
+          }
+          if (lowerIndex === (upperIndex + 1) % polygon.length) {
+            p[0] = (lowerInt[0] + upperInt[0]) / 2;
+            p[1] = (lowerInt[1] + upperInt[1]) / 2;
+            steinerPoints.push(p);
+            if (i < upperIndex) {
+              polygonAppend(lowerPoly, poly, i, upperIndex + 1);
+              lowerPoly.push(p);
+              upperPoly.push(p);
+              if (lowerIndex !== 0) {
+                polygonAppend(upperPoly, poly, lowerIndex, poly.length);
+              }
+              polygonAppend(upperPoly, poly, 0, i + 1);
+            } else {
+              if (i !== 0) {
+                polygonAppend(lowerPoly, poly, i, poly.length);
+              }
+              polygonAppend(lowerPoly, poly, 0, upperIndex + 1);
+              lowerPoly.push(p);
+              upperPoly.push(p);
+              polygonAppend(upperPoly, poly, lowerIndex, i + 1);
+            }
+          } else {
+            if (lowerIndex > upperIndex) {
+              upperIndex += polygon.length;
+            }
+            closestDist = Number.MAX_VALUE;
+            if (upperIndex < lowerIndex) {
+              return result;
+            }
+            for (var j = lowerIndex; j <= upperIndex; ++j) {
+              if (isLeftOn(polygonAt(poly, i - 1), polygonAt(poly, i), polygonAt(poly, j)) && isRightOn(polygonAt(poly, i + 1), polygonAt(poly, i), polygonAt(poly, j))) {
+                d = sqdist(polygonAt(poly, i), polygonAt(poly, j));
+                if (d < closestDist && polygonCanSee2(poly, i, j)) {
+                  closestDist = d;
+                  closestIndex = j % polygon.length;
+                }
+              }
+            }
+            if (i < closestIndex) {
+              polygonAppend(lowerPoly, poly, i, closestIndex + 1);
+              if (closestIndex !== 0) {
+                polygonAppend(upperPoly, poly, closestIndex, v.length);
+              }
+              polygonAppend(upperPoly, poly, 0, i + 1);
+            } else {
+              if (i !== 0) {
+                polygonAppend(lowerPoly, poly, i, v.length);
+              }
+              polygonAppend(lowerPoly, poly, 0, closestIndex + 1);
+              polygonAppend(upperPoly, poly, closestIndex, i + 1);
+            }
+          }
+          if (lowerPoly.length < upperPoly.length) {
+            polygonQuickDecomp(lowerPoly, result, reflexVertices, steinerPoints, delta, maxlevel, level);
+            polygonQuickDecomp(upperPoly, result, reflexVertices, steinerPoints, delta, maxlevel, level);
+          } else {
+            polygonQuickDecomp(upperPoly, result, reflexVertices, steinerPoints, delta, maxlevel, level);
+            polygonQuickDecomp(lowerPoly, result, reflexVertices, steinerPoints, delta, maxlevel, level);
+          }
+          return result;
+        }
+      }
+      result.push(polygon);
+      return result;
+    }
+    function polygonRemoveCollinearPoints(polygon, precision) {
+      var num = 0;
+      for (var i = polygon.length - 1; polygon.length > 3 && i >= 0; --i) {
+        if (collinear(polygonAt(polygon, i - 1), polygonAt(polygon, i), polygonAt(polygon, i + 1), precision)) {
+          polygon.splice(i % polygon.length, 1);
+          num++;
+        }
+      }
+      return num;
+    }
+    function polygonRemoveDuplicatePoints(polygon, precision) {
+      for (var i = polygon.length - 1; i >= 1; --i) {
+        var pi = polygon[i];
+        for (var j = i - 1; j >= 0; --j) {
+          if (points_eq(pi, polygon[j], precision)) {
+            polygon.splice(i, 1);
+            continue;
+          }
+        }
+      }
+    }
+    function scalar_eq(a, b, precision) {
+      precision = precision || 0;
+      return Math.abs(a - b) <= precision;
+    }
+    function points_eq(a, b, precision) {
+      return scalar_eq(a[0], b[0], precision) && scalar_eq(a[1], b[1], precision);
+    }
+  }
+});
+
+// src/index.ts
+var decomp = __toESM(require_src(), 1);
+import * as Matter from "matter-js";
+import {
+  Ellipse,
+  version as melonjsVersion,
+  Polygon,
+  Rect,
+  state,
+  utils,
+  Vector2d
+} from "melonjs";
+Matter.Common.setDecomp(decomp);
+var REQUIRED_MELONJS_VERSION = "19.5.0";
+var MatterAdapter = class {
+  physicLabel = "matter";
+  name = "@melonjs/matter-adapter";
+  version = "1.0.0";
+  url = "https://www.npmjs.com/package/@melonjs/matter-adapter";
+  capabilities = {
+    constraints: true,
+    continuousCollisionDetection: true,
+    sleepingBodies: true,
+    raycasts: true,
+    velocityLimit: true,
+    isGrounded: true
+  };
+  gravity;
+  /**
+   * Raw matter-js namespace — escape hatch for matter-specific features
+   * the portable `PhysicsAdapter` interface doesn't cover (constraints,
+   * compound bodies, events on the Matter engine, queries, etc.).
+   *
+   * Saves you from adding a transitive `import * as Matter from "matter-js"`
+   * just to reach the factories you need. The Matter modules are accessed
+   * by the same names matter's own docs use, so examples from the
+   * matter-js docs copy-paste without renaming:
+   *
+   * ```ts
+   * const spring = adapter.matter.Constraint.create({
+   *   bodyA: a.body, bodyB: b.body, stiffness: 0.04, length: 80,
+   * });
+   * adapter.matter.Composite.add(adapter.engine.world, spring);
+   * ```
+   *
+   * Game code that touches `adapter.matter.*` is matter-only — it will
+   * not work under any other physics adapter. Use the
+   * `PhysicsAdapter` methods for anything that should stay portable.
+   * @see {@link https://brm.io/matter-js/docs/ Official matter-js documentation}
+   * for the full module reference (`Matter.Constraint`, `Matter.Composite`,
+   * `Matter.Bodies`, `Matter.Events`, `Matter.Query`, `Matter.Vector`, …).
+   */
+  matter = Matter;
+  /** the underlying Matter engine; exposed for advanced use cases. */
+  engine;
+  /** back-reference to the owning melonJS world (set in {@link init}). */
+  world;
+  /** renderable → its matter-js body */
+  bodyMap = /* @__PURE__ */ new Map();
+  /** matter-js body → its renderable (for collision / sync) */
+  renderableMap = /* @__PURE__ */ new Map();
+  /** per-body velocity cap (Matter has no native equivalent) */
+  velocityLimits = /* @__PURE__ */ new Map();
+  /** per-body bodyDef hash kept for shape introspection / removeBody */
+  defMap = /* @__PURE__ */ new Map();
+  /**
+   * Per-body gravity multiplier. matter-js 0.20 doesn't honor a
+   * body-level gravityScale, so we emulate it by applying a counter-
+   * force each step (see {@link init} `beforeUpdate`). Only stored for
+   * bodies with scale ≠ 1; the default-1 case is the hot path and we
+   * skip the map lookup entirely for it.
+   */
+  bodyGravityScale = /* @__PURE__ */ new Map();
+  /**
+   * Offset between `renderable.pos` (top-left in melonJS convention)
+   * and `Matter.Body.position` (centroid in Matter's convention). Stored
+   * at addBody time so syncFromPhysics can place the sprite correctly.
+   */
+  posOffsets = /* @__PURE__ */ new Map();
+  matterOptions;
+  subSteps;
+  constructor(options = {}) {
+    if (utils.checkVersion(REQUIRED_MELONJS_VERSION, melonjsVersion) > 0) {
+      throw new Error(
+        `@melonjs/matter-adapter requires melonJS >= ${REQUIRED_MELONJS_VERSION}, but the loaded melonJS is ${melonjsVersion}.`
+      );
+    }
+    this.matterOptions = options.matterEngineOptions;
+    this.subSteps = Math.max(1, Math.floor(options.subSteps ?? 1));
+    const g = options.gravity ?? { x: 0, y: 1 };
+    this.gravity = new Vector2d(g.x, g.y);
+  }
+  /**
+   * Stored references to the listeners registered in {@link init}, so
+   * {@link destroy} can `Matter.Events.off` them. Without these stored
+   * refs, a destroy/re-init cycle would leak the old listeners and
+   * dispatch every event twice on the second cycle.
+   */
+  _matterListeners = [];
+  init(world) {
+    this.world = world;
+    this.engine = Matter.Engine.create(this.matterOptions);
+    this.engine.gravity.x = this.gravity.x;
+    this.engine.gravity.y = this.gravity.y;
+    const on = (name, fn) => {
+      Matter.Events.on(
+        this.engine,
+        name,
+        fn
+      );
+      this._matterListeners.push({ name, fn });
+    };
+    on("beforeUpdate", () => {
+      if (this.bodyGravityScale.size === 0) return;
+      const gx = this.engine.gravity.x;
+      const gy = this.engine.gravity.y;
+      const gs = this.engine.gravity.scale ?? 1e-3;
+      for (const [body, scale] of this.bodyGravityScale) {
+        if (body.isStatic || body.isSleeping) continue;
+        const k = (scale - 1) * body.mass * gs;
+        body.force.x += k * gx;
+        body.force.y += k * gy;
+      }
+    });
+    on("afterUpdate", () => {
+      this._clampVelocities();
+      this.syncFromPhysics();
+    });
+    on("collisionStart", (e) => {
+      this._dispatchCollisions(e.pairs, "start");
+    });
+    on("collisionActive", (e) => {
+      this._dispatchCollisions(e.pairs, "active");
+    });
+    on("collisionEnd", (e) => {
+      this._dispatchCollisions(e.pairs, "end");
+    });
+  }
+  destroy() {
+    for (const { name, fn } of this._matterListeners) {
+      Matter.Events.off(
+        this.engine,
+        name,
+        fn
+      );
+    }
+    this._matterListeners = [];
+    Matter.Composite.clear(this.engine.world, false, true);
+    Matter.Engine.clear(this.engine);
+    this.bodyMap.clear();
+    this.renderableMap.clear();
+    this.velocityLimits.clear();
+    this.defMap.clear();
+    this.bodyGravityScale.clear();
+    this.posOffsets.clear();
+  }
+  step(dt) {
+    if (state.isPaused()) {
+      return;
+    }
+    this.engine.gravity.x = this.gravity.x;
+    this.engine.gravity.y = this.gravity.y;
+    if (this.subSteps === 1) {
+      Matter.Engine.update(this.engine, dt);
+    } else {
+      const sub = dt / this.subSteps;
+      for (let i = 0; i < this.subSteps; i++) {
+        Matter.Engine.update(this.engine, sub);
+      }
+    }
+  }
+  syncFromPhysics() {
+    for (const [body, renderable] of this.renderableMap) {
+      if (!renderable.pos) {
+        continue;
+      }
+      const off = this.posOffsets.get(renderable);
+      if (off) {
+        renderable.pos.x = body.position.x + off.x;
+        renderable.pos.y = body.position.y + off.y;
+      } else {
+        renderable.pos.x = body.position.x;
+        renderable.pos.y = body.position.y;
+      }
+      const t = renderable.currentTransform;
+      const off2 = this.posOffsets.get(renderable);
+      const cx = off2 ? -off2.x : 0;
+      const cy = off2 ? -off2.y : 0;
+      t.identity();
+      if (cx !== 0 || cy !== 0) {
+        t.translate(cx, cy);
+        t.rotate(body.angle);
+        t.translate(-cx, -cy);
+      } else {
+        t.rotate(body.angle);
+      }
+    }
+  }
+  addBody(renderable, def) {
+    const baseX = renderable.pos.x;
+    const baseY = renderable.pos.y;
+    const parts = def.shapes.map((s) => this._shapeToMatter(s, baseX, baseY));
+    let body;
+    if (parts.length === 1) {
+      body = parts[0];
+    } else {
+      body = Matter.Body.create({ parts });
+    }
+    if (def.type === "static") {
+      Matter.Body.setStatic(body, true);
+    }
+    if (typeof def.density === "number") {
+      Matter.Body.setDensity(body, def.density);
+    }
+    if (def.frictionAir !== void 0) {
+      body.frictionAir = typeof def.frictionAir === "number" ? def.frictionAir : (def.frictionAir.x + def.frictionAir.y) / 2;
+    }
+    if (typeof def.restitution === "number") {
+      body.restitution = def.restitution;
+    }
+    if (typeof def.friction === "number") {
+      body.friction = def.friction;
+    }
+    if (typeof def.gravityScale === "number" && def.gravityScale !== 1) {
+      this.bodyGravityScale.set(body, def.gravityScale);
+    }
+    if (def.maxVelocity) {
+      this.velocityLimits.set(renderable, {
+        x: def.maxVelocity.x,
+        y: def.maxVelocity.y
+      });
+    }
+    Object.defineProperties(body, {
+      collisionType: {
+        get() {
+          return this.collisionFilter.category;
+        },
+        set(v) {
+          this.collisionFilter.category = v;
+        },
+        configurable: true,
+        enumerable: true
+      },
+      collisionMask: {
+        get() {
+          return this.collisionFilter.mask;
+        },
+        set(v) {
+          this.collisionFilter.mask = v;
+        },
+        configurable: true,
+        enumerable: true
+      }
+    });
+    if (typeof def.collisionType === "number") {
+      body.collisionFilter.category = def.collisionType;
+    }
+    if (typeof def.collisionMask === "number") {
+      body.collisionFilter.mask = def.collisionMask;
+    }
+    if (def.isSensor) {
+      body.isSensor = true;
+    }
+    if (def.fixedRotation !== false) {
+      Matter.Body.setInertia(body, Number.POSITIVE_INFINITY);
+    }
+    Matter.Composite.add(this.engine.world, body);
+    this.bodyMap.set(renderable, body);
+    this.renderableMap.set(body, renderable);
+    this.defMap.set(renderable, def);
+    this.posOffsets.set(renderable, {
+      x: baseX - body.position.x,
+      y: baseY - body.position.y
+    });
+    const helpers = {
+      setVelocity(x, y) {
+        Matter.Body.setVelocity(body, { x, y });
+      },
+      getVelocity(out) {
+        return (out ?? new Vector2d()).set(body.velocity.x, body.velocity.y);
+      },
+      applyForce(x, y, pointX, pointY) {
+        const point = typeof pointX === "number" && typeof pointY === "number" ? { x: pointX, y: pointY } : body.position;
+        Matter.Body.applyForce(body, point, { x, y });
+      },
+      applyImpulse(x, y) {
+        const invMass = body.mass > 0 ? 1 / body.mass : 0;
+        Matter.Body.setVelocity(body, {
+          x: body.velocity.x + x * invMass,
+          y: body.velocity.y + y * invMass
+        });
+      },
+      setSensor(isSensor = true) {
+        body.isSensor = isSensor;
+      },
+      setStatic(isStatic = true) {
+        Matter.Body.setStatic(body, isStatic);
+      },
+      setCollisionMask(mask) {
+        body.collisionFilter.mask = mask;
+      },
+      setCollisionType(type) {
+        body.collisionFilter.category = type;
+      },
+      setMass: (m) => {
+        Matter.Body.setMass(body, m);
+      },
+      setBounce(r) {
+        body.restitution = r;
+      },
+      setGravityScale: (scale) => {
+        if (scale === 1) {
+          this.bodyGravityScale.delete(body);
+        } else {
+          this.bodyGravityScale.set(body, scale);
+        }
+      },
+      setAngularVelocity(omega) {
+        Matter.Body.setAngularVelocity(body, omega);
+      },
+      getAngularVelocity() {
+        return body.angularVelocity;
+      },
+      setAngle(rad) {
+        Matter.Body.setAngle(body, rad);
+      },
+      getAngle() {
+        return body.angle;
+      },
+      applyTorque(t) {
+        body.torque += t;
+      }
+    };
+    Object.assign(body, helpers);
+    const adapterBody = body;
+    renderable.body = adapterBody;
+    return adapterBody;
+  }
+  removeBody(renderable) {
+    const body = this.bodyMap.get(renderable);
+    if (body) {
+      Matter.Composite.remove(this.engine.world, body);
+      this.bodyMap.delete(renderable);
+      this.renderableMap.delete(body);
+      this.velocityLimits.delete(renderable);
+      this.defMap.delete(renderable);
+      this.posOffsets.delete(renderable);
+      this.bodyGravityScale.delete(body);
+    }
+  }
+  updateShape(renderable, shapes) {
+    const oldDef = this.defMap.get(renderable);
+    if (!oldDef) {
+      return;
+    }
+    const oldBody = this.bodyMap.get(renderable);
+    const savedVel = oldBody ? { x: oldBody.velocity.x, y: oldBody.velocity.y } : void 0;
+    const savedAngVel = oldBody?.angularVelocity ?? 0;
+    this.removeBody(renderable);
+    const newBody = this.addBody(renderable, { ...oldDef, shapes });
+    if (savedVel) {
+      Matter.Body.setVelocity(newBody, savedVel);
+      Matter.Body.setAngularVelocity(newBody, savedAngVel);
+    }
+  }
+  getVelocity(renderable, out) {
+    const body = this.bodyMap.get(renderable);
+    const target = out ?? new Vector2d();
+    if (body) {
+      return target.set(body.velocity.x, body.velocity.y);
+    }
+    return target.set(0, 0);
+  }
+  setVelocity(renderable, v) {
+    const body = this.bodyMap.get(renderable);
+    if (body) {
+      Matter.Body.setVelocity(body, { x: v.x, y: v.y });
+    }
+  }
+  applyForce(renderable, force, point) {
+    const body = this.bodyMap.get(renderable);
+    if (!body) return;
+    Matter.Body.applyForce(body, point ?? body.position, {
+      x: force.x,
+      y: force.y
+    });
+  }
+  applyImpulse(renderable, impulse) {
+    const body = this.bodyMap.get(renderable);
+    if (!body) return;
+    const invMass = body.mass > 0 ? 1 / body.mass : 0;
+    Matter.Body.setVelocity(body, {
+      x: body.velocity.x + impulse.x * invMass,
+      y: body.velocity.y + impulse.y * invMass
+    });
+  }
+  setPosition(renderable, p) {
+    const body = this.bodyMap.get(renderable);
+    if (body) {
+      const off = this.posOffsets.get(renderable);
+      Matter.Body.setPosition(body, {
+        x: p.x - (off?.x ?? 0),
+        y: p.y - (off?.y ?? 0)
+      });
+      this.invalidateContactsFor(body);
+    }
+    renderable.pos.x = p.x;
+    renderable.pos.y = p.y;
+  }
+  invalidateContactsFor(body) {
+    const impulse = body.positionImpulse;
+    impulse.x = 0;
+    impulse.y = 0;
+  }
+  setAngle(renderable, angle) {
+    const body = this.bodyMap.get(renderable);
+    if (body) {
+      Matter.Body.setAngle(body, angle);
+    }
+  }
+  getAngle(renderable) {
+    const body = this.bodyMap.get(renderable);
+    return body ? body.angle : 0;
+  }
+  setAngularVelocity(renderable, omega) {
+    const body = this.bodyMap.get(renderable);
+    if (body) {
+      Matter.Body.setAngularVelocity(body, omega);
+    }
+  }
+  getAngularVelocity(renderable) {
+    const body = this.bodyMap.get(renderable);
+    return body ? body.angularVelocity : 0;
+  }
+  applyTorque(renderable, torque) {
+    const body = this.bodyMap.get(renderable);
+    if (body) {
+      body.torque += torque;
+    }
+  }
+  setStatic(renderable, isStatic) {
+    const body = this.bodyMap.get(renderable);
+    if (body) {
+      Matter.Body.setStatic(body, isStatic);
+    }
+  }
+  setGravityScale(renderable, scale) {
+    const body = this.bodyMap.get(renderable);
+    if (!body) return;
+    if (scale === 1) {
+      this.bodyGravityScale.delete(body);
+    } else {
+      this.bodyGravityScale.set(body, scale);
+    }
+  }
+  setSensor(renderable, isSensor) {
+    const body = this.bodyMap.get(renderable);
+    if (body) {
+      body.isSensor = isSensor;
+    }
+  }
+  setFrictionAir(renderable, friction) {
+    const body = this.bodyMap.get(renderable);
+    if (body) {
+      body.frictionAir = typeof friction === "number" ? friction : (friction.x + friction.y) / 2;
+    }
+  }
+  setMaxVelocity(renderable, limit) {
+    this.velocityLimits.set(renderable, { x: limit.x, y: limit.y });
+  }
+  getMaxVelocity(renderable) {
+    return this.velocityLimits.get(renderable) ?? { x: 0, y: 0 };
+  }
+  setCollisionType(renderable, type) {
+    const body = this.bodyMap.get(renderable);
+    if (body) {
+      body.collisionFilter.category = type;
+    }
+  }
+  setCollisionMask(renderable, mask) {
+    const body = this.bodyMap.get(renderable);
+    if (body) {
+      body.collisionFilter.mask = mask;
+    }
+  }
+  /**
+   * Adapter-side debug surface: the body's AABB in renderable-local
+   * coordinates. Matter tracks `body.bounds` in WORLD space; we
+   * subtract `renderable.pos` so the result matches melonJS's local-
+   * space convention (the debug plugin translates to the renderable
+   * origin before drawing, and would otherwise see the bounds drawn
+   * offset by the renderable's world position).
+   * @param renderable - the renderable whose body bounds to read
+   * @param out - destination `Bounds` (filled in place, also returned)
+   */
+  getBodyAABB(renderable, out) {
+    const body = this.bodyMap.get(renderable);
+    if (!body) return void 0;
+    const b = body.bounds;
+    const rp = renderable.pos;
+    out.setMinMax(
+      b.min.x - rp.x,
+      b.min.y - rp.y,
+      b.max.x - rp.x,
+      b.max.y - rp.y
+    );
+    return out;
+  }
+  /**
+   * Adapter-side debug surface: the body's collision shapes in
+   * renderable-local coordinates. We return the original `def.shapes`
+   * array — those are the input shape definitions in local space,
+   * unchanged by matter's body transformation (rotation is baked into
+   * matter's vertices, not into our local-space defs). Read-only.
+   * @param renderable - the renderable whose body shapes to read
+   */
+  getBodyShapes(renderable) {
+    return this.defMap.get(renderable)?.shapes ?? [];
+  }
+  isGrounded(renderable) {
+    const body = this.bodyMap.get(renderable);
+    if (!body) return false;
+    for (const pair of this.engine.pairs.list) {
+      if (!pair.isActive) continue;
+      const isA = pair.bodyA === body;
+      const isB = pair.bodyB === body;
+      if (!isA && !isB) continue;
+      const other = isA ? pair.bodyB : pair.bodyA;
+      if (other.position.y > body.position.y) {
+        return true;
+      }
+    }
+    return false;
+  }
+  raycast(from, to) {
+    const dx = to.x - from.x;
+    const dy = to.y - from.y;
+    if (Math.abs(dx) < 1e-9 && Math.abs(dy) < 1e-9) return null;
+    const bodies = Matter.Composite.allBodies(this.engine.world);
+    const collisions = Matter.Query.ray(bodies, from, to);
+    if (collisions.length === 0) return null;
+    let bestT = Infinity;
+    let bestEdgeX = 0;
+    let bestEdgeY = 0;
+    let bestBody = null;
+    for (const collision of collisions) {
+      const candidate = collision.bodyA;
+      const parts = candidate.parts;
+      const startIdx = parts.length > 1 ? 1 : 0;
+      for (let p = startIdx; p < parts.length; p++) {
+        const vertices = parts[p].vertices;
+        const vlen = vertices.length;
+        for (let i = 0; i < vlen; i++) {
+          const a = vertices[i];
+          const b = vertices[i + 1 === vlen ? 0 : i + 1];
+          const ex = b.x - a.x;
+          const ey = b.y - a.y;
+          const denom = dx * ey - dy * ex;
+          if (denom > -1e-9 && denom < 1e-9) continue;
+          const fx = a.x - from.x;
+          const fy = a.y - from.y;
+          const t = (fx * ey - fy * ex) / denom;
+          if (t < 0 || t > 1 || t >= bestT) continue;
+          const s = (fx * dy - fy * dx) / denom;
+          if (s < 0 || s > 1) continue;
+          bestT = t;
+          bestEdgeX = ex;
+          bestEdgeY = ey;
+          bestBody = candidate;
+        }
+      }
+    }
+    if (bestBody === null) return null;
+    const renderable = this.renderableMap.get(bestBody);
+    if (!renderable) return null;
+    let nx = bestEdgeY;
+    let ny = -bestEdgeX;
+    const nLen = Math.sqrt(nx * nx + ny * ny);
+    if (nLen > 0) {
+      nx /= nLen;
+      ny /= nLen;
+    }
+    if (nx * dx + ny * dy > 0) {
+      nx = -nx;
+      ny = -ny;
+    }
+    return {
+      renderable,
+      point: new Vector2d(from.x + dx * bestT, from.y + dy * bestT),
+      normal: new Vector2d(nx, ny),
+      fraction: bestT
+    };
+  }
+  queryAABB(rect) {
+    const bodies = Matter.Composite.allBodies(this.engine.world);
+    const matched = Matter.Query.region(bodies, {
+      min: { x: rect.pos.x, y: rect.pos.y },
+      max: { x: rect.pos.x + rect.width, y: rect.pos.y + rect.height }
+    });
+    const result = [];
+    for (const b of matched) {
+      const r = this.renderableMap.get(b);
+      if (r) result.push(r);
+    }
+    return result;
+  }
+  // ---------------------------------------------------------------------
+  // Internal helpers
+  // ---------------------------------------------------------------------
+  _clampVelocities() {
+    for (const [renderable, limit] of this.velocityLimits) {
+      const body = this.bodyMap.get(renderable);
+      if (!body) continue;
+      const vx = Math.max(-limit.x, Math.min(limit.x, body.velocity.x));
+      const vy = Math.max(-limit.y, Math.min(limit.y, body.velocity.y));
+      if (vx !== body.velocity.x || vy !== body.velocity.y) {
+        Matter.Body.setVelocity(body, { x: vx, y: vy });
+      }
+    }
+  }
+  _dispatchCollisions(pairs, phase) {
+    const methodForSide = (receiver) => {
+      if (phase === "start") return "onCollisionStart";
+      if (phase === "end") return "onCollisionEnd";
+      return typeof receiver.onCollisionActive === "function" ? "onCollisionActive" : "onCollision";
+    };
+    for (const pair of pairs) {
+      const rA = this.renderableMap.get(pair.bodyA);
+      const rB = this.renderableMap.get(pair.bodyB);
+      if (!rA || !rB) continue;
+      const ancA = rA.ancestor;
+      const ancB = rB.ancestor;
+      const aDetached = ancA === null;
+      const bDetached = ancB === null;
+      if (phase === "end") {
+        if (aDetached && bDetached) continue;
+      } else if (aDetached || bDetached) {
+        continue;
+      }
+      const collision = pair.collision;
+      const depth = collision.depth;
+      const normal = collision.normal;
+      const responseAB = {
+        a: rA,
+        b: rB,
+        normal: { x: normal.x, y: normal.y },
+        depth,
+        pair
+      };
+      const responseBA = {
+        a: rB,
+        b: rA,
+        normal: { x: -normal.x, y: -normal.y },
+        depth,
+        pair
+      };
+      if (!aDetached) {
+        const mA = methodForSide(rA);
+        const fnA = rA[mA];
+        if (typeof fnA === "function") {
+          fnA.call(
+            rA,
+            responseAB,
+            rB
+          );
+        }
+      }
+      if (!bDetached) {
+        const mB = methodForSide(rB);
+        const fnB = rB[mB];
+        if (typeof fnB === "function") {
+          fnB.call(
+            rB,
+            responseBA,
+            rA
+          );
+        }
+      }
+    }
+  }
+  _shapeToMatter(shape, baseX, baseY) {
+    if (shape instanceof Rect) {
+      const w = shape.width;
+      const h = shape.height;
+      return Matter.Bodies.rectangle(
+        baseX + shape.pos.x + w / 2,
+        baseY + shape.pos.y + h / 2,
+        w,
+        h
+      );
+    }
+    if (shape instanceof Ellipse) {
+      const radius = (shape.radiusV.x + shape.radiusV.y) / 2;
+      return Matter.Bodies.circle(
+        baseX + shape.pos.x,
+        baseY + shape.pos.y,
+        radius
+      );
+    }
+    if (shape instanceof Polygon) {
+      const points = shape.points.map((p) => ({
+        x: baseX + shape.pos.x + p.x,
+        y: baseY + shape.pos.y + p.y
+      }));
+      const cx = points.reduce((s, p) => s + p.x, 0) / Math.max(1, points.length);
+      const cy = points.reduce((s, p) => s + p.y, 0) / Math.max(1, points.length);
+      const body = Matter.Bodies.fromVertices(cx, cy, [points]);
+      if (body) {
+        return body;
+      }
+      let minX = Number.POSITIVE_INFINITY;
+      let minY = Number.POSITIVE_INFINITY;
+      let maxX = Number.NEGATIVE_INFINITY;
+      let maxY = Number.NEGATIVE_INFINITY;
+      for (const p of points) {
+        if (p.x < minX) minX = p.x;
+        if (p.y < minY) minY = p.y;
+        if (p.x > maxX) maxX = p.x;
+        if (p.y > maxY) maxY = p.y;
+      }
+      const w = Math.max(1, maxX - minX);
+      const h = Math.max(1, maxY - minY);
+      return Matter.Bodies.rectangle(minX + w / 2, minY + h / 2, w, h);
+    }
+    throw new Error(
+      `MatterAdapter: unsupported shape type ${shape.constructor.name}`
+    );
+  }
+};
+export {
+  MatterAdapter,
+  REQUIRED_MELONJS_VERSION
+};
+//# sourceMappingURL=index.js.map