@blorkfield/overlay-core 0.10.1 → 0.11.1

package/README.md

@@ -628,7 +628,7 @@ scene.on('objectRemoved', (obj) => {
   console.log(`Removed: ${obj.id}`);
 });
 
-// Objects collided
+// Objects collided (fires on collision start)
 scene.on('objectCollision', (a, b) => {
   console.log(`Collision: ${a.id} hit ${b.id}`);
 });
@@ -637,6 +637,23 @@ scene.on('objectCollision', (a, b) => {
 scene.off('objectSpawned', myCallback);
 ```
 
+### Querying Active Collisions
+
+The scene tracks which objects are currently in contact, so you can query collision state at any time without maintaining your own bookkeeping:
+
+```typescript
+// Get all object IDs currently touching a specific object
+const touching = scene.getCollidingWith('my-object-id'); // string[]
+
+// Get all active collision pairs
+const pairs = scene.getActiveCollisions(); // Array<{ a: string, b: string }>
+for (const { a, b } of pairs) {
+  console.log(`${a} is touching ${b}`);
+}
+```
+
+These reflect live physics state — pairs are added on `collisionStart` and removed on `collisionEnd`. Only tracked objects are included (floor, boundaries, and DOM obstacles are excluded).
+
 ## Font Setup
 
 ### Bundled Fonts

package/dist/index.cjs

@@ -1466,6 +1466,8 @@ var OverlayScene = class {
     this.followWindowEntries = /* @__PURE__ */ new Set();
     // IDs of static objects that have pressure thresholds — empty = skip updatePressure entirely
     this.pressureObstacleIds = /* @__PURE__ */ new Set();
+    // Active collision pairs: id -> Set of ids currently colliding with it
+    this.activeCollisions = /* @__PURE__ */ new Map();
     /** Handle mouse down - start grab via programmatic API */
     this.handleMouseDown = (event) => {
       const rect = this.canvas.getBoundingClientRect();
@@ -1532,6 +1534,10 @@ var OverlayScene = class {
         const entryA = this.findObjectByBody(pair.bodyA);
         const entryB = this.findObjectByBody(pair.bodyB);
         if (entryA && entryB) {
+          if (!this.activeCollisions.has(entryA.id)) this.activeCollisions.set(entryA.id, /* @__PURE__ */ new Set());
+          if (!this.activeCollisions.has(entryB.id)) this.activeCollisions.set(entryB.id, /* @__PURE__ */ new Set());
+          this.activeCollisions.get(entryA.id).add(entryB.id);
+          this.activeCollisions.get(entryB.id).add(entryA.id);
           this.emitLifecycleEvent(
             "objectCollision",
             this.toObjectState(entryA),
@@ -1540,6 +1546,16 @@ var OverlayScene = class {
         }
       }
     };
+    this.handleCollisionEnd = (event) => {
+      for (const pair of event.pairs) {
+        const entryA = this.findObjectByBody(pair.bodyA);
+        const entryB = this.findObjectByBody(pair.bodyB);
+        if (entryA && entryB) {
+          this.activeCollisions.get(entryA.id)?.delete(entryB.id);
+          this.activeCollisions.get(entryB.id)?.delete(entryA.id);
+        }
+      }
+    };
     // ==================== PRIVATE ====================
     this.loop = () => {
       const substepDelta = 1e3 / 60 / this.substeps;
@@ -1668,6 +1684,7 @@ var OverlayScene = class {
     import_matter_js5.default.Events.on(this.render, "beforeRender", this.handleBeforeRender);
     import_matter_js5.default.Events.on(this.render, "afterRender", this.handleAfterRender);
     import_matter_js5.default.Events.on(this.engine, "collisionStart", this.handleCollisionStart);
+    import_matter_js5.default.Events.on(this.engine, "collisionEnd", this.handleCollisionEnd);
   }
   static createContainer(parent, options = {}) {
     const canvas = document.createElement("canvas");
@@ -2071,6 +2088,7 @@ var OverlayScene = class {
     import_matter_js5.default.Events.off(this.render, "beforeRender", this.handleBeforeRender);
     import_matter_js5.default.Events.off(this.render, "afterRender", this.handleAfterRender);
     import_matter_js5.default.Events.off(this.engine, "collisionStart", this.handleCollisionStart);
+    import_matter_js5.default.Events.off(this.engine, "collisionEnd", this.handleCollisionEnd);
     import_matter_js5.default.Engine.clear(this.engine);
     this.objects.clear();
     this.gravityOverrideEntries.clear();
@@ -2081,6 +2099,7 @@ var OverlayScene = class {
     this.pressureLogTimer = 0;
     this.floorSegmentPressure.clear();
     this.collapsedSegments.clear();
+    this.activeCollisions.clear();
     this.updateCallbacks = [];
     this.lifecycleCallbacks.objectSpawned = [];
     this.lifecycleCallbacks.objectRemoved = [];
@@ -2532,6 +2551,13 @@ var OverlayScene = class {
     this.gravityOverrideEntries.delete(entry);
     this.followWindowEntries.delete(entry);
     this.pressureObstacleIds.delete(id);
+    const colliding = this.activeCollisions.get(id);
+    if (colliding) {
+      for (const otherId of colliding) {
+        this.activeCollisions.get(otherId)?.delete(id);
+      }
+      this.activeCollisions.delete(id);
+    }
     this.objects.delete(id);
   }
   removeObjects(ids) {
@@ -2781,6 +2807,32 @@ var OverlayScene = class {
     const idx = arr.indexOf(callback);
     if (idx !== -1) arr.splice(idx, 1);
   }
+  /**
+   * Get the IDs of all objects currently colliding with a given object.
+   * @param id - The ID of the object to query
+   * @returns Array of IDs of objects currently in contact with it
+   */
+  getCollidingWith(id) {
+    return Array.from(this.activeCollisions.get(id) ?? []);
+  }
+  /**
+   * Get all currently active collision pairs.
+   * @returns Array of `{ a, b }` pairs where `a` and `b` are colliding object IDs
+   */
+  getActiveCollisions() {
+    const pairs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const [id, others] of this.activeCollisions) {
+      for (const otherId of others) {
+        const key = id < otherId ? `${id}:${otherId}` : `${otherId}:${id}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          pairs.push({ a: id, b: otherId });
+        }
+      }
+    }
+    return pairs;
+  }
   /** Create ObjectState from an ObjectEntry */
   toObjectState(entry) {
     return {
@@ -3082,11 +3134,12 @@ var OverlayScene = class {
       maxDimension = Math.max(maxDimension, dims.width, dims.height);
     }
     if (maxDimension === 0) maxDimension = 100;
+    const spaceWidth = letterSize / 3;
     const calculateLineWidth = (line) => {
       let width = 0;
       for (const char of line) {
         if (char === " ") {
-          width += 20;
+          width += spaceWidth;
         } else if (/^[A-Za-z0-9]$/.test(char)) {
           const dims = charDimensions.get(char);
           if (dims) {
@@ -3144,7 +3197,6 @@ var OverlayScene = class {
       for (let i = 0; i < chars.length; i++) {
         const char = chars[i];
         if (char === " ") {
-          const spaceWidth = config.letterSpacing ?? letterSize;
           currentX += spaceWidth;
           globalCharIndex++;
           if (inWord) {