excalibur 0.32.0-alpha.19 → 0.32.0

package/build/dist/excalibur.js

@@ -1,4 +1,4 @@
-/*! excalibur - 0.32.0-alpha.19+57bc004 - 2025-12-22
+/*! excalibur - 0.32.0 - 2025-12-23
 https://github.com/excaliburjs/Excalibur
 Copyright (c) 2025 Excalibur.js <https://github.com/excaliburjs/Excalibur/graphs/contributors>
 Licensed BSD-2-Clause
@@ -512,18 +512,13 @@ Licensed BSD-2-Clause
     return Math.abs(val1 - val2) < tolerance;
   }
   function canonicalizeAngle(angle) {
-    let tmpAngle = angle;
-    if (angle >= TwoPI) {
-      while (tmpAngle >= TwoPI) {
-        tmpAngle -= TwoPI;
-      }
-    }
-    if (angle < 0) {
-      while (tmpAngle < 0) {
-        tmpAngle += TwoPI;
-      }
-    }
-    return tmpAngle;
+    const TWO_PI = 2 * Math.PI;
+    return (angle % TWO_PI + TWO_PI) % TWO_PI;
+  }
+  function angleDifference(angle1, angle2) {
+    const TWO_PI = 2 * Math.PI;
+    const diff = Math.abs(angle1 - angle2);
+    return Math.min(diff, TWO_PI - diff);
   }
   function toDegrees(radians) {
     return 180 / Math.PI * radians;
@@ -5927,18 +5922,32 @@ mask:     ${(this.mask >>> 0).toString(2).padStart(32, "0")}
      * @param elapsed time in milliseconds
      */
     updateSystems(type, scene, elapsed) {
+      var _a, _b, _c;
       const systems = this.systems.filter((s) => s.systemType === type);
-      for (const s of systems) {
-        if (s.preupdate) {
-          s.preupdate(scene, elapsed);
+      const stats = (_c = (_b = (_a = scene == null ? void 0 : scene.engine) == null ? void 0 : _a.stats) == null ? void 0 : _b.currFrame) != null ? _c : { systemDuration: {} };
+      let startTime;
+      let endTime;
+      const systemsLength = systems.length;
+      for (let i = 0; i < systemsLength; i++) {
+        if (systems[i].preupdate) {
+          startTime = performance.now();
+          systems[i].preupdate(scene, elapsed);
+          endTime = performance.now();
+          stats.systemDuration[`${type}:${systems[i].constructor.name}.preupdate`] = endTime - startTime;
         }
       }
-      for (const s of systems) {
-        s.update(elapsed);
+      for (let i = 0; i < systemsLength; i++) {
+        startTime = performance.now();
+        systems[i].update(elapsed);
+        endTime = performance.now();
+        stats.systemDuration[`${type}:${systems[i].constructor.name}.update`] = endTime - startTime;
       }
-      for (const s of systems) {
-        if (s.postupdate) {
-          s.postupdate(scene, elapsed);
+      for (let i = 0; i < systemsLength; i++) {
+        if (systems[i].postupdate) {
+          startTime = performance.now();
+          systems[i].postupdate(scene, elapsed);
+          endTime = performance.now();
+          stats.systemDuration[`${type}:${systems[i].constructor.name}.postupdate`] = endTime - startTime;
         }
       }
     }
@@ -7196,10 +7205,11 @@ Check your bundler settings to make sure this is not the case! Excalibur has ESM
       surfaceEpsilon: 0.1
     },
     bodies: {
-      canSleepByDefault: false,
+      canSleepByDefault: true,
       sleepEpsilon: 0.07,
       wakeThreshold: 0.07 * 3,
-      sleepBias: 0.9,
+      sleepBias: 0.5,
+      sleepTimeThreshold: 1e3,
       defaultMass: 10
     },
     spatialPartition: SpatialPartitionStrategy.SparseHashGrid,
@@ -7839,23 +7849,6 @@ Check your bundler settings to make sure this is not the case! Excalibur has ESM
         this.bodyB = this.colliderB.owner.get(BodyComponent);
       }
     }
-    /**
-     * Match contact awake state, except if body's are Fixed
-     */
-    matchAwake() {
-      const bodyA = this.bodyA;
-      const bodyB = this.bodyB;
-      if (bodyA && bodyB) {
-        if (bodyA.isSleeping !== bodyB.isSleeping) {
-          if (bodyA.isSleeping && bodyA.collisionType !== CollisionType.Fixed && bodyB.sleepMotion >= bodyA.wakeThreshold) {
-            bodyA.isSleeping = false;
-          }
-          if (bodyB.isSleeping && bodyB.collisionType !== CollisionType.Fixed && bodyA.sleepMotion >= bodyB.wakeThreshold) {
-            bodyB.isSleeping = false;
-          }
-        }
-      }
-    }
     isCanceled() {
       return this._canceled;
     }
@@ -12083,7 +12076,7 @@ Read more here: https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/WebGL
         const optionalBody = ancestor == null ? void 0 : ancestor.get(BodyComponent);
         if (transform) {
           let tx = transform.get();
-          if (optionalBody) {
+          if (optionalBody && !optionalBody.isSleeping) {
             if (this._engine.fixedUpdateTimestep && optionalBody.__oldTransformCaptured && optionalBody.enableFixedUpdateInterpolate) {
               const blend = this._engine.currentFrameLagMs / this._engine.fixedUpdateTimestep;
               tx = blendTransform(optionalBody.oldTransform, transform.get(), blend, this._targetInterpolationTransform);
@@ -20750,11 +20743,14 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
       this.dependencies = [TransformComponent, MotionComponent];
       this.id = createId("body", _BodyComponent2._ID++);
       this.events = new EventEmitter();
+      this.island = null;
       this.oldTransform = new Transform();
       this.__oldTransformCaptured = false;
       this.enableFixedUpdateInterpolate = true;
+      this.sleepTime = 0;
       this.collisionType = CollisionType.PreventCollision;
       this.group = CollisionGroup.All;
+      this.canSleep = this.collisionType === CollisionType.Active;
       this._sleeping = false;
       this.bounciness = 0.2;
       this.friction = 0.99;
@@ -20797,6 +20793,12 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
       this.sleepMotion = this._bodyConfig.sleepEpsilon * 5;
       this.wakeThreshold = this._bodyConfig.wakeThreshold;
     }
+    get canFallAsleep() {
+      return this.canSleep && this.collisionType === CollisionType.Active && this.sleepMotion < this._bodyConfig.sleepEpsilon;
+    }
+    get canWakeUp() {
+      return this.collisionType === CollisionType.Active && this.sleepMotion > this.wakeThreshold;
+    }
     /**
      * Called by excalibur to update defaults
      * @param config
@@ -20829,7 +20831,7 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
      * Whether this body is sleeping or not
      */
     get isSleeping() {
-      return this._sleeping;
+      return this.canSleep && this._sleeping;
     }
     /**
      * Set the sleep state of the body
@@ -20839,30 +20841,51 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
     setSleeping(sleeping) {
       this.isSleeping = sleeping;
     }
-    set isSleeping(sleeping) {
-      this._sleeping = sleeping;
-      if (!sleeping) {
-        this.sleepMotion = this._bodyConfig.sleepEpsilon * 5;
-      } else {
+    wake() {
+      var _a;
+      if (this._sleeping && this.collisionType === CollisionType.Active) {
+        this._sleeping = false;
+        (_a = this.owner) == null ? void 0 : _a.removeTag("ex.is_sleeping");
+        this.sleepMotion = this._bodyConfig.sleepEpsilon * 2;
+        this.sleepTime = 0;
+      }
+    }
+    sleep() {
+      var _a;
+      if (!this._sleeping && this.canSleep) {
+        this._sleeping = true;
+        (_a = this.owner) == null ? void 0 : _a.addTag("ex.is_sleeping");
         this.vel = Vector.Zero;
         this.acc = Vector.Zero;
         this.angularVelocity = 0;
         this.sleepMotion = 0;
       }
     }
+    set isSleeping(sleeping) {
+      if (sleeping) {
+        this.sleep();
+      } else {
+        this.wake();
+      }
+    }
     /**
      * Update body's {@apilink BodyComponent.sleepMotion} for the purpose of sleeping
      */
-    updateMotion() {
-      if (this._sleeping) {
-        this.isSleeping = true;
+    updateMotion(duration) {
+      if (this.collisionType !== CollisionType.Active) {
+        return;
       }
-      const currentMotion = this.vel.magnitude * this.vel.magnitude + Math.abs(this.angularVelocity * this.angularVelocity);
-      const bias = this._bodyConfig.sleepBias;
-      this.sleepMotion = bias * this.sleepMotion + (1 - bias) * currentMotion;
+      const effectiveVel = this.pos.sub(this.oldPos);
+      const effectiveAngularVel = angleDifference(canonicalizeAngle(this.rotation), canonicalizeAngle(this.oldRotation));
+      const vel = effectiveVel.magnitude;
+      const omega = effectiveAngularVel;
+      const currentMotion = vel * vel + omega * omega;
+      const bias = Math.pow(this._bodyConfig.sleepBias, duration / 1e3);
+      const previousMotion = this.sleepMotion;
+      this.sleepMotion = bias * previousMotion + (1 - bias) * currentMotion;
       this.sleepMotion = clamp(this.sleepMotion, 0, 10 * this._bodyConfig.sleepEpsilon);
-      if (this.canSleep && this.sleepMotion < this._bodyConfig.sleepEpsilon) {
-        this.isSleeping = true;
+      if (this.canFallAsleep) {
+        this.sleepTime += duration;
       }
     }
     /**
@@ -22091,7 +22114,6 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
           "beforecollisionresolve",
           new CollisionPreSolveEvent(contact.colliderB, contact.colliderA, exports2.Side.getOpposite(side), contact.mtv.negate(), contact)
         );
-        contact.matchAwake();
       }
       const finishedContactIds = Array.from(this.idToContactConstraint.keys());
       for (let i = 0; i < contacts.length; i++) {
@@ -22106,7 +22128,7 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
         const colliderA = contact.colliderA;
         const bodyB = contact.bodyB;
         const colliderB = contact.colliderB;
-        if (bodyA && bodyB) {
+        if (bodyA && bodyB && (!bodyA.isSleeping || !bodyB.isSleeping)) {
           for (let j = 0; j < contact.points.length; j++) {
             const point2 = contact.points[j];
             const normal = contact.normal;
@@ -22165,8 +22187,6 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
           if (bodyA.collisionType === CollisionType.Passive || bodyB.collisionType === CollisionType.Passive) {
             continue;
           }
-          bodyA.updateMotion();
-          bodyB.updateMotion();
         }
         const side = exports2.Side.fromDirection(contact.mtv);
         contact.colliderA.events.emit(
@@ -22202,6 +22222,9 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
         const contact = contacts[i];
         const bodyA = contact.bodyA;
         const bodyB = contact.bodyB;
+        if (bodyA.isSleeping && bodyB.isSleeping) {
+          continue;
+        }
         if (bodyA && bodyB) {
           const contactPoints = (_a = this.idToContactConstraint.get(contact.id)) != null ? _a : [];
           for (const point2 of contactPoints) {
@@ -22230,6 +22253,9 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
           const contact = contacts[i2];
           const bodyA = contact.bodyA;
           const bodyB = contact.bodyB;
+          if (bodyA.isSleeping && bodyB.isSleeping) {
+            continue;
+          }
           if (bodyA && bodyB) {
             if (bodyA.collisionType === CollisionType.Passive || bodyB.collisionType === CollisionType.Passive) {
               continue;
@@ -22281,6 +22307,9 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
           const contact = contacts[i2];
           const bodyA = contact.bodyA;
           const bodyB = contact.bodyB;
+          if (bodyA.isSleeping && bodyB.isSleeping) {
+            continue;
+          }
           if (bodyA && bodyB) {
             if (bodyA.collisionType === CollisionType.Passive || bodyB.collisionType === CollisionType.Passive) {
               continue;
@@ -22322,17 +22351,20 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
       this.physics = physics;
       this.systemType = SystemType.Update;
       this._physicsConfigDirty = false;
-      this.query = this.world.query({
+      this.query = this._createPhysicsQuery(world, physics);
+      physics.$configUpdate.subscribe(() => {
+        this._physicsConfigDirty = true;
+      });
+    }
+    _createPhysicsQuery(world, physics) {
+      return world.query({
         components: {
           all: [TransformComponent, MotionComponent]
         },
         tags: {
-          not: this.physics.config.integration.onScreenOnly ? ["ex.offscreen"] : []
+          not: physics.config.integration.onScreenOnly ? ["ex.offscreen", "ex.is_sleeping"] : ["ex.is_sleeping"]
         }
       });
-      physics.$configUpdate.subscribe(() => {
-        this._physicsConfigDirty = true;
-      });
     }
     update(elapsed) {
       let transform;
@@ -22364,14 +22396,7 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
       }
       if (this._physicsConfigDirty) {
         this._physicsConfigDirty = false;
-        this.query = this.world.query({
-          components: {
-            all: [TransformComponent, MotionComponent]
-          },
-          tags: {
-            not: this.physics.config.integration.onScreenOnly ? ["ex.offscreen"] : []
-          }
-        });
+        this.query = this._createPhysicsQuery(this.world, this.physics);
       }
     }
     captureOldTransformWithChildren(entity) {
@@ -22383,6 +22408,105 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
     }
   }
   MotionSystem.priority = SystemPriority.Higher;
+  class Island {
+    constructor(config) {
+      this.config = config;
+      this.bodies = [];
+      this.contacts = [];
+      this.isSleeping = false;
+    }
+    wake() {
+      this.isSleeping = false;
+      for (const body of this.bodies) {
+        body.wake();
+      }
+    }
+    sleep() {
+      this.isSleeping = true;
+      for (const body of this.bodies) {
+        body.sleep();
+      }
+    }
+    updateSleepState(elapsed) {
+      let islandHasMotion = false;
+      let allBodiesCanSleep = true;
+      for (const body of this.bodies) {
+        body.updateMotion(elapsed);
+        if (!body.canFallAsleep) {
+          allBodiesCanSleep && (allBodiesCanSleep = false);
+        }
+        if (body.canWakeUp) {
+          islandHasMotion || (islandHasMotion = true);
+        }
+      }
+      if (islandHasMotion) {
+        this.wake();
+      } else if (allBodiesCanSleep) {
+        let minSleepTime = Infinity;
+        for (const body of this.bodies) {
+          minSleepTime = Math.min(minSleepTime, body.sleepTime);
+        }
+        if (minSleepTime > this.config.sleepTimeThreshold) {
+          this.sleep();
+        }
+      }
+    }
+  }
+  function buildContactIslands(config, bodies, contacts) {
+    const parent = /* @__PURE__ */ new Map();
+    function find(body) {
+      if (!parent.has(body)) {
+        parent.set(body, body);
+      }
+      if (parent.get(body) !== body) {
+        parent.set(body, find(parent.get(body)));
+      }
+      return parent.get(body);
+    }
+    function union(bodyA, bodyB) {
+      const rootA = find(bodyA);
+      const rootB = find(bodyB);
+      if (rootA !== rootB) {
+        parent.set(rootA, rootB);
+      }
+    }
+    const bodyToContacts = /* @__PURE__ */ new Map();
+    for (const contact of contacts) {
+      if (contact.bodyA.collisionType === CollisionType.Active && contact.bodyB.collisionType === CollisionType.Active) {
+        union(contact.bodyA, contact.bodyB);
+      }
+      if (!bodyToContacts.has(contact.bodyA)) {
+        bodyToContacts.set(contact.bodyA, []);
+      }
+      if (!bodyToContacts.has(contact.bodyB)) {
+        bodyToContacts.set(contact.bodyB, []);
+      }
+      if (contact.bodyA.collisionType === CollisionType.Active) {
+        bodyToContacts.get(contact.bodyA).push(contact);
+      }
+      if (contact.bodyB.collisionType === CollisionType.Active) {
+        bodyToContacts.get(contact.bodyB).push(contact);
+      }
+    }
+    const islandMap = /* @__PURE__ */ new Map();
+    for (const body of bodies) {
+      if (body.collisionType !== CollisionType.Active) {
+        continue;
+      }
+      const root = find(body);
+      if (!islandMap.has(root)) {
+        islandMap.set(root, []);
+      }
+      islandMap.get(root).push(body);
+    }
+    return Array.from(islandMap.values()).map((bodies2) => {
+      const island = new Island(config);
+      island.bodies = bodies2;
+      bodies2.forEach((b) => b.island = island);
+      island.contacts = Array.from(new Set(bodies2.flatMap((b) => bodyToContacts.get(b))));
+      return island;
+    });
+  }
   class CollisionSystem extends System {
     constructor(world, _physics) {
       super();
@@ -22391,6 +22515,7 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
       this._configDirty = false;
       this._lastFrameContacts = /* @__PURE__ */ new Map();
       this._currentFrameContacts = /* @__PURE__ */ new Map();
+      this._bodies = [];
       this._arcadeSolver = new ArcadeSolver(_physics.config.arcade);
       this._realisticSolver = new RealisticSolver(_physics.config.realistic);
       this._physics.$configUpdate.subscribe(() => this._configDirty = true);
@@ -22414,6 +22539,17 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
         }
       });
       this._motionSystem = world.get(MotionSystem);
+      this.bodyQuery = world.query([BodyComponent]);
+      this.bodyQuery.entityAdded$.subscribe((e) => {
+        this._bodies.push(e.get(BodyComponent));
+      });
+      this.bodyQuery.entityRemoved$.subscribe((e) => {
+        const body = e.get(BodyComponent);
+        const indexOf = this._bodies.indexOf(body);
+        if (indexOf > -1) {
+          this._bodies.splice(indexOf, 1);
+        }
+      });
     }
     get _processor() {
       return this._physics.collisionProcessor;
@@ -22459,7 +22595,13 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
         }
         if (pairs.length) {
           contacts = this._processor.narrowphase(pairs, (_d = (_c = (_b = this._engine) == null ? void 0 : _b.debug) == null ? void 0 : _c.stats) == null ? void 0 : _d.currFrame);
-          contacts = solver.solve(contacts);
+          if (this._physics.config.solver === SolverStrategy.Realistic) {
+            const islands = buildContactIslands(this._physics.config.bodies, this._bodies, contacts);
+            for (const island of islands) {
+              island.updateSleepState(elapsed / substep);
+            }
+          }
+          contacts = solver.solve(contacts, elapsed / substep);
           for (const contact of contacts) {
             if (contact.isCanceled()) {
               continue;
@@ -22515,6 +22657,8 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
         if (!this._currentFrameContacts.has(id)) {
           const colliderA = c.colliderA;
           const colliderB = c.colliderB;
+          c.bodyA.isSleeping = false;
+          c.bodyB.isSleeping = false;
           const side = exports2.Side.fromDirection(c.mtv);
           const opposite = exports2.Side.getOpposite(side);
           colliderA.events.emit("collisionend", new CollisionEndEvent(colliderA, colliderB, side, c));
@@ -27154,7 +27298,7 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
             cursor = cursor.add(lineHeight);
           }
           if (bodySettings.showAll || bodySettings.showMotion) {
-            this._graphicsContext.debug.drawText(`motion(${body.sleepMotion})`, cursor);
+            this._graphicsContext.debug.drawText(`motion(${body.sleepMotion.toFixed(3)})`, cursor);
             cursor = cursor.add(lineHeight);
           }
           if (bodySettings.showAll || bodySettings.showSleeping) {
@@ -29461,6 +29605,7 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
         drawnImages: 0,
         rendererSwaps: 0
       };
+      this.systemDuration = {};
     }
     /**
      * Zero out values or clone other IFrameStat stats. Allows instance reuse.
@@ -29476,6 +29621,9 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
         this.actors.ui = otherStats.actors.ui;
         this.duration.update = otherStats.duration.update;
         this.duration.draw = otherStats.duration.draw;
+        for (const key in otherStats.systemDuration) {
+          this.systemDuration[key] = otherStats.systemDuration[key];
+        }
         this._physicsStats.reset(otherStats.physics);
         this.graphics.drawCalls = otherStats.graphics.drawCalls;
         this.graphics.drawnImages = otherStats.graphics.drawnImages;
@@ -29486,6 +29634,9 @@ If you want to do custom drawing, use Actor.graphics, or any onPreDraw or onPost
         this.duration.update = this.duration.draw = 0;
         this._physicsStats.reset();
         this.graphics.drawnImages = this.graphics.drawCalls = this.graphics.rendererSwaps = 0;
+        for (const key in this.systemDuration) {
+          this.systemDuration[key] = 0;
+        }
       }
     }
     /**
@@ -33631,7 +33782,7 @@ Read more about this issue at https://excaliburjs.com/docs/performance`
       this._count += count;
     }
   }
-  const EX_VERSION = "0.32.0-alpha.19+57bc004";
+  const EX_VERSION = "0.32.0";
   polyfill();
   exports2.ActionCompleteEvent = ActionCompleteEvent;
   exports2.ActionContext = ActionContext;
@@ -33952,6 +34103,7 @@ Read more about this issue at https://excaliburjs.com/docs/performance`
   exports2.WheelDeltaMode = WheelDeltaMode;
   exports2.WheelEvent = WheelEvent;
   exports2.World = World;
+  exports2.angleDifference = angleDifference;
   exports2.approximatelyEqual = approximatelyEqual;
   exports2.assert = assert;
   exports2.canonicalizeAngle = canonicalizeAngle;