cubeforge 0.5.0 → 0.5.2

package/dist/advanced.js

@@ -30,7 +30,7 @@ import {
   resolveTOI,
   setDeterministicMode,
   sortEntities
-} from "./chunk-OT6I5RYW.js";
+} from "./chunk-UMHYQ4EP.js";
 export {
   Float64Pool,
   IslandDetector,

package/dist/{chunk-OT6I5RYW.js → chunk-UMHYQ4EP.js}

@@ -5261,6 +5261,31 @@ var PhysicsSystem = class {
   bvhCache = /* @__PURE__ */ new Map();
   // Physics hooks for filtering and modifying contacts
   hooks = {};
+  // ── Scratch containers — reused every frame to avoid GC pressure ──────────
+  //
+  // Previously these were allocated fresh inside update() every substep,
+  // producing ~20 Map/Set allocations per frame. Now they live as instance
+  // fields and are cleared at the start of each use. Never escape the class.
+  //
+  // The _current*Pairs fields are double-buffered with their active*Pairs
+  // counterparts: at the end of each substep, the filled "current" is swapped
+  // with "active", and next substep clears the new "current" (which was the
+  // previous "active"). Same enter/stay/exit event semantics, zero allocation.
+  _staticDelta = /* @__PURE__ */ new Map();
+  _preStepPos = /* @__PURE__ */ new Map();
+  _spatialGrid = /* @__PURE__ */ new Map();
+  _jointExcludedPairs = /* @__PURE__ */ new Set();
+  _solverBodies = /* @__PURE__ */ new Map();
+  _triggerNormals = /* @__PURE__ */ new Map();
+  _circleNormals = /* @__PURE__ */ new Map();
+  /** Shared scratch for per-body "checked" neighbor dedup; cleared per iteration. */
+  _checkedScratch = /* @__PURE__ */ new Set();
+  _currentCollisionPairs = /* @__PURE__ */ new Map();
+  _currentTriggerPairs = /* @__PURE__ */ new Map();
+  _currentCirclePairs = /* @__PURE__ */ new Map();
+  _currentCompoundPairs = /* @__PURE__ */ new Map();
+  _currentCapsulePairs = /* @__PURE__ */ new Map();
+  _currentPolygonPairs = /* @__PURE__ */ new Map();
   /** Set physics hooks for contact filtering and modification. */
   setHooks(hooks) {
     this.hooks = hooks;
@@ -5421,7 +5446,8 @@ var PhysicsSystem = class {
     }
     const nonDynamic = [...staticBox, ...kinematicBox];
     this.pruneDeadPairs(world);
-    const staticDelta = /* @__PURE__ */ new Map();
+    const staticDelta = this._staticDelta;
+    staticDelta.clear();
     for (const sid of nonDynamic) {
       const st = world.getComponent(sid, "Transform");
       const prev = this.staticPrevPos.get(sid);
@@ -5551,12 +5577,14 @@ var PhysicsSystem = class {
       }
       if (rb.dropThrough > 0) rb.dropThrough--;
     }
-    const preStepPos = /* @__PURE__ */ new Map();
+    const preStepPos = this._preStepPos;
+    preStepPos.clear();
     for (const id of dynamicBox) {
       const t = world.getComponent(id, "Transform");
       preStepPos.set(id, { x: t.x, y: t.y });
     }
-    const spatialGrid = /* @__PURE__ */ new Map();
+    const spatialGrid = this._spatialGrid;
+    spatialGrid.clear();
     for (const sid of nonDynamic) {
       const st = world.getComponent(sid, "Transform");
       const sc = world.getComponent(sid, "BoxCollider");
@@ -5571,7 +5599,8 @@ var PhysicsSystem = class {
         bucket.push(sid);
       }
     }
-    const jointExcludedPairs = /* @__PURE__ */ new Set();
+    const jointExcludedPairs = this._jointExcludedPairs;
+    jointExcludedPairs.clear();
     for (const jid of world.query("Joint")) {
       const j = world.getComponent(jid, "Joint");
       if (!j.enabled || j.broken) continue;
@@ -5581,7 +5610,8 @@ var PhysicsSystem = class {
       }
     }
     const manifolds = [];
-    const currentCollisionPairs = /* @__PURE__ */ new Map();
+    const currentCollisionPairs = this._currentCollisionPairs;
+    currentCollisionPairs.clear();
     for (const id of dynamicBox) {
       const rb = world.getComponent(id, "RigidBody");
       if (rb.sleeping) continue;
@@ -5590,7 +5620,8 @@ var PhysicsSystem = class {
       if (!col.enabled || col.isTrigger) continue;
       const dynAABB = getAABB2(transform, col);
       const candidateCells = this.getCells(dynAABB.cx, dynAABB.cy, dynAABB.hw, dynAABB.hh);
-      const checked = /* @__PURE__ */ new Set();
+      const checked = this._checkedScratch;
+      checked.clear();
       for (const cell of candidateCells) {
         const bucket = spatialGrid.get(cell);
         if (!bucket) continue;
@@ -5779,7 +5810,8 @@ var PhysicsSystem = class {
       const circleCy = ct.y + cc.offsetY;
       const circleAABB2 = { cx: circleCx, cy: circleCy, hw: cc.radius, hh: cc.radius };
       const candidateCells = this.getCells(circleAABB2.cx, circleAABB2.cy, circleAABB2.hw, circleAABB2.hh);
-      const checked = /* @__PURE__ */ new Set();
+      const checked = this._checkedScratch;
+      checked.clear();
       for (const cell of candidateCells) {
         const bucket = spatialGrid.get(cell);
         if (!bucket) continue;
@@ -5963,7 +5995,8 @@ var PhysicsSystem = class {
       const capHw = cc.width / 2;
       const capHh = cc.height / 2;
       const candidateCells = this.getCells(capCx, capCy, capHw, capHh);
-      const checked = /* @__PURE__ */ new Set();
+      const checked = this._checkedScratch;
+      checked.clear();
       for (const cell of candidateCells) {
         const bucket = spatialGrid.get(cell);
         if (!bucket) continue;
@@ -6202,7 +6235,8 @@ var PhysicsSystem = class {
       const polyCx = (minX + maxX) / 2;
       const polyCy = (minY + maxY) / 2;
       const candidateCells = this.getCells(polyCx, polyCy, polyHw, polyHh);
-      const checked = /* @__PURE__ */ new Set();
+      const checked = this._checkedScratch;
+      checked.clear();
       for (const cell of candidateCells) {
         const bucket = spatialGrid.get(cell);
         if (!bucket) continue;
@@ -6457,7 +6491,8 @@ var PhysicsSystem = class {
       const triCx = (minX + maxX) / 2;
       const triCy = (minY + maxY) / 2;
       const candidateCells = this.getCells(triCx, triCy, triHw, triHh);
-      const checked = /* @__PURE__ */ new Set();
+      const checked = this._checkedScratch;
+      checked.clear();
       for (const cell of candidateCells) {
         const bucket = spatialGrid.get(cell);
         if (!bucket) continue;
@@ -6956,7 +6991,8 @@ var PhysicsSystem = class {
         this.hooks.onContactModify(m);
       }
     }
-    const solverBodies = /* @__PURE__ */ new Map();
+    const solverBodies = this._solverBodies;
+    solverBodies.clear();
     for (const id of allBox) {
       const rb = world.getComponent(id, "RigidBody");
       const t = world.getComponent(id, "Transform");
@@ -7264,7 +7300,8 @@ var PhysicsSystem = class {
         (Math.max(startCx, endCx) - Math.min(startCx, endCx)) / 2 + hw,
         (Math.max(startCy, endCy) - Math.min(startCy, endCy)) / 2 + hh
       );
-      const checked = /* @__PURE__ */ new Set();
+      const checked = this._checkedScratch;
+      checked.clear();
       for (const cell of sweepCells) {
         const bucket = spatialGrid.get(cell);
         if (!bucket) continue;
@@ -7345,7 +7382,8 @@ var PhysicsSystem = class {
         hh: col.height / 2
       };
       const candidateCells = this.getCells(probeAABB.cx, probeAABB.cy, probeAABB.hw, probeAABB.hh);
-      const checked = /* @__PURE__ */ new Set();
+      const checked = this._checkedScratch;
+      checked.clear();
       outer: for (const cell of candidateCells) {
         const bucket = spatialGrid.get(cell);
         if (!bucket) continue;
@@ -7379,7 +7417,8 @@ var PhysicsSystem = class {
         hh: cap.height / 2
       };
       const candidateCells = this.getCells(probeAABB.cx, probeAABB.cy, probeAABB.hw, probeAABB.hh);
-      const checked = /* @__PURE__ */ new Set();
+      const checked = this._checkedScratch;
+      checked.clear();
       outerCap: for (const cell of candidateCells) {
         const bucket = spatialGrid.get(cell);
         if (!bucket) continue;
@@ -7723,10 +7762,16 @@ var PhysicsSystem = class {
         this.events?.emit("collisionExit", { a, b, normalX: 0, normalY: 0 });
       }
     }
-    this.activeCollisionPairs = currentCollisionPairs;
+    {
+      const prev = this.activeCollisionPairs;
+      this.activeCollisionPairs = currentCollisionPairs;
+      this._currentCollisionPairs = prev;
+    }
     const allWithCollider = world.query("Transform", "BoxCollider");
-    const currentTriggerPairs = /* @__PURE__ */ new Map();
-    const triggerNormals = /* @__PURE__ */ new Map();
+    const currentTriggerPairs = this._currentTriggerPairs;
+    currentTriggerPairs.clear();
+    const triggerNormals = this._triggerNormals;
+    triggerNormals.clear();
     for (let i = 0; i < allWithCollider.length; i++) {
       for (let j = i + 1; j < allWithCollider.length; j++) {
         const ia = allWithCollider[i];
@@ -7762,10 +7807,16 @@ var PhysicsSystem = class {
     for (const [key, [a, b]] of this.activeTriggerPairs) {
       if (!currentTriggerPairs.has(key)) this.events?.emit("triggerExit", { a, b, normalX: 0, normalY: 0 });
     }
-    this.activeTriggerPairs = currentTriggerPairs;
+    {
+      const prev = this.activeTriggerPairs;
+      this.activeTriggerPairs = currentTriggerPairs;
+      this._currentTriggerPairs = prev;
+    }
     if (allCircle.length > 0) {
-      const currentCirclePairs = /* @__PURE__ */ new Map();
-      const circleNormals = /* @__PURE__ */ new Map();
+      const currentCirclePairs = this._currentCirclePairs;
+      currentCirclePairs.clear();
+      const circleNormals = this._circleNormals;
+      circleNormals.clear();
       for (let i = 0; i < allCircle.length; i++) {
         for (let j = i + 1; j < allCircle.length; j++) {
           const ia = allCircle[i];
@@ -7832,14 +7883,19 @@ var PhysicsSystem = class {
       for (const [key, [a, b]] of this.activeCirclePairs) {
         if (!currentCirclePairs.has(key)) this.events?.emit("circleExit", { a, b, normalX: 0, normalY: 0 });
       }
-      this.activeCirclePairs = currentCirclePairs;
+      {
+        const prev = this.activeCirclePairs;
+        this.activeCirclePairs = currentCirclePairs;
+        this._currentCirclePairs = prev;
+      }
     } else if (this.activeCirclePairs.size > 0) {
       for (const [, [a, b]] of this.activeCirclePairs) this.events?.emit("circleExit", { a, b, normalX: 0, normalY: 0 });
-      this.activeCirclePairs = /* @__PURE__ */ new Map();
+      this.activeCirclePairs.clear();
     }
     const allCompound = world.query("Transform", "CompoundCollider");
     if (allCompound.length > 0) {
-      const currentCompoundPairs = /* @__PURE__ */ new Map();
+      const currentCompoundPairs = this._currentCompoundPairs;
+      currentCompoundPairs.clear();
       const allBoxEntities = world.query("Transform", "BoxCollider");
       for (const cid of allCompound) {
         const cc = world.getComponent(cid, "CompoundCollider");
@@ -7914,13 +7970,18 @@ var PhysicsSystem = class {
       for (const [key, [a, b]] of this.activeCompoundPairs) {
         if (!currentCompoundPairs.has(key)) this.events?.emit("compoundExit", { a, b });
       }
-      this.activeCompoundPairs = currentCompoundPairs;
+      {
+        const prev = this.activeCompoundPairs;
+        this.activeCompoundPairs = currentCompoundPairs;
+        this._currentCompoundPairs = prev;
+      }
     } else if (this.activeCompoundPairs.size > 0) {
       for (const [, [a, b]] of this.activeCompoundPairs) this.events?.emit("compoundExit", { a, b });
-      this.activeCompoundPairs = /* @__PURE__ */ new Map();
+      this.activeCompoundPairs.clear();
     }
     if (allCapsule.length > 0) {
-      const currentCapsulePairs = /* @__PURE__ */ new Map();
+      const currentCapsulePairs = this._currentCapsulePairs;
+      currentCapsulePairs.clear();
       const allBoxForCapsule = world.query("Transform", "BoxCollider");
       for (const cid of allCapsule) {
         const cc = world.getComponent(cid, "CapsuleCollider");
@@ -7958,14 +8019,19 @@ var PhysicsSystem = class {
       for (const [key, [a, b]] of this.activeCapsulePairs) {
         if (!currentCapsulePairs.has(key)) this.events?.emit("capsuleExit", { a, b });
       }
-      this.activeCapsulePairs = currentCapsulePairs;
+      {
+        const prev = this.activeCapsulePairs;
+        this.activeCapsulePairs = currentCapsulePairs;
+        this._currentCapsulePairs = prev;
+      }
     } else if (this.activeCapsulePairs.size > 0) {
       for (const [, [a, b]] of this.activeCapsulePairs) this.events?.emit("capsuleExit", { a, b });
-      this.activeCapsulePairs = /* @__PURE__ */ new Map();
+      this.activeCapsulePairs.clear();
     }
     const allPolygonEntities = [...allPolygon, ...allTriangle];
     if (allPolygonEntities.length > 0) {
-      const currentPolyPairs = /* @__PURE__ */ new Map();
+      const currentPolyPairs = this._currentPolygonPairs;
+      currentPolyPairs.clear();
       const allBoxForPoly = world.query("Transform", "BoxCollider");
       for (const pid of allPolygonEntities) {
         const isPoly = world.getComponent(pid, "ConvexPolygonCollider");
@@ -8046,10 +8112,14 @@ var PhysicsSystem = class {
       for (const [key, [a, b]] of this.activePolygonPairs) {
         if (!currentPolyPairs.has(key)) this.events?.emit("polygonExit", { a, b });
       }
-      this.activePolygonPairs = currentPolyPairs;
+      {
+        const prev = this.activePolygonPairs;
+        this.activePolygonPairs = currentPolyPairs;
+        this._currentPolygonPairs = prev;
+      }
     } else if (this.activePolygonPairs.size > 0) {
       for (const [, [a, b]] of this.activePolygonPairs) this.events?.emit("polygonExit", { a, b });
-      this.activePolygonPairs = /* @__PURE__ */ new Map();
+      this.activePolygonPairs.clear();
     }
   }
   // ── Pair pruning ────────────────────────────────────────────────────────

package/dist/index.d.ts

@@ -67,6 +67,10 @@ interface GameProps$1 {
      * - 'onDemand' — sleeps until input arrives or a component calls markDirty().
      *   Use for puzzle games, turn-based games, visual novels, level editors, or any
      *   scene where nothing changes unless the user acts. Saves battery and CPU.
+     *
+     * **Captured at mount.** This prop is read once when the Game mounts and
+     * baked into the loop. Changing it later has no effect — to switch modes,
+     * unmount and remount the Game (e.g. via a `key` change).
      */
     mode?: GameLoopMode;
     style?: CSSProperties;