melonjs 20.0.0 → 20.1.1

package/build/index.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - 20.0.0
+ * melonJS Game Engine - 20.1.1
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -6665,8 +6665,8 @@ function resetGUID(base, index = 0) {
   GUID_base = toHex(base.toUpperCase());
   GUID_index = index;
 }
-function createGUID(index = 1) {
-  GUID_index += index;
+function createGUID(index) {
+  GUID_index++;
   return `${GUID_base}-${index || GUID_index}`;
 }
 var isStringArray = (value) => {
@@ -12366,7 +12366,10 @@ var Timer = class {
    * @ignore
    */
   updateTimers() {
-    for (const timer2 of this.timers) {
+    for (const timer2 of [...this.timers]) {
+      if (!this.timers.includes(timer2)) {
+        continue;
+      }
       if (!(timer2.pauseable && state_default.isPaused())) {
         timer2.elapsed += this.delta;
       }
@@ -13193,9 +13196,15 @@ var FadeEffect = class extends CameraEffect {
     }
   }
   destroy() {
-    this.tween.stop();
-    tweenPool.release(this.tween);
-    colorPool.release(this.color);
+    if (this.tween !== void 0) {
+      this.tween.stop();
+      tweenPool.release(this.tween);
+      this.tween = void 0;
+    }
+    if (this.color !== void 0) {
+      colorPool.release(this.color);
+      this.color = void 0;
+    }
   }
 };
 
@@ -13594,13 +13603,22 @@ var MaskEffect = class extends CameraEffect {
     r.restore();
   }
   destroy() {
-    this.tween.stop();
-    tweenPool.release(this.tween);
-    colorPool.release(this.color);
-    if (this._maskShape.type === "Ellipse") {
-      ellipsePool.release(this._maskShape);
-    } else {
-      polygonPool.release(this._maskShape);
+    if (this.tween !== void 0) {
+      this.tween.stop();
+      tweenPool.release(this.tween);
+      this.tween = void 0;
+    }
+    if (this.color !== void 0) {
+      colorPool.release(this.color);
+      this.color = void 0;
+    }
+    if (this._maskShape !== void 0) {
+      if (this._maskShape.type === "Ellipse") {
+        ellipsePool.release(this._maskShape);
+      } else {
+        polygonPool.release(this._maskShape);
+      }
+      this._maskShape = void 0;
     }
   }
 };
@@ -16678,6 +16696,7 @@ var collision = {
 };
 
 // src/physics/builtin/body.js
+var shapeContactIdCounter = 0;
 var Body = class {
   /**
    * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} ancestor - the parent object this body is attached to
@@ -17046,6 +17065,9 @@ var Body = class {
    * @private
    */
   _initShapeCollision(stored, source) {
+    if (stored._contactId === void 0) {
+      stored._contactId = ++shapeContactIdCounter;
+    }
     if (source === void 0) {
       stored.collisionType = void 0;
       stored.collisionMask = void 0;
@@ -17502,6 +17524,7 @@ var Body = class {
       shape.collisionMask = void 0;
       shape.isTrigger = false;
       shape.isActive = true;
+      shape._contactId = void 0;
       if (shape instanceof Point) {
         pointPool.release(shape);
       } else if (shape instanceof Line) {
@@ -17587,7 +17610,7 @@ var Renderable = class _Renderable extends Rect {
    */
   get parentApp() {
     if (!this._parentApp && this.ancestor) {
-      this._parentApp = this.ancestor.getRootAncestor().app;
+      this._parentApp = this.ancestor.getRootAncestor()?.app;
     }
     return this._parentApp;
   }
@@ -21056,6 +21079,9 @@ var FrameAnimation = class {
           this.resetAnim = () => {
             if (typeof onComplete === "function") {
               onComplete();
+              if (!this._isCurrentAnimationLive()) {
+                return false;
+              }
             }
             this.setCurrentAnimation(next, null, true);
           };
@@ -21063,6 +21089,9 @@ var FrameAnimation = class {
           this.resetAnim = () => {
             if (typeof onComplete === "function") {
               onComplete();
+              if (!this._isCurrentAnimationLive()) {
+                return false;
+              }
             }
             this._animDone = true;
             return false;
@@ -21148,6 +21177,26 @@ var FrameAnimation = class {
    * @param {number} id - the frame id
    * @returns {object} the frame data
    */
+  /**
+   * Whether the current animation is still resolvable.
+   *
+   * `update()` hands control to user code in the middle of its frame loop:
+   * `onended`, and the completion callback behind `resetAnim`. That code is
+   * free to tear the host down — "remove me once the animation finishes" is
+   * an entirely reasonable reaction, and `removeChildNow()` destroys the
+   * sprite, whose `destroy()` empties `anim`. Everything after the callback
+   * reads out of `anim`, so the loop has to check it is still there rather
+   * than resume into a map the callback just cleared.
+   *
+   * A callback that switches animations with `setCurrentAnimation()` leaves
+   * this true, which is the point: only a genuinely torn-down host stops the
+   * loop.
+   * @ignore
+   * @returns {boolean} true while the current animation can still be read
+   */
+  _isCurrentAnimationLive() {
+    return this.current !== void 0 && this.current !== null && this.anim[this.current.name] !== void 0;
+  }
   getAnimationFrameObjectByIndex(id) {
     return this.anim[this.current.name].frames[id];
   }
@@ -21181,6 +21230,9 @@ var FrameAnimation = class {
    */
   update(dt) {
     let changed = false;
+    if (!this._isCurrentAnimationLive()) {
+      return changed;
+    }
     if (!this.animationpause && !this._animDone && this.current.length > 1) {
       let duration = this.getAnimationFrameObjectByIndex(
         this.current.idx
@@ -21194,9 +21246,16 @@ var FrameAnimation = class {
         if (this.current.idx === 0) {
           if (typeof this.host.onended === "function") {
             this.host.onended();
+            if (!this._isCurrentAnimationLive()) {
+              break;
+            }
           }
           if (typeof this.resetAnim === "function") {
-            if (this.resetAnim() === false) {
+            const keepPlaying = this.resetAnim();
+            if (!this._isCurrentAnimationLive()) {
+              break;
+            }
+            if (keepPlaying === false) {
               this.setAnimationFrame(this.current.length - 1);
               this.dt %= duration;
               break;
@@ -23294,11 +23353,13 @@ function preloadBinary(data2, onload2, onerror, settings) {
 // src/loader/parsers/fontface.js
 function preloadFontFace(data2, onload2, onerror) {
   const fontFaceSet = typeof globalThis.document !== "undefined" ? globalThis.document.fonts : void 0;
-  if (!data2.src.startsWith("url(") && !data2.src.startsWith("local(")) {
-    data2.src = "url(" + data2.src + ")";
+  let src = data2.src;
+  if (!src.startsWith("url(") && !src.startsWith("local(")) {
+    const escaped = src.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+    src = `url('${escaped}')`;
   }
   if (typeof fontFaceSet !== "undefined") {
-    const font = new FontFace(data2.name, data2.src);
+    const font = new FontFace(data2.name, src);
     font.load().then(
       () => {
         fontList[data2.name] = font;
@@ -26691,9 +26752,12 @@ var Container = class _Container extends Renderable {
     let isFloating = false;
     const isPaused = state_default.isPaused();
     const children = this.getChildren();
-    const childrenLength = children.length;
     const cameras = state_default.current().cameras;
-    for (let i = childrenLength, obj; i--, obj = children[i]; ) {
+    const pass = children.slice();
+    for (let i = pass.length, obj; i--, obj = pass[i]; ) {
+      if (obj.ancestor !== this) {
+        continue;
+      }
       if (isPaused && !obj.updateWhenPaused) {
         continue;
       }
@@ -27033,6 +27097,9 @@ var GLTFModel = class extends Container {
       this.resetAnim = () => {
         if (typeof onComplete === "function") {
           onComplete();
+          if (!this._isLive()) {
+            return false;
+          }
         }
         this.setCurrentAnimation(next);
       };
@@ -27040,6 +27107,9 @@ var GLTFModel = class extends Container {
       this.resetAnim = () => {
         if (typeof onComplete === "function") {
           onComplete();
+          if (!this._isLive()) {
+            return false;
+          }
         }
         this._animDone = true;
         return false;
@@ -27119,6 +27189,9 @@ var GLTFModel = class extends Container {
       if (this.current.time >= duration) {
         if (typeof this.onended === "function") {
           this.onended();
+          if (!this._isLive()) {
+            return super.update(dt);
+          }
         }
         if (typeof this.resetAnim === "function") {
           if (this.resetAnim() === false) {
@@ -27130,6 +27203,9 @@ var GLTFModel = class extends Container {
           this.current.time %= duration;
         }
       }
+      if (!this._isLive()) {
+        return super.update(dt);
+      }
       this._pose();
       this.isDirty = true;
     }
@@ -27141,6 +27217,24 @@ var GLTFModel = class extends Container {
    * not animate use their cached rest matrix.
    * @ignore
    */
+  /**
+   * Whether this model is still alive.
+   *
+   * `update()` hands control to user code — `onended`, and the completion
+   * callback behind `resetAnim` — and then poses the hierarchy. A callback
+   * that removed the model (a death animation removing its own model is the
+   * obvious case) has had `Renderable.destroy()` run, which releases `pos` to
+   * the pool and leaves it undefined on every part. `_pose()` writes
+   * `mesh.pos`, so it must not run on a torn-down model.
+   *
+   * `pos` and not `ancestor`: a model that was never added to a container is
+   * perfectly poseable, and several callers do exactly that.
+   * @ignore
+   * @returns {boolean} true while the model can still be posed
+   */
+  _isLive() {
+    return this.pos !== void 0;
+  }
   _pose() {
     const clip = this.current.name ? this.anim[this.current.name] : null;
     const t = this.current.time;
@@ -47811,6 +47905,56 @@ var Detector = class {
         isTriggerContact: false
       }
     ];
+    this._activeShapePairs = /* @__PURE__ */ new Map();
+    this._frameShapeSeen = /* @__PURE__ */ new Map();
+    this._shapeViews = [
+      {
+        a: null,
+        b: null,
+        shapeA: null,
+        shapeB: null,
+        overlap: 0,
+        overlapN: { x: 0, y: 0 },
+        overlapV: { x: 0, y: 0 },
+        normal: { x: 0, y: 0 },
+        depth: 0,
+        overlapNZ: 0,
+        overlapZ: 0,
+        normalZ: 0,
+        indexShapeA: -1,
+        indexShapeB: -1,
+        isTrigger: false
+      },
+      {
+        a: null,
+        b: null,
+        shapeA: null,
+        shapeB: null,
+        overlap: 0,
+        overlapN: { x: 0, y: 0 },
+        overlapV: { x: 0, y: 0 },
+        normal: { x: 0, y: 0 },
+        depth: 0,
+        overlapNZ: 0,
+        overlapZ: 0,
+        normalZ: 0,
+        indexShapeA: -1,
+        indexShapeB: -1,
+        isTrigger: false
+      }
+    ];
+    this._contactObjA = null;
+    this._contactObjB = null;
+    this._onShapeContact = (shapeA, indexA, shapeB, indexB, isTrigger, res) => {
+      this._dispatchShapeContact(
+        shapeA,
+        indexA,
+        shapeB,
+        indexB,
+        isTrigger,
+        res
+      );
+    };
   }
   /**
    * Populate one of the pooled symmetric views from a SAT response.
@@ -47869,6 +48013,7 @@ var Detector = class {
    */
   beginFrame() {
     this._frameSeen.clear();
+    this._frameShapeSeen.clear();
   }
   /**
    * Called by the adapter at the end of a physics step. Diffs the
@@ -47895,9 +48040,58 @@ var Detector = class {
         b.onCollisionEnd(void 0, a);
       }
     }
+    for (const [key, entry2] of this._activeShapePairs) {
+      if (this._frameShapeSeen.has(key)) {
+        continue;
+      }
+      const [a, b, shapeA, shapeB] = entry2;
+      const aAttached = a.ancestor != null;
+      const bAttached = b.ancestor != null;
+      if (!aAttached && !bAttached) {
+        continue;
+      }
+      if (aAttached && typeof a.onShapeCollisionEnd === "function") {
+        a.onShapeCollisionEnd(this._fillEndedView(0, a, b, shapeA, shapeB), b);
+      }
+      if (bAttached && typeof b.onShapeCollisionEnd === "function") {
+        b.onShapeCollisionEnd(this._fillEndedView(1, b, a, shapeB, shapeA), a);
+      }
+    }
     const prev = this._activePairs;
     this._activePairs = this._frameSeen;
     this._frameSeen = prev;
+    const prevShapes = this._activeShapePairs;
+    this._activeShapePairs = this._frameShapeSeen;
+    this._frameShapeSeen = prevShapes;
+    this._frameShapeSeen.clear();
+  }
+  /**
+   * Identity-only shape-contact view for `onShapeCollisionEnd`: the shapes
+   * have separated, so every geometric field is zeroed rather than left
+   * holding the last overlap, which would read as a live contact.
+   * @ignore
+   */
+  _fillEndedView(slot, receiver, partner, ownShape, otherShape) {
+    const view = this._shapeViews[slot];
+    view.a = receiver;
+    view.b = partner;
+    view.shapeA = ownShape;
+    view.shapeB = otherShape;
+    view.indexShapeA = receiver.body?.shapes.indexOf(ownShape) ?? -1;
+    view.indexShapeB = partner.body?.shapes.indexOf(otherShape) ?? -1;
+    view.isTrigger = ownShape?.isTrigger === true || otherShape?.isTrigger === true;
+    view.overlap = 0;
+    view.depth = 0;
+    view.overlapN.x = 0;
+    view.overlapN.y = 0;
+    view.overlapV.x = 0;
+    view.overlapV.y = 0;
+    view.normal.x = 0;
+    view.normal.y = 0;
+    view.overlapNZ = 0;
+    view.overlapZ = 0;
+    view.normalZ = 0;
+    return view;
   }
   /**
    * Build a stable order-independent key for a pair of renderables,
@@ -47913,6 +48107,188 @@ var Detector = class {
     }
     return ga < gb ? `${ga}|${gb}` : `${gb}|${ga}`;
   }
+  /**
+   * Re-run the narrowphase for a remembered shape pair and repopulate
+   * `response` from it.
+   *
+   * The scan clears `response` on every test, so whichever pair won has to be
+   * measured again before handlers and the solver read it. Indices are looked
+   * up here rather than carried from the scan because an enumeration handler
+   * may have mutated either body in between: `removeShape()` re-indexes, and
+   * `destroy()` empties the array outright. A shape that is no longer on its
+   * body has no contact left to resolve, so this reports failure and the
+   * caller falls through instead of throwing.
+   * @ignore
+   * @returns {boolean} true when the pair was re-measured
+   */
+  _retest(bodyA, bodyB, shapeA, shapeB, response) {
+    const indexA = bodyA.shapes.indexOf(shapeA);
+    const indexB = bodyB.shapes.indexOf(shapeB);
+    if (indexA < 0 || indexB < 0) {
+      return false;
+    }
+    const test = SAT_LOOKUP[shapeA.type + shapeB.type];
+    if (test === void 0) {
+      return false;
+    }
+    test.call(
+      this,
+      bodyA.ancestor,
+      shapeA,
+      bodyB.ancestor,
+      shapeB,
+      response.clear()
+    );
+    response.indexShapeA = indexA;
+    response.indexShapeB = indexB;
+    return true;
+  }
+  /**
+   * Stable, order-independent key for one SHAPE pair (#1596).
+   *
+   * The renderable GUIDs order the pair, exactly as `_pairKey` does, and the
+   * two shape ids MUST swap alongside them: keying `guidA|guidB|idA|idB`
+   * without that swap gives the same physical contact two different keys
+   * depending on which object the outer loop visited first, and the contact
+   * would then End and Start every step.
+   *
+   * Shape identity is `_contactId`, stamped once in `Body#addShape` and never
+   * derived from array position, because `removeShape()` re-indexes every
+   * surviving shape.
+   * @ignore
+   */
+  _shapePairKey(a, b, shapeA, shapeB) {
+    const ga = a.GUID;
+    const gb = b.GUID;
+    const sa = shapeA?._contactId;
+    const sb = shapeB?._contactId;
+    if (ga === void 0 || gb === void 0 || sa === void 0 || sb === void 0) {
+      return void 0;
+    }
+    const left = `${ga}#${sa}`;
+    const right = `${gb}#${sb}`;
+    return left < right ? `${left}|${right}` : `${right}|${left}`;
+  }
+  /**
+   * True when an object subscribes to any shape-contact event.
+   *
+   * This is the opt-in gate: `collides()` only runs the full M x N scan when
+   * this returns true for one of the two objects, so an application that
+   * never declares these handlers performs exactly the narrowphase work it
+   * did before the feature existed.
+   * @ignore
+   */
+  _wantsShapeContacts(obj) {
+    return typeof obj.onShapeCollisionStart === "function" || typeof obj.onShapeCollisionActive === "function" || typeof obj.onShapeCollisionEnd === "function";
+  }
+  /**
+   * Populate a pooled shape-contact view, same flip convention as
+   * `_fillSymView`: `flip=false` builds the view for `response.a`'s side,
+   * `flip=true` for `response.b`'s, so `shapeA` is always the receiver's.
+   * @ignore
+   */
+  _fillShapeView(slot, satResponse, flip, shapeA, shapeB, isTrigger) {
+    const view = this._shapeViews[slot];
+    const oN = satResponse.overlapN;
+    const oV = satResponse.overlapV;
+    const oNZ = satResponse.overlapNZ;
+    const oZ = satResponse.overlapZ;
+    view.overlap = satResponse.overlap;
+    view.depth = satResponse.overlap;
+    view.isTrigger = isTrigger === true;
+    if (flip) {
+      view.a = satResponse.b;
+      view.b = satResponse.a;
+      view.shapeA = shapeB;
+      view.shapeB = shapeA;
+      view.indexShapeA = satResponse.indexShapeB;
+      view.indexShapeB = satResponse.indexShapeA;
+      view.overlapN.x = -oN.x;
+      view.overlapN.y = -oN.y;
+      view.overlapV.x = -oV.x;
+      view.overlapV.y = -oV.y;
+      view.overlapNZ = -oNZ;
+      view.overlapZ = -oZ;
+      view.normal.x = oN.x;
+      view.normal.y = oN.y;
+      view.normalZ = oNZ;
+    } else {
+      view.a = satResponse.a;
+      view.b = satResponse.b;
+      view.shapeA = shapeA;
+      view.shapeB = shapeB;
+      view.indexShapeA = satResponse.indexShapeA;
+      view.indexShapeB = satResponse.indexShapeB;
+      view.overlapN.x = oN.x;
+      view.overlapN.y = oN.y;
+      view.overlapV.x = oV.x;
+      view.overlapV.y = oV.y;
+      view.overlapNZ = oNZ;
+      view.overlapZ = oZ;
+      view.normal.x = -oN.x;
+      view.normal.y = -oN.y;
+      view.normalZ = -oNZ;
+    }
+    return view;
+  }
+  /**
+   * Fire Start / Active for one overlapping shape pair. Called back from
+   * `collides()` once per pair, in scan order.
+   * @ignore
+   */
+  _dispatchShapeContact(shapeA, shapeB, isTrigger, response) {
+    const objA = this._contactObjA;
+    const objB = this._contactObjB;
+    const key = this._shapePairKey(objA, objB, shapeA, shapeB);
+    if (key === void 0 || this._frameShapeSeen.has(key)) {
+      return;
+    }
+    this._frameShapeSeen.set(key, [objA, objB, shapeA, shapeB]);
+    const isEntry = !this._activeShapePairs.has(key);
+    const viewA = this._fillShapeView(
+      0,
+      response,
+      false,
+      shapeA,
+      shapeB,
+      isTrigger
+    );
+    const viewB = this._fillShapeView(
+      1,
+      response,
+      true,
+      shapeA,
+      shapeB,
+      isTrigger
+    );
+    if (isEntry) {
+      if (typeof objA.onShapeCollisionStart === "function") {
+        objA.onShapeCollisionStart(viewA, objB);
+      }
+      if (typeof objB.onShapeCollisionStart === "function") {
+        objB.onShapeCollisionStart(viewB, objA);
+      }
+    }
+    if (typeof objA.onShapeCollisionActive === "function") {
+      objA.onShapeCollisionActive(viewA, objB);
+    }
+    if (typeof objB.onShapeCollisionActive === "function") {
+      objB.onShapeCollisionActive(viewB, objA);
+    }
+  }
+  /**
+   * Drop the references the enumeration callback reads.
+   *
+   * They are plain fields rather than a per-pair closure so the hot path
+   * allocates nothing, which means they outlive the pair unless cleared, and
+   * would hold two renderables (and everything they reach) against garbage
+   * collection until the next subscribed pair happened to overwrite them.
+   * @ignore
+   */
+  _clearContactPair() {
+    this._contactObjA = null;
+    this._contactObjB = null;
+  }
   /**
    * determine if two objects should collide (based on both respective objects body collision mask and type).<br>
    * you can redefine this function if you need any specific rules over what should collide with what.
@@ -47931,9 +48307,12 @@ var Detector = class {
    * @param {Body} bodyB - a reference to body B.
    * @returns {boolean} true if colliding
    */
-  collides(bodyA, bodyB, response = this.response) {
-    let triggerIndexA = -1;
-    let triggerIndexB = -1;
+  collides(bodyA, bodyB, response = this.response, onContact = void 0) {
+    const enumerate = onContact !== void 0;
+    let solidShapeA = null;
+    let solidShapeB = null;
+    let triggerShapeA = null;
+    let triggerShapeB = null;
     for (let indexA = bodyA.shapes.length, shapeA; indexA--, shapeA = bodyA.shapes[indexA]; ) {
       for (let indexB = bodyB.shapes.length, shapeB; indexB--, shapeB = bodyB.shapes[indexB]; ) {
         if (shapeA.isActive === false || shapeB.isActive === false) {
@@ -47968,10 +48347,24 @@ var Detector = class {
           // clear response object before reusing
           response.clear()
         ) === true) {
-          if (shapeA.isTrigger === true || shapeB.isTrigger === true) {
-            if (triggerIndexA < 0) {
-              triggerIndexA = indexA;
-              triggerIndexB = indexB;
+          const pairIsTrigger = shapeA.isTrigger === true || shapeB.isTrigger === true;
+          if (enumerate === true) {
+            response.indexShapeA = indexA;
+            response.indexShapeB = indexB;
+            response.isTriggerContact = pairIsTrigger;
+            onContact(shapeA, shapeB, pairIsTrigger, response);
+          }
+          if (pairIsTrigger) {
+            if (triggerShapeA === null) {
+              triggerShapeA = shapeA;
+              triggerShapeB = shapeB;
+            }
+            continue;
+          }
+          if (enumerate === true) {
+            if (solidShapeA === null) {
+              solidShapeA = shapeA;
+              solidShapeB = shapeB;
             }
             continue;
           }
@@ -47981,22 +48374,15 @@ var Detector = class {
         }
       }
     }
-    if (triggerIndexA >= 0) {
-      const shapeA = bodyA.shapes[triggerIndexA];
-      const shapeB = bodyB.shapes[triggerIndexB];
-      SAT_LOOKUP[shapeA.type + shapeB.type].call(
-        this,
-        bodyA.ancestor,
-        shapeA,
-        bodyB.ancestor,
-        shapeB,
-        response.clear()
-      );
-      response.indexShapeA = triggerIndexA;
-      response.indexShapeB = triggerIndexB;
-      response.isTriggerContact = true;
+    if (solidShapeA !== null && this._retest(bodyA, bodyB, solidShapeA, solidShapeB, response)) {
       return true;
     }
+    if (triggerShapeA !== null) {
+      if (this._retest(bodyA, bodyB, triggerShapeA, triggerShapeB, response)) {
+        response.isTriggerContact = true;
+        return true;
+      }
+    }
     return false;
   }
   /**
@@ -48016,7 +48402,23 @@ var Detector = class {
         boundsB.addBounds(objB.getBounds(), true);
         boundsB.addBounds(objB.body.getBounds());
         if (boundsA.overlaps(boundsB)) {
-          if (this.collides(objA.body, objB.body)) {
+          const wantsContacts = this._wantsShapeContacts(objA) || this._wantsShapeContacts(objB);
+          let onContact;
+          if (wantsContacts === true) {
+            this._contactObjA = objA;
+            this._contactObjB = objB;
+            onContact = this._onShapeContact;
+          }
+          const didCollide = this.collides(
+            objA.body,
+            objB.body,
+            this.response,
+            onContact
+          );
+          if (wantsContacts === true) {
+            this._clearContactPair();
+          }
+          if (didCollide) {
             collisionCounter++;
             const pairKey = this._pairKey(objA, objB);
             const firstVisitThisFrame = pairKey !== void 0 && !this._frameSeen.has(pairKey);
@@ -48040,14 +48442,23 @@ var Detector = class {
                 objB.onCollisionActive(viewB, objA);
               }
             }
+            if (objA.body === void 0 || objB.body === void 0) {
+              continue;
+            }
             const eitherSensor = objA.body.isSensor === true || objB.body.isSensor === true || this.response.isTriggerContact === true;
             const aHasModern = typeof objA.onCollisionActive === "function";
             const bHasModern = typeof objB.onCollisionActive === "function";
             const aOptsOut = !aHasModern && typeof objA.onCollision === "function" && objA.onCollision(this.response, objB) === false;
+            if (objA.body === void 0 || objB.body === void 0) {
+              continue;
+            }
             if (!aOptsOut && objA.body.isStatic === false && !eitherSensor) {
               objA.body.respondToCollision.call(objA.body, this.response);
             }
             const bOptsOut = !bHasModern && typeof objB.onCollision === "function" && objB.onCollision(this.response, objA) === false;
+            if (objA.body === void 0 || objB.body === void 0) {
+              continue;
+            }
             if (!bOptsOut && objB.body.isStatic === false && !eitherSensor) {
               objB.body.respondToCollision.call(objB.body, this.response);
             }
@@ -48323,8 +48734,10 @@ var BuiltinAdapter = class {
           this.detector.collisions(ancestor);
         }
       }
-      body.force.set(0, 0);
-      body.forceZ = 0;
+      if (body.force !== void 0) {
+        body.force.set(0, 0);
+        body.forceZ = 0;
+      }
     }
     this.detector.endFrame();
   }
@@ -50064,7 +50477,7 @@ var Trigger = class extends Renderable {
 };
 
 // src/version.ts
-var version = "20.0.0";
+var version = "20.1.1";
 
 // src/system/bootstrap.ts
 var initialized = false;