excalibur 0.32.0-alpha.19 → 0.32.0

package/build/esm/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
@@ -508,18 +508,13 @@ function approximatelyEqual(val1, val2, tolerance) {
   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;
@@ -5923,18 +5918,32 @@ class SystemManager {
    * @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;
       }
     }
   }
@@ -7192,10 +7201,11 @@ const getDefaultPhysicsConfig = () => ({
     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,
@@ -7835,23 +7845,6 @@ class CollisionContact {
       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;
   }
@@ -12079,7 +12072,7 @@ class GraphicsSystem extends System {
       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);
@@ -20746,11 +20739,14 @@ const _BodyComponent = class _BodyComponent2 extends Component {
     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;
@@ -20793,6 +20789,12 @@ const _BodyComponent = class _BodyComponent2 extends Component {
     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
@@ -20825,7 +20827,7 @@ const _BodyComponent = class _BodyComponent2 extends Component {
    * Whether this body is sleeping or not
    */
   get isSleeping() {
-    return this._sleeping;
+    return this.canSleep && this._sleeping;
   }
   /**
    * Set the sleep state of the body
@@ -20835,30 +20837,51 @@ const _BodyComponent = class _BodyComponent2 extends Component {
   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;
     }
   }
   /**
@@ -22087,7 +22110,6 @@ class RealisticSolver {
         "beforecollisionresolve",
         new CollisionPreSolveEvent(contact.colliderB, contact.colliderA, Side.getOpposite(side), contact.mtv.negate(), contact)
       );
-      contact.matchAwake();
     }
     const finishedContactIds = Array.from(this.idToContactConstraint.keys());
     for (let i = 0; i < contacts.length; i++) {
@@ -22102,7 +22124,7 @@ class RealisticSolver {
       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;
@@ -22161,8 +22183,6 @@ class RealisticSolver {
         if (bodyA.collisionType === CollisionType.Passive || bodyB.collisionType === CollisionType.Passive) {
           continue;
         }
-        bodyA.updateMotion();
-        bodyB.updateMotion();
       }
       const side = Side.fromDirection(contact.mtv);
       contact.colliderA.events.emit(
@@ -22198,6 +22218,9 @@ class RealisticSolver {
       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) {
@@ -22226,6 +22249,9 @@ class RealisticSolver {
         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;
@@ -22277,6 +22303,9 @@ class RealisticSolver {
         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;
@@ -22318,17 +22347,20 @@ class MotionSystem extends System {
     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;
@@ -22360,14 +22392,7 @@ class MotionSystem extends System {
     }
     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) {
@@ -22379,6 +22404,105 @@ class MotionSystem extends System {
   }
 }
 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();
@@ -22387,6 +22511,7 @@ class CollisionSystem extends System {
     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);
@@ -22410,6 +22535,17 @@ class CollisionSystem extends System {
       }
     });
     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;
@@ -22455,7 +22591,13 @@ class CollisionSystem extends System {
       }
       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;
@@ -22511,6 +22653,8 @@ class CollisionSystem extends System {
       if (!this._currentFrameContacts.has(id)) {
         const colliderA = c.colliderA;
         const colliderB = c.colliderB;
+        c.bodyA.isSleeping = false;
+        c.bodyB.isSleeping = false;
         const side = Side.fromDirection(c.mtv);
         const opposite = Side.getOpposite(side);
         colliderA.events.emit("collisionend", new CollisionEndEvent(colliderA, colliderB, side, c));
@@ -27150,7 +27294,7 @@ class DebugSystem extends System {
           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) {
@@ -29457,6 +29601,7 @@ class FrameStats {
       drawnImages: 0,
       rendererSwaps: 0
     };
+    this.systemDuration = {};
   }
   /**
    * Zero out values or clone other IFrameStat stats. Allows instance reuse.
@@ -29472,6 +29617,9 @@ class FrameStats {
       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;
@@ -29482,6 +29630,9 @@ class FrameStats {
       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;
+      }
     }
   }
   /**
@@ -33627,7 +33778,7 @@ class Semaphore {
     this._count += count;
   }
 }
-const EX_VERSION = "0.32.0-alpha.19+57bc004";
+const EX_VERSION = "0.32.0";
 polyfill();
 export {
   ActionCompleteEvent,
@@ -33950,6 +34101,7 @@ export {
   WheelDeltaMode,
   WheelEvent,
   World,
+  angleDifference,
   approximatelyEqual,
   assert,
   canonicalizeAngle,