melonjs 20.1.0 → 20.1.1

package/build/index.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - 20.1.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
@@ -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;
       }
@@ -17607,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;
   }
@@ -21076,6 +21079,9 @@ var FrameAnimation = class {
           this.resetAnim = () => {
             if (typeof onComplete === "function") {
               onComplete();
+              if (!this._isCurrentAnimationLive()) {
+                return false;
+              }
             }
             this.setCurrentAnimation(next, null, true);
           };
@@ -21083,6 +21089,9 @@ var FrameAnimation = class {
           this.resetAnim = () => {
             if (typeof onComplete === "function") {
               onComplete();
+              if (!this._isCurrentAnimationLive()) {
+                return false;
+              }
             }
             this._animDone = true;
             return false;
@@ -21168,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];
   }
@@ -21201,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
@@ -21214,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;
@@ -23314,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;
@@ -26711,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;
       }
@@ -27053,6 +27097,9 @@ var GLTFModel = class extends Container {
       this.resetAnim = () => {
         if (typeof onComplete === "function") {
           onComplete();
+          if (!this._isLive()) {
+            return false;
+          }
         }
         this.setCurrentAnimation(next);
       };
@@ -27060,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;
@@ -27139,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) {
@@ -27150,6 +27203,9 @@ var GLTFModel = class extends Container {
           this.current.time %= duration;
         }
       }
+      if (!this._isLive()) {
+        return super.update(dt);
+      }
       this._pose();
       this.isDirty = true;
     }
@@ -27161,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;
@@ -48368,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);
             }
@@ -48651,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();
   }
@@ -50392,7 +50477,7 @@ var Trigger = class extends Renderable {
 };
 
 // src/version.ts
-var version = "20.1.0";
+var version = "20.1.1";
 
 // src/system/bootstrap.ts
 var initialized = false;