@nice2dev/game-engine 1.3.15 → 1.3.17

package/dist/esm/performance/DeterministicPhysics.js

@@ -1,572 +1,554 @@
-/**
- * @file DeterministicPhysics.ts
- * @description Deterministic physics simulation for competitive games
- * PRO-1.5: Runtime & Performance
- *
- * Features:
- * - Fixed-point arithmetic
- * - Deterministic collision detection
- * - Frame-based simulation
- * - Lockstep networking support
- * - State hashing for desync detection
- * - Replay validation
- */
 const FIXED_SHIFT = 16;
 const FIXED_ONE = 1 << FIXED_SHIFT;
 const FIXED_HALF = FIXED_ONE >> 1;
-// ============================================================
-// Default Configuration
-// ============================================================
 const DEFAULT_DETERMINISTIC_CONFIG = {
-    gravity: { x: 0, y: fixedFromFloat(-9.81) },
-    maxBodies: 1000,
-    maxIterations: 10,
-    substeps: 4,
-    sleepThreshold: fixedFromFloat(0.01),
-    sleepFrames: 60,
-    broadphase: 'spatial',
-    cellSize: 100,
+  gravity: { x: 0, y: fixedFromFloat(-9.81) },
+  maxBodies: 1e3,
+  maxIterations: 10,
+  substeps: 4,
+  sleepThreshold: fixedFromFloat(0.01),
+  sleepFrames: 60,
+  broadphase: "spatial",
+  cellSize: 100
 };
-// ============================================================
-// Fixed-Point Math
-// ============================================================
 function fixedFromFloat(f) {
-    return Math.round(f * FIXED_ONE);
+  return Math.round(f * FIXED_ONE);
 }
 function fixedToFloat(f) {
-    return f / FIXED_ONE;
+  return f / FIXED_ONE;
 }
 function fixedMul(a, b) {
-    // Use BigInt for overflow protection
-    return Number((BigInt(a) * BigInt(b)) >> BigInt(FIXED_SHIFT));
+  return Number(BigInt(a) * BigInt(b) >> BigInt(FIXED_SHIFT));
 }
 function fixedDiv(a, b) {
-    if (b === 0) {
-        return 0;
-    }
-    return Number((BigInt(a) << BigInt(FIXED_SHIFT)) / BigInt(b));
+  if (b === 0) {
+    return 0;
+  }
+  return Number((BigInt(a) << BigInt(FIXED_SHIFT)) / BigInt(b));
 }
 function fixedSqrt(a) {
-    if (a <= 0) {
-        return 0;
-    }
-    // Newton-Raphson method
-    let x = a;
-    let y = (x + FIXED_ONE) >> 1;
-    while (y < x) {
-        x = y;
-        y = (x + fixedDiv(a, x)) >> 1;
-    }
-    return x;
+  if (a <= 0) {
+    return 0;
+  }
+  let x = a;
+  let y = x + FIXED_ONE >> 1;
+  while (y < x) {
+    x = y;
+    y = x + fixedDiv(a, x) >> 1;
+  }
+  return x;
 }
 function fixedAbs(a) {
-    return a < 0 ? -a : a;
+  return a < 0 ? -a : a;
 }
 function fixedMin(a, b) {
-    return a < b ? a : b;
+  return a < b ? a : b;
 }
 function fixedMax(a, b) {
-    return a > b ? a : b;
+  return a > b ? a : b;
 }
 function fixedClamp(value, min, max) {
-    return fixedMin(fixedMax(value, min), max);
+  return fixedMin(fixedMax(value, min), max);
 }
-// ============================================================
-// Fixed-Point Vector Math
-// ============================================================
 function vec2Add(a, b) {
-    return { x: a.x + b.x, y: a.y + b.y };
+  return { x: a.x + b.x, y: a.y + b.y };
 }
 function vec2Sub(a, b) {
-    return { x: a.x - b.x, y: a.y - b.y };
+  return { x: a.x - b.x, y: a.y - b.y };
 }
 function vec2Scale(v, s) {
-    return { x: fixedMul(v.x, s), y: fixedMul(v.y, s) };
+  return { x: fixedMul(v.x, s), y: fixedMul(v.y, s) };
 }
 function vec2Dot(a, b) {
-    return fixedMul(a.x, b.x) + fixedMul(a.y, b.y);
+  return fixedMul(a.x, b.x) + fixedMul(a.y, b.y);
 }
 function vec2LengthSq(v) {
-    return vec2Dot(v, v);
+  return vec2Dot(v, v);
 }
 function vec2Length(v) {
-    return fixedSqrt(vec2LengthSq(v));
+  return fixedSqrt(vec2LengthSq(v));
 }
 function vec2Normalize(v) {
-    const len = vec2Length(v);
-    if (len === 0) {
-        return { x: 0, y: 0 };
-    }
-    return { x: fixedDiv(v.x, len), y: fixedDiv(v.y, len) };
+  const len = vec2Length(v);
+  if (len === 0) {
+    return { x: 0, y: 0 };
+  }
+  return { x: fixedDiv(v.x, len), y: fixedDiv(v.y, len) };
 }
 function vec2Negate(v) {
-    return { x: -v.x, y: -v.y };
+  return { x: -v.x, y: -v.y };
 }
-// ============================================================
-// Collision Detection
-// ============================================================
 function circleVsCircle(posA, radiusA, posB, radiusB) {
-    const diff = vec2Sub(posB, posA);
-    const distSq = vec2LengthSq(diff);
-    const totalRadius = radiusA + radiusB;
-    const totalRadiusSq = fixedMul(totalRadius, totalRadius);
-    if (distSq >= totalRadiusSq) {
-        return null;
-    }
-    const dist = fixedSqrt(distSq);
-    const normal = dist > 0 ? vec2Normalize(diff) : { x: FIXED_ONE, y: 0 };
-    const penetration = totalRadius - dist;
-    const contactPoint = vec2Add(posA, vec2Scale(normal, radiusA));
-    return {
-        bodyA: '',
-        bodyB: '',
-        normal,
-        penetration,
-        contactPoint,
-    };
+  const diff = vec2Sub(posB, posA);
+  const distSq = vec2LengthSq(diff);
+  const totalRadius = radiusA + radiusB;
+  const totalRadiusSq = fixedMul(totalRadius, totalRadius);
+  if (distSq >= totalRadiusSq) {
+    return null;
+  }
+  const dist = fixedSqrt(distSq);
+  const normal = dist > 0 ? vec2Normalize(diff) : { x: FIXED_ONE, y: 0 };
+  const penetration = totalRadius - dist;
+  const contactPoint = vec2Add(posA, vec2Scale(normal, radiusA));
+  return {
+    bodyA: "",
+    bodyB: "",
+    normal,
+    penetration,
+    contactPoint
+  };
 }
 function aabbVsAABB(posA, halfA, posB, halfB) {
-    const dx = posB.x - posA.x;
-    const dy = posB.y - posA.y;
-    const overlapX = halfA.x + halfB.x - fixedAbs(dx);
-    const overlapY = halfA.y + halfB.y - fixedAbs(dy);
-    if (overlapX <= 0 || overlapY <= 0) {
-        return null;
-    }
-    let normal;
-    let penetration;
-    if (overlapX < overlapY) {
-        penetration = overlapX;
-        normal = { x: dx > 0 ? FIXED_ONE : -FIXED_ONE, y: 0 };
-    }
-    else {
-        penetration = overlapY;
-        normal = { x: 0, y: dy > 0 ? FIXED_ONE : -FIXED_ONE };
-    }
-    const contactPoint = {
-        x: posA.x + fixedMul(normal.x, halfA.x),
-        y: posA.y + fixedMul(normal.y, halfA.y),
-    };
-    return {
-        bodyA: '',
-        bodyB: '',
-        normal,
-        penetration,
-        contactPoint,
-    };
+  const dx = posB.x - posA.x;
+  const dy = posB.y - posA.y;
+  const overlapX = halfA.x + halfB.x - fixedAbs(dx);
+  const overlapY = halfA.y + halfB.y - fixedAbs(dy);
+  if (overlapX <= 0 || overlapY <= 0) {
+    return null;
+  }
+  let normal;
+  let penetration;
+  if (overlapX < overlapY) {
+    penetration = overlapX;
+    normal = { x: dx > 0 ? FIXED_ONE : -FIXED_ONE, y: 0 };
+  } else {
+    penetration = overlapY;
+    normal = { x: 0, y: dy > 0 ? FIXED_ONE : -FIXED_ONE };
+  }
+  const contactPoint = {
+    x: posA.x + fixedMul(normal.x, halfA.x),
+    y: posA.y + fixedMul(normal.y, halfA.y)
+  };
+  return {
+    bodyA: "",
+    bodyB: "",
+    normal,
+    penetration,
+    contactPoint
+  };
 }
 function circleVsAABB(circlePos, radius, aabbPos, halfExtents) {
-    const closestX = fixedClamp(circlePos.x, aabbPos.x - halfExtents.x, aabbPos.x + halfExtents.x);
-    const closestY = fixedClamp(circlePos.y, aabbPos.y - halfExtents.y, aabbPos.y + halfExtents.y);
-    const diff = vec2Sub(circlePos, { x: closestX, y: closestY });
-    const distSq = vec2LengthSq(diff);
-    const radiusSq = fixedMul(radius, radius);
-    if (distSq >= radiusSq) {
-        return null;
-    }
-    const dist = fixedSqrt(distSq);
-    const normal = dist > 0 ? vec2Normalize(diff) : { x: FIXED_ONE, y: 0 };
-    const penetration = radius - dist;
-    const contactPoint = { x: closestX, y: closestY };
-    return {
-        bodyA: '',
-        bodyB: '',
-        normal,
-        penetration,
-        contactPoint,
-    };
+  const closestX = fixedClamp(circlePos.x, aabbPos.x - halfExtents.x, aabbPos.x + halfExtents.x);
+  const closestY = fixedClamp(circlePos.y, aabbPos.y - halfExtents.y, aabbPos.y + halfExtents.y);
+  const diff = vec2Sub(circlePos, { x: closestX, y: closestY });
+  const distSq = vec2LengthSq(diff);
+  const radiusSq = fixedMul(radius, radius);
+  if (distSq >= radiusSq) {
+    return null;
+  }
+  const dist = fixedSqrt(distSq);
+  const normal = dist > 0 ? vec2Normalize(diff) : { x: FIXED_ONE, y: 0 };
+  const penetration = radius - dist;
+  const contactPoint = { x: closestX, y: closestY };
+  return {
+    bodyA: "",
+    bodyB: "",
+    normal,
+    penetration,
+    contactPoint
+  };
 }
-// ============================================================
-// Spatial Hash (Fixed-Point)
-// ============================================================
 class FixedSpatialHash {
-    constructor(cellSize) {
-        this.cells = new Map();
-        this.bodyPositions = new Map();
-        this.cellSize = cellSize;
-    }
-    getCellKey(pos) {
-        const cellX = Math.floor(fixedToFloat(pos.x) / this.cellSize);
-        const cellY = Math.floor(fixedToFloat(pos.y) / this.cellSize);
-        return `${cellX},${cellY}`;
-    }
-    insert(id, position) {
-        const key = this.getCellKey(position);
-        if (!this.cells.has(key)) {
-            this.cells.set(key, new Set());
+  constructor(cellSize) {
+    this.cells = /* @__PURE__ */ new Map();
+    this.bodyPositions = /* @__PURE__ */ new Map();
+    this.cellSize = cellSize;
+  }
+  getCellKey(pos) {
+    const cellX = Math.floor(fixedToFloat(pos.x) / this.cellSize);
+    const cellY = Math.floor(fixedToFloat(pos.y) / this.cellSize);
+    return `${cellX},${cellY}`;
+  }
+  insert(id, position) {
+    const key = this.getCellKey(position);
+    if (!this.cells.has(key)) {
+      this.cells.set(key, /* @__PURE__ */ new Set());
+    }
+    this.cells.get(key).add(id);
+    this.bodyPositions.set(id, { ...position });
+  }
+  update(id, newPosition) {
+    const oldPosition = this.bodyPositions.get(id);
+    if (oldPosition) {
+      const oldKey = this.getCellKey(oldPosition);
+      const newKey = this.getCellKey(newPosition);
+      if (oldKey !== newKey) {
+        this.cells.get(oldKey)?.delete(id);
+        if (!this.cells.has(newKey)) {
+          this.cells.set(newKey, /* @__PURE__ */ new Set());
         }
-        this.cells.get(key).add(id);
-        this.bodyPositions.set(id, { ...position });
-    }
-    update(id, newPosition) {
-        const oldPosition = this.bodyPositions.get(id);
-        if (oldPosition) {
-            const oldKey = this.getCellKey(oldPosition);
-            const newKey = this.getCellKey(newPosition);
-            if (oldKey !== newKey) {
-                this.cells.get(oldKey)?.delete(id);
-                if (!this.cells.has(newKey)) {
-                    this.cells.set(newKey, new Set());
-                }
-                this.cells.get(newKey).add(id);
+        this.cells.get(newKey).add(id);
+      }
+    }
+    this.bodyPositions.set(id, { ...newPosition });
+  }
+  remove(id) {
+    const position = this.bodyPositions.get(id);
+    if (position) {
+      const key = this.getCellKey(position);
+      this.cells.get(key)?.delete(id);
+      this.bodyPositions.delete(id);
+    }
+  }
+  queryNearby(id) {
+    const position = this.bodyPositions.get(id);
+    if (!position) {
+      return [];
+    }
+    const results = [];
+    const cellX = Math.floor(fixedToFloat(position.x) / this.cellSize);
+    const cellY = Math.floor(fixedToFloat(position.y) / this.cellSize);
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        const key = `${cellX + dx},${cellY + dy}`;
+        const cell = this.cells.get(key);
+        if (cell) {
+          for (const otherId of cell) {
+            if (otherId !== id) {
+              results.push(otherId);
             }
+          }
         }
-        this.bodyPositions.set(id, { ...newPosition });
-    }
-    remove(id) {
-        const position = this.bodyPositions.get(id);
-        if (position) {
-            const key = this.getCellKey(position);
-            this.cells.get(key)?.delete(id);
-            this.bodyPositions.delete(id);
-        }
-    }
-    queryNearby(id) {
-        const position = this.bodyPositions.get(id);
-        if (!position) {
-            return [];
-        }
-        const results = [];
-        const cellX = Math.floor(fixedToFloat(position.x) / this.cellSize);
-        const cellY = Math.floor(fixedToFloat(position.y) / this.cellSize);
-        for (let dx = -1; dx <= 1; dx++) {
-            for (let dy = -1; dy <= 1; dy++) {
-                const key = `${cellX + dx},${cellY + dy}`;
-                const cell = this.cells.get(key);
-                if (cell) {
-                    for (const otherId of cell) {
-                        if (otherId !== id) {
-                            results.push(otherId);
-                        }
-                    }
-                }
-            }
-        }
-        return results;
-    }
-    clear() {
-        this.cells.clear();
-        this.bodyPositions.clear();
-    }
+      }
+    }
+    return results;
+  }
+  clear() {
+    this.cells.clear();
+    this.bodyPositions.clear();
+  }
 }
-// ============================================================
-// Deterministic Physics World
-// ============================================================
 class DeterministicWorld {
-    constructor(config) {
-        this.bodies = new Map();
-        this.frame = 0;
-        this.collisionPairs = [];
-        this.config = { ...DEFAULT_DETERMINISTIC_CONFIG, ...config };
-        this.spatialHash = new FixedSpatialHash(this.config.cellSize);
-    }
-    // ─── Body Management ───────────────────────────────────
-    addBody(body) {
-        this.bodies.set(body.id, body);
-        if (this.config.broadphase === 'spatial') {
-            this.spatialHash.insert(body.id, body.position);
+  constructor(config) {
+    this.bodies = /* @__PURE__ */ new Map();
+    this.frame = 0;
+    this.collisionPairs = [];
+    this.config = { ...DEFAULT_DETERMINISTIC_CONFIG, ...config };
+    this.spatialHash = new FixedSpatialHash(this.config.cellSize);
+  }
+  // ─── Body Management ───────────────────────────────────
+  addBody(body) {
+    this.bodies.set(body.id, body);
+    if (this.config.broadphase === "spatial") {
+      this.spatialHash.insert(body.id, body.position);
+    }
+  }
+  removeBody(id) {
+    this.bodies.delete(id);
+    if (this.config.broadphase === "spatial") {
+      this.spatialHash.remove(id);
+    }
+  }
+  getBody(id) {
+    return this.bodies.get(id);
+  }
+  // ─── Simulation ────────────────────────────────────────
+  step(dt) {
+    const substepDt = fixedDiv(dt, fixedFromFloat(this.config.substeps));
+    for (let i = 0; i < this.config.substeps; i++) {
+      this.integrate(substepDt);
+      this.broadphase();
+      this.narrowphase();
+      this.resolveCollisions();
+    }
+    if (this.config.broadphase === "spatial") {
+      for (const body of this.bodies.values()) {
+        this.spatialHash.update(body.id, body.position);
+      }
+    }
+    this.frame++;
+  }
+  integrate(dt) {
+    for (const body of this.bodies.values()) {
+      if (body.isStatic) {
+        continue;
+      }
+      body.acceleration = vec2Add(body.acceleration, this.config.gravity);
+      body.velocity = vec2Add(body.velocity, vec2Scale(body.acceleration, dt));
+      body.position = vec2Add(body.position, vec2Scale(body.velocity, dt));
+      body.acceleration = { x: 0, y: 0 };
+    }
+  }
+  broadphase() {
+    this.collisionPairs = [];
+    const checked = /* @__PURE__ */ new Set();
+    for (const body of this.bodies.values()) {
+      let candidates;
+      if (this.config.broadphase === "spatial") {
+        candidates = this.spatialHash.queryNearby(body.id);
+      } else {
+        candidates = Array.from(this.bodies.keys()).filter((id) => id !== body.id);
+      }
+      for (const otherId of candidates) {
+        const pairKey = body.id < otherId ? `${body.id}:${otherId}` : `${otherId}:${body.id}`;
+        if (checked.has(pairKey)) {
+          continue;
         }
-    }
-    removeBody(id) {
-        this.bodies.delete(id);
-        if (this.config.broadphase === 'spatial') {
-            this.spatialHash.remove(id);
+        checked.add(pairKey);
+        const other = this.bodies.get(otherId);
+        if (!other) {
+          continue;
         }
-    }
-    getBody(id) {
-        return this.bodies.get(id);
-    }
-    // ─── Simulation ────────────────────────────────────────
-    step(dt) {
-        const substepDt = fixedDiv(dt, fixedFromFloat(this.config.substeps));
-        for (let i = 0; i < this.config.substeps; i++) {
-            this.integrate(substepDt);
-            this.broadphase();
-            this.narrowphase();
-            this.resolveCollisions();
+        if (!this.shouldCollide(body, other)) {
+          continue;
         }
-        // Update spatial hash positions
-        if (this.config.broadphase === 'spatial') {
-            for (const body of this.bodies.values()) {
-                this.spatialHash.update(body.id, body.position);
-            }
+        const pair = this.testCollision(body, other);
+        if (pair) {
+          pair.bodyA = body.id;
+          pair.bodyB = otherId;
+          this.collisionPairs.push(pair);
         }
-        this.frame++;
-    }
-    integrate(dt) {
-        for (const body of this.bodies.values()) {
-            if (body.isStatic) {
-                continue;
-            }
-            // Apply gravity
-            body.acceleration = vec2Add(body.acceleration, this.config.gravity);
-            // Semi-implicit Euler integration
-            body.velocity = vec2Add(body.velocity, vec2Scale(body.acceleration, dt));
-            body.position = vec2Add(body.position, vec2Scale(body.velocity, dt));
-            // Reset acceleration
-            body.acceleration = { x: 0, y: 0 };
+      }
+    }
+  }
+  shouldCollide(a, b) {
+    return (a.collisionMask & b.collisionLayer) !== 0 && (b.collisionMask & a.collisionLayer) !== 0;
+  }
+  narrowphase() {
+  }
+  testCollision(a, b) {
+    if (a.shape.type === "circle" && b.shape.type === "circle") {
+      return circleVsCircle(a.position, a.shape.radius, b.position, b.shape.radius);
+    }
+    if (a.shape.type === "aabb" && b.shape.type === "aabb") {
+      return aabbVsAABB(a.position, { x: a.shape.halfWidth, y: a.shape.halfHeight }, b.position, {
+        x: b.shape.halfWidth,
+        y: b.shape.halfHeight
+      });
+    }
+    if (a.shape.type === "circle" && b.shape.type === "aabb") {
+      return circleVsAABB(a.position, a.shape.radius, b.position, {
+        x: b.shape.halfWidth,
+        y: b.shape.halfHeight
+      });
+    }
+    if (a.shape.type === "aabb" && b.shape.type === "circle") {
+      const result = circleVsAABB(b.position, b.shape.radius, a.position, {
+        x: a.shape.halfWidth,
+        y: a.shape.halfHeight
+      });
+      if (result) {
+        result.normal = vec2Negate(result.normal);
+      }
+      return result;
+    }
+    return null;
+  }
+  resolveCollisions() {
+    for (let iter = 0; iter < this.config.maxIterations; iter++) {
+      for (const pair of this.collisionPairs) {
+        const bodyA = this.bodies.get(pair.bodyA);
+        const bodyB = this.bodies.get(pair.bodyB);
+        if (!bodyA || !bodyB) {
+          continue;
         }
-    }
-    broadphase() {
-        this.collisionPairs = [];
-        const checked = new Set();
-        for (const body of this.bodies.values()) {
-            let candidates;
-            if (this.config.broadphase === 'spatial') {
-                candidates = this.spatialHash.queryNearby(body.id);
-            }
-            else {
-                candidates = Array.from(this.bodies.keys()).filter((id) => id !== body.id);
-            }
-            for (const otherId of candidates) {
-                const pairKey = body.id < otherId ? `${body.id}:${otherId}` : `${otherId}:${body.id}`;
-                if (checked.has(pairKey)) {
-                    continue;
-                }
-                checked.add(pairKey);
-                const other = this.bodies.get(otherId);
-                if (!other) {
-                    continue;
-                }
-                // Check collision masks
-                if (!this.shouldCollide(body, other)) {
-                    continue;
-                }
-                const pair = this.testCollision(body, other);
-                if (pair) {
-                    pair.bodyA = body.id;
-                    pair.bodyB = otherId;
-                    this.collisionPairs.push(pair);
-                }
-            }
+        if (bodyA.isTrigger || bodyB.isTrigger) {
+          this.onTrigger?.(pair.bodyA, pair.bodyB);
+          continue;
         }
-    }
-    shouldCollide(a, b) {
-        return (a.collisionMask & b.collisionLayer) !== 0 && (b.collisionMask & a.collisionLayer) !== 0;
-    }
-    narrowphase() {
-        // Already done in broadphase for this implementation
-    }
-    testCollision(a, b) {
-        if (a.shape.type === 'circle' && b.shape.type === 'circle') {
-            return circleVsCircle(a.position, a.shape.radius, b.position, b.shape.radius);
+        this.onCollision?.(pair);
+        if (bodyA.isStatic && bodyB.isStatic) {
+          continue;
         }
-        if (a.shape.type === 'aabb' && b.shape.type === 'aabb') {
-            return aabbVsAABB(a.position, { x: a.shape.halfWidth, y: a.shape.halfHeight }, b.position, {
-                x: b.shape.halfWidth,
-                y: b.shape.halfHeight,
-            });
+        const invMassA = bodyA.isStatic ? 0 : fixedDiv(FIXED_ONE, bodyA.mass);
+        const invMassB = bodyB.isStatic ? 0 : fixedDiv(FIXED_ONE, bodyB.mass);
+        const totalInvMass = invMassA + invMassB;
+        if (totalInvMass === 0) {
+          continue;
         }
-        if (a.shape.type === 'circle' && b.shape.type === 'aabb') {
-            return circleVsAABB(a.position, a.shape.radius, b.position, {
-                x: b.shape.halfWidth,
-                y: b.shape.halfHeight,
-            });
+        const correction = vec2Scale(
+          pair.normal,
+          fixedDiv(pair.penetration, fixedFromFloat(fixedToFloat(totalInvMass)))
+        );
+        if (!bodyA.isStatic) {
+          const corrA = vec2Scale(correction, invMassA);
+          bodyA.position = vec2Sub(bodyA.position, corrA);
         }
-        if (a.shape.type === 'aabb' && b.shape.type === 'circle') {
-            const result = circleVsAABB(b.position, b.shape.radius, a.position, {
-                x: a.shape.halfWidth,
-                y: a.shape.halfHeight,
-            });
-            if (result) {
-                result.normal = vec2Negate(result.normal);
-            }
-            return result;
+        if (!bodyB.isStatic) {
+          const corrB = vec2Scale(correction, invMassB);
+          bodyB.position = vec2Add(bodyB.position, corrB);
         }
-        return null;
-    }
-    resolveCollisions() {
-        for (let iter = 0; iter < this.config.maxIterations; iter++) {
-            for (const pair of this.collisionPairs) {
-                const bodyA = this.bodies.get(pair.bodyA);
-                const bodyB = this.bodies.get(pair.bodyB);
-                if (!bodyA || !bodyB) {
-                    continue;
-                }
-                // Trigger callback
-                if (bodyA.isTrigger || bodyB.isTrigger) {
-                    this.onTrigger?.(pair.bodyA, pair.bodyB);
-                    continue;
-                }
-                this.onCollision?.(pair);
-                // Both static - skip
-                if (bodyA.isStatic && bodyB.isStatic) {
-                    continue;
-                }
-                // Calculate inverse masses
-                const invMassA = bodyA.isStatic ? 0 : fixedDiv(FIXED_ONE, bodyA.mass);
-                const invMassB = bodyB.isStatic ? 0 : fixedDiv(FIXED_ONE, bodyB.mass);
-                const totalInvMass = invMassA + invMassB;
-                if (totalInvMass === 0) {
-                    continue;
-                }
-                // Positional correction
-                const correction = vec2Scale(pair.normal, fixedDiv(pair.penetration, fixedFromFloat(fixedToFloat(totalInvMass))));
-                if (!bodyA.isStatic) {
-                    const corrA = vec2Scale(correction, invMassA);
-                    bodyA.position = vec2Sub(bodyA.position, corrA);
-                }
-                if (!bodyB.isStatic) {
-                    const corrB = vec2Scale(correction, invMassB);
-                    bodyB.position = vec2Add(bodyB.position, corrB);
-                }
-                // Velocity resolution
-                const relVel = vec2Sub(bodyB.velocity, bodyA.velocity);
-                const velAlongNormal = vec2Dot(relVel, pair.normal);
-                if (velAlongNormal > 0) {
-                    continue;
-                }
-                const restitution = fixedMin(bodyA.restitution, bodyB.restitution);
-                const j = fixedDiv(fixedMul(-(FIXED_ONE + restitution), velAlongNormal), totalInvMass);
-                const impulse = vec2Scale(pair.normal, j);
-                if (!bodyA.isStatic) {
-                    bodyA.velocity = vec2Sub(bodyA.velocity, vec2Scale(impulse, invMassA));
-                }
-                if (!bodyB.isStatic) {
-                    bodyB.velocity = vec2Add(bodyB.velocity, vec2Scale(impulse, invMassB));
-                }
-                // Friction
-                const tangent = vec2Normalize({
-                    x: relVel.x - fixedMul(velAlongNormal, pair.normal.x),
-                    y: relVel.y - fixedMul(velAlongNormal, pair.normal.y),
-                });
-                const friction = fixedMul(bodyA.friction, bodyB.friction);
-                const frictionImpulse = vec2Scale(tangent, fixedMul(j, friction));
-                if (!bodyA.isStatic) {
-                    bodyA.velocity = vec2Add(bodyA.velocity, vec2Scale(frictionImpulse, invMassA));
-                }
-                if (!bodyB.isStatic) {
-                    bodyB.velocity = vec2Sub(bodyB.velocity, vec2Scale(frictionImpulse, invMassB));
-                }
-            }
+        const relVel = vec2Sub(bodyB.velocity, bodyA.velocity);
+        const velAlongNormal = vec2Dot(relVel, pair.normal);
+        if (velAlongNormal > 0) {
+          continue;
         }
-    }
-    // ─── State Management ──────────────────────────────────
-    getState() {
-        const bodies = Array.from(this.bodies.values()).map((b) => ({
-            ...b,
-            position: { ...b.position },
-            velocity: { ...b.velocity },
-            acceleration: { ...b.acceleration },
-        }));
-        return {
-            frame: this.frame,
-            bodies,
-            hash: this.calculateHash(),
-        };
-    }
-    setState(state) {
-        this.frame = state.frame;
-        this.bodies.clear();
-        this.spatialHash.clear();
-        for (const body of state.bodies) {
-            this.addBody({ ...body });
+        const restitution = fixedMin(bodyA.restitution, bodyB.restitution);
+        const j = fixedDiv(fixedMul(-(FIXED_ONE + restitution), velAlongNormal), totalInvMass);
+        const impulse = vec2Scale(pair.normal, j);
+        if (!bodyA.isStatic) {
+          bodyA.velocity = vec2Sub(bodyA.velocity, vec2Scale(impulse, invMassA));
         }
-    }
-    calculateHash() {
-        let hash = this.frame;
-        for (const body of this.bodies.values()) {
-            hash ^= body.position.x;
-            hash ^= body.position.y << 8;
-            hash ^= body.velocity.x << 16;
-            hash ^= body.velocity.y << 24;
+        if (!bodyB.isStatic) {
+          bodyB.velocity = vec2Add(bodyB.velocity, vec2Scale(impulse, invMassB));
         }
-        return hash >>> 0;
-    }
-    // ─── Frame ─────────────────────────────────────────────
-    getFrame() {
-        return this.frame;
-    }
-    setFrame(frame) {
-        this.frame = frame;
-    }
-    // ─── Force Application ─────────────────────────────────
-    applyForce(bodyId, force) {
-        const body = this.bodies.get(bodyId);
-        if (body && !body.isStatic) {
-            const accel = { x: fixedDiv(force.x, body.mass), y: fixedDiv(force.y, body.mass) };
-            body.acceleration = vec2Add(body.acceleration, accel);
+        const tangent = vec2Normalize({
+          x: relVel.x - fixedMul(velAlongNormal, pair.normal.x),
+          y: relVel.y - fixedMul(velAlongNormal, pair.normal.y)
+        });
+        const friction = fixedMul(bodyA.friction, bodyB.friction);
+        const frictionImpulse = vec2Scale(tangent, fixedMul(j, friction));
+        if (!bodyA.isStatic) {
+          bodyA.velocity = vec2Add(bodyA.velocity, vec2Scale(frictionImpulse, invMassA));
         }
-    }
-    applyImpulse(bodyId, impulse) {
-        const body = this.bodies.get(bodyId);
-        if (body && !body.isStatic) {
-            const velChange = { x: fixedDiv(impulse.x, body.mass), y: fixedDiv(impulse.y, body.mass) };
-            body.velocity = vec2Add(body.velocity, velChange);
+        if (!bodyB.isStatic) {
+          bodyB.velocity = vec2Sub(bodyB.velocity, vec2Scale(frictionImpulse, invMassB));
         }
-    }
-    setVelocity(bodyId, velocity) {
-        const body = this.bodies.get(bodyId);
-        if (body && !body.isStatic) {
-            body.velocity = { ...velocity };
-        }
-    }
-    setPosition(bodyId, position) {
-        const body = this.bodies.get(bodyId);
-        if (body) {
-            body.position = { ...position };
-            if (this.config.broadphase === 'spatial') {
-                this.spatialHash.update(bodyId, position);
-            }
-        }
-    }
-    // ─── Callbacks ─────────────────────────────────────────
-    setOnCollision(callback) {
-        this.onCollision = callback;
-    }
-    setOnTrigger(callback) {
-        this.onTrigger = callback;
-    }
-    // ─── Cleanup ───────────────────────────────────────────
-    clear() {
-        this.bodies.clear();
-        this.spatialHash.clear();
-        this.collisionPairs = [];
-        this.frame = 0;
-    }
+      }
+    }
+  }
+  // ─── State Management ──────────────────────────────────
+  getState() {
+    const bodies = Array.from(this.bodies.values()).map((b) => ({
+      ...b,
+      position: { ...b.position },
+      velocity: { ...b.velocity },
+      acceleration: { ...b.acceleration }
+    }));
+    return {
+      frame: this.frame,
+      bodies,
+      hash: this.calculateHash()
+    };
+  }
+  setState(state) {
+    this.frame = state.frame;
+    this.bodies.clear();
+    this.spatialHash.clear();
+    for (const body of state.bodies) {
+      this.addBody({ ...body });
+    }
+  }
+  calculateHash() {
+    let hash = this.frame;
+    for (const body of this.bodies.values()) {
+      hash ^= body.position.x;
+      hash ^= body.position.y << 8;
+      hash ^= body.velocity.x << 16;
+      hash ^= body.velocity.y << 24;
+    }
+    return hash >>> 0;
+  }
+  // ─── Frame ─────────────────────────────────────────────
+  getFrame() {
+    return this.frame;
+  }
+  setFrame(frame) {
+    this.frame = frame;
+  }
+  // ─── Force Application ─────────────────────────────────
+  applyForce(bodyId, force) {
+    const body = this.bodies.get(bodyId);
+    if (body && !body.isStatic) {
+      const accel = { x: fixedDiv(force.x, body.mass), y: fixedDiv(force.y, body.mass) };
+      body.acceleration = vec2Add(body.acceleration, accel);
+    }
+  }
+  applyImpulse(bodyId, impulse) {
+    const body = this.bodies.get(bodyId);
+    if (body && !body.isStatic) {
+      const velChange = { x: fixedDiv(impulse.x, body.mass), y: fixedDiv(impulse.y, body.mass) };
+      body.velocity = vec2Add(body.velocity, velChange);
+    }
+  }
+  setVelocity(bodyId, velocity) {
+    const body = this.bodies.get(bodyId);
+    if (body && !body.isStatic) {
+      body.velocity = { ...velocity };
+    }
+  }
+  setPosition(bodyId, position) {
+    const body = this.bodies.get(bodyId);
+    if (body) {
+      body.position = { ...position };
+      if (this.config.broadphase === "spatial") {
+        this.spatialHash.update(bodyId, position);
+      }
+    }
+  }
+  // ─── Callbacks ─────────────────────────────────────────
+  setOnCollision(callback) {
+    this.onCollision = callback;
+  }
+  setOnTrigger(callback) {
+    this.onTrigger = callback;
+  }
+  // ─── Cleanup ───────────────────────────────────────────
+  clear() {
+    this.bodies.clear();
+    this.spatialHash.clear();
+    this.collisionPairs = [];
+    this.frame = 0;
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createDeterministicWorld(config) {
-    return new DeterministicWorld(config);
+  return new DeterministicWorld(config);
 }
 function createCircleBody(id, position, radius, options) {
-    return {
-        id,
-        position,
-        velocity: { x: 0, y: 0 },
-        acceleration: { x: 0, y: 0 },
-        mass: options?.mass ?? FIXED_ONE,
-        restitution: options?.restitution ?? fixedFromFloat(0.5),
-        friction: options?.friction ?? fixedFromFloat(0.3),
-        isStatic: options?.isStatic ?? false,
-        isTrigger: options?.isTrigger ?? false,
-        collisionMask: options?.collisionMask ?? 0xffffffff,
-        collisionLayer: options?.collisionLayer ?? 1,
-        shape: { type: 'circle', radius },
-        userData: options?.userData,
-    };
+  return {
+    id,
+    position,
+    velocity: { x: 0, y: 0 },
+    acceleration: { x: 0, y: 0 },
+    mass: options?.mass ?? FIXED_ONE,
+    restitution: options?.restitution ?? fixedFromFloat(0.5),
+    friction: options?.friction ?? fixedFromFloat(0.3),
+    isStatic: options?.isStatic ?? false,
+    isTrigger: options?.isTrigger ?? false,
+    collisionMask: options?.collisionMask ?? 4294967295,
+    collisionLayer: options?.collisionLayer ?? 1,
+    shape: { type: "circle", radius },
+    userData: options?.userData
+  };
 }
 function createBoxBody(id, position, halfWidth, halfHeight, options) {
-    return {
-        id,
-        position,
-        velocity: { x: 0, y: 0 },
-        acceleration: { x: 0, y: 0 },
-        mass: options?.mass ?? FIXED_ONE,
-        restitution: options?.restitution ?? fixedFromFloat(0.5),
-        friction: options?.friction ?? fixedFromFloat(0.3),
-        isStatic: options?.isStatic ?? false,
-        isTrigger: options?.isTrigger ?? false,
-        collisionMask: options?.collisionMask ?? 0xffffffff,
-        collisionLayer: options?.collisionLayer ?? 1,
-        shape: { type: 'aabb', halfWidth, halfHeight },
-        userData: options?.userData,
-    };
+  return {
+    id,
+    position,
+    velocity: { x: 0, y: 0 },
+    acceleration: { x: 0, y: 0 },
+    mass: options?.mass ?? FIXED_ONE,
+    restitution: options?.restitution ?? fixedFromFloat(0.5),
+    friction: options?.friction ?? fixedFromFloat(0.3),
+    isStatic: options?.isStatic ?? false,
+    isTrigger: options?.isTrigger ?? false,
+    collisionMask: options?.collisionMask ?? 4294967295,
+    collisionLayer: options?.collisionLayer ?? 1,
+    shape: { type: "aabb", halfWidth, halfHeight },
+    userData: options?.userData
+  };
 }
 function createStaticBody(id, position, halfWidth, halfHeight) {
-    return createBoxBody(id, position, halfWidth, halfHeight, { isStatic: true });
+  return createBoxBody(id, position, halfWidth, halfHeight, { isStatic: true });
 }
-
-export { DEFAULT_DETERMINISTIC_CONFIG, DeterministicWorld, FIXED_HALF, FIXED_ONE, FIXED_SHIFT, aabbVsAABB, circleVsAABB, circleVsCircle, createBoxBody, createCircleBody, createDeterministicWorld, createStaticBody, fixedAbs, fixedClamp, fixedDiv, fixedFromFloat, fixedMax, fixedMin, fixedMul, fixedSqrt, fixedToFloat, vec2Add, vec2Dot, vec2Length, vec2LengthSq, vec2Negate, vec2Normalize, vec2Scale, vec2Sub };
+export {
+  DEFAULT_DETERMINISTIC_CONFIG,
+  DeterministicWorld,
+  FIXED_HALF,
+  FIXED_ONE,
+  FIXED_SHIFT,
+  aabbVsAABB,
+  circleVsAABB,
+  circleVsCircle,
+  createBoxBody,
+  createCircleBody,
+  createDeterministicWorld,
+  createStaticBody,
+  fixedAbs,
+  fixedClamp,
+  fixedDiv,
+  fixedFromFloat,
+  fixedMax,
+  fixedMin,
+  fixedMul,
+  fixedSqrt,
+  fixedToFloat,
+  vec2Add,
+  vec2Dot,
+  vec2Length,
+  vec2LengthSq,
+  vec2Negate,
+  vec2Normalize,
+  vec2Scale,
+  vec2Sub
+};