dacha 0.17.2 → 0.18.0-alpha.0

package/build/contrib/systems/physics-system/subsystems/collision-detection/index.js

@@ -1,7 +1,6 @@
 import { ActorQuery } from '../../../../../engine/actor';
 import { Transform, Collider, RigidBody } from '../../../../components';
 import { AddActor, RemoveActor } from '../../../../../engine/events';
-import { Collision } from '../../../../events';
 import { insertionSort } from '../../../../../engine/data-lib';
 import { geometryBuilders } from './geometry-builders';
 import { aabbBuilders } from './aabb-builders';
@@ -10,17 +9,18 @@ import { DispersionCalculator } from './dispersion-calculator';
 import { checkTransform, checkCollider } from './reorientation-checkers';
 export class CollisionDetectionSubsystem {
     actorQuery;
-    scene;
     axis;
-    entriesMap;
-    collisionPairs;
-    entriesToDelete;
+    proxiesByActorId;
+    proxyPairs;
+    contacts;
+    actorIdsToDelete;
+    collisionMatrix;
     constructor(options) {
+        const settings = options.globalOptions.physics;
         this.actorQuery = new ActorQuery({
             scene: options.scene,
             filter: [Collider, Transform],
         });
-        this.scene = options.scene;
         this.axis = {
             x: {
                 sortedList: [],
@@ -31,12 +31,12 @@ export class CollisionDetectionSubsystem {
                 dispersionCalculator: new DispersionCalculator('y'),
             },
         };
-        this.entriesMap = new Map();
-        this.collisionPairs = [];
-        this.entriesToDelete = new Set();
-        this.actorQuery
-            .getActors()
-            .forEach((actor) => this.addCollisionEntry(actor));
+        this.proxiesByActorId = new Map();
+        this.proxyPairs = [];
+        this.contacts = [];
+        this.actorIdsToDelete = new Set();
+        this.collisionMatrix = settings?.collisionMatrix ?? {};
+        this.actorQuery.getActors().forEach((actor) => this.addProxy(actor));
         this.actorQuery.addEventListener(AddActor, this.handleActorAdd);
         this.actorQuery.addEventListener(RemoveActor, this.handleActorRemove);
     }
@@ -45,20 +45,20 @@ export class CollisionDetectionSubsystem {
         this.actorQuery.removeEventListener(RemoveActor, this.handleActorRemove);
     }
     handleActorAdd = (event) => {
-        this.addCollisionEntry(event.actor);
+        this.addProxy(event.actor);
     };
     handleActorRemove = (event) => {
-        this.entriesToDelete.add(event.actor.id);
+        this.actorIdsToDelete.add(event.actor.id);
     };
     checkOnReorientation(actor) {
-        const entry = this.entriesMap.get(actor.id);
-        if (!entry) {
+        const proxy = this.proxiesByActorId.get(actor.id);
+        if (!proxy) {
             return true;
         }
         const transform = actor.getComponent(Transform);
         const collider = actor.getComponent(Collider);
-        const transformOld = entry.orientationData.transform;
-        const colliderOld = entry.orientationData.collider;
+        const transformOld = proxy.orientationData.transform;
+        const colliderOld = proxy.orientationData.collider;
         return (checkTransform(transform, transformOld) ||
             checkCollider(collider, colliderOld));
     }
@@ -80,155 +80,169 @@ export class CollisionDetectionSubsystem {
                 sizeX: collider.sizeX,
                 sizeY: collider.sizeY,
                 radius: collider.radius,
+                layer: collider.layer,
             },
         };
     }
-    addCollisionEntry(actor) {
+    addProxy(actor) {
         const transform = actor.getComponent(Transform);
         const collider = actor.getComponent(Collider);
         const geometry = geometryBuilders[collider.type](collider, transform);
         const aabb = aabbBuilders[collider.type](geometry);
-        const entry = {
+        const proxy = {
             actor,
             aabb,
             geometry,
             orientationData: this.getOrientationData(actor),
         };
         this.axis.x.dispersionCalculator.addToSample(aabb);
-        this.addToSortedList(entry, 'x');
+        this.addToSortedList(proxy, 'x');
         this.axis.y.dispersionCalculator.addToSample(aabb);
-        this.addToSortedList(entry, 'y');
-        this.entriesMap.set(actor.id, entry);
+        this.addToSortedList(proxy, 'y');
+        this.proxiesByActorId.set(actor.id, proxy);
     }
-    updateCollisionEntry(actor) {
+    updateProxy(actor) {
         const transform = actor.getComponent(Transform);
         const collider = actor.getComponent(Collider);
         const geometry = geometryBuilders[collider.type](collider, transform);
         const aabb = aabbBuilders[collider.type](geometry);
-        const entry = this.entriesMap.get(actor.id);
-        const prevAABB = entry.aabb;
-        entry.aabb = aabb;
-        entry.geometry = geometry;
-        entry.orientationData = this.getOrientationData(actor);
+        const proxy = this.proxiesByActorId.get(actor.id);
+        const prevAABB = proxy.aabb;
+        proxy.aabb = aabb;
+        proxy.geometry = geometry;
+        proxy.orientationData = this.getOrientationData(actor);
         this.axis.x.dispersionCalculator.removeFromSample(prevAABB);
         this.axis.x.dispersionCalculator.addToSample(aabb);
-        this.updateSortedList(entry, 'x');
+        this.updateSortedList(proxy, 'x');
         this.axis.y.dispersionCalculator.removeFromSample(prevAABB);
         this.axis.y.dispersionCalculator.addToSample(aabb);
-        this.updateSortedList(entry, 'y');
+        this.updateSortedList(proxy, 'y');
     }
-    addToSortedList(entry, axis) {
-        const min = { value: entry.aabb.min[axis], entry };
-        const max = { value: entry.aabb.max[axis], entry };
+    addToSortedList(proxy, axis) {
+        const min = { value: proxy.aabb.min[axis], proxy };
+        const max = { value: proxy.aabb.max[axis], proxy };
         this.axis[axis].sortedList.push(min, max);
-        entry.edges ??= {};
-        entry.edges[axis] = [min, max];
+        proxy.edges ??= {};
+        proxy.edges[axis] = [min, max];
     }
-    updateSortedList(entry, axis) {
-        const [min, max] = entry.edges[axis];
-        min.value = entry.aabb.min[axis];
-        min.entry = entry;
-        max.value = entry.aabb.max[axis];
-        max.entry = entry;
+    updateSortedList(proxy, axis) {
+        const [min, max] = proxy.edges[axis];
+        min.value = proxy.aabb.min[axis];
+        min.proxy = proxy;
+        max.value = proxy.aabb.max[axis];
+        max.proxy = proxy;
     }
     clearSortedList(axis) {
-        this.axis[axis].sortedList = this.axis[axis].sortedList.filter((item) => !this.entriesToDelete.has(item.entry.actor.id));
+        this.axis[axis].sortedList = this.axis[axis].sortedList.filter((item) => !this.actorIdsToDelete.has(item.proxy.actor.id));
     }
     getAxes() {
         const xDispersion = this.axis.x.dispersionCalculator.getDispersion();
         const yDispersion = this.axis.y.dispersionCalculator.getDispersion();
         return xDispersion >= yDispersion ? ['x', 'y'] : ['y', 'x'];
     }
-    areStaticBodies(entry1, entry2) {
-        const { actor: actor1 } = entry1;
-        const { actor: actor2 } = entry2;
+    areStaticBodies(proxy1, proxy2) {
+        const { actor: actor1 } = proxy1;
+        const { actor: actor2 } = proxy2;
         const rigidBody1 = actor1.getComponent(RigidBody);
         const rigidBody2 = actor2.getComponent(RigidBody);
         return rigidBody1?.type === 'static' && rigidBody2?.type === 'static';
     }
-    testAABB(entry1, entry2, axis) {
-        const aabb1 = entry1.aabb;
-        const aabb2 = entry2.aabb;
+    testAABB(proxy1, proxy2, axis) {
+        const aabb1 = proxy1.aabb;
+        const aabb2 = proxy2.aabb;
         return (aabb1.max[axis] > aabb2.min[axis] && aabb1.min[axis] < aabb2.max[axis]);
     }
+    testCollisionLayers(proxy1, proxy2) {
+        const collider1 = proxy1.actor.getComponent(Collider);
+        const collider2 = proxy2.actor.getComponent(Collider);
+        return this.collisionMatrix[collider1.layer]?.[collider2.layer] ?? true;
+    }
     sweepAndPrune() {
         const [mainAxis, secondAxis] = this.getAxes();
         const { sortedList } = this.axis[mainAxis];
         insertionSort(sortedList, (arg1, arg2) => arg1.value - arg2.value);
-        const activeEntries = new Set();
-        let collisionIndex = 0;
+        const activeProxies = new Set();
+        let proxyPairIndex = 0;
         for (const item of sortedList) {
-            const { entry } = item;
-            if (!activeEntries.has(entry)) {
-                activeEntries.forEach((activeEntry) => {
-                    if (!this.testAABB(entry, activeEntry, secondAxis)) {
+            const { proxy } = item;
+            if (!activeProxies.has(proxy)) {
+                activeProxies.forEach((activeProxy) => {
+                    if (!this.testAABB(proxy, activeProxy, secondAxis)) {
+                        return;
+                    }
+                    if (this.areStaticBodies(proxy, activeProxy)) {
                         return;
                     }
-                    if (this.areStaticBodies(entry, activeEntry)) {
+                    if (!this.testCollisionLayers(proxy, activeProxy)) {
                         return;
                     }
-                    this.collisionPairs[collisionIndex] = [entry, activeEntry];
-                    collisionIndex += 1;
+                    this.proxyPairs[proxyPairIndex] = [proxy, activeProxy];
+                    proxyPairIndex += 1;
                 });
-                activeEntries.add(entry);
+                activeProxies.add(proxy);
             }
             else {
-                activeEntries.delete(entry);
+                activeProxies.delete(proxy);
             }
         }
-        if (this.collisionPairs.length > collisionIndex) {
-            this.collisionPairs.length = collisionIndex;
+        if (this.proxyPairs.length > proxyPairIndex) {
+            this.proxyPairs.length = proxyPairIndex;
         }
     }
-    checkOnIntersection(pair) {
-        const [arg1, arg2] = pair;
-        const type1 = arg1.actor.getComponent(Collider).type;
-        const type2 = arg2.actor.getComponent(Collider).type;
-        return intersectionCheckers[type1][type2](arg1, arg2);
+    checkOnIntersection(proxyPair) {
+        const [proxy1, proxy2] = proxyPair;
+        const type1 = proxy1.actor.getComponent(Collider).type;
+        const type2 = proxy2.actor.getComponent(Collider).type;
+        return intersectionCheckers[type1][type2](proxy1, proxy2);
     }
-    sendCollisionEvent(actor1, actor2, intersection) {
-        const { mtv1, mtv2 } = intersection;
-        this.scene.dispatchEventImmediately(Collision, {
+    storeContact(contactIndex, actor1, actor2, intersection) {
+        this.contacts[contactIndex] ??= {
             actor1,
             actor2,
-            mtv1,
-            mtv2,
-        });
-        this.scene.dispatchEventImmediately(Collision, {
-            actor1: actor2,
-            actor2: actor1,
-            mtv1: mtv2,
-            mtv2: mtv1,
-        });
-    }
-    clearDeletedEntries() {
-        if (this.entriesToDelete.size === 0) {
+            normal: intersection.normal,
+            penetration: intersection.penetration,
+            contactPoints: intersection.contactPoints,
+        };
+        this.contacts[contactIndex].actor1 = actor1;
+        this.contacts[contactIndex].actor2 = actor2;
+        this.contacts[contactIndex].normal = intersection.normal;
+        this.contacts[contactIndex].penetration = intersection.penetration;
+        this.contacts[contactIndex].contactPoints = intersection.contactPoints;
+    }
+    clearDeletedProxies() {
+        if (this.actorIdsToDelete.size === 0) {
             return;
         }
         this.clearSortedList('x');
         this.clearSortedList('y');
-        this.entriesToDelete.forEach((id) => {
-            const entry = this.entriesMap.get(id);
-            this.axis.x.dispersionCalculator.removeFromSample(entry.aabb);
-            this.axis.y.dispersionCalculator.removeFromSample(entry.aabb);
-            this.entriesMap.delete(id);
+        this.actorIdsToDelete.forEach((id) => {
+            const proxy = this.proxiesByActorId.get(id);
+            this.axis.x.dispersionCalculator.removeFromSample(proxy.aabb);
+            this.axis.y.dispersionCalculator.removeFromSample(proxy.aabb);
+            this.proxiesByActorId.delete(id);
         });
-        this.entriesToDelete.clear();
+        this.actorIdsToDelete.clear();
     }
     update() {
-        this.clearDeletedEntries();
+        this.clearDeletedProxies();
         this.actorQuery.getActors().forEach((actor) => {
             if (!this.checkOnReorientation(actor)) {
                 return;
             }
-            this.updateCollisionEntry(actor);
+            this.updateProxy(actor);
         });
         this.sweepAndPrune();
-        this.collisionPairs.forEach((pair) => {
-            const intersection = this.checkOnIntersection(pair);
+        let contactIndex = 0;
+        this.proxyPairs.forEach((proxyPair) => {
+            const intersection = this.checkOnIntersection(proxyPair);
             if (intersection) {
-                this.sendCollisionEvent(pair[0].actor, pair[1].actor, intersection);
+                this.storeContact(contactIndex, proxyPair[0].actor, proxyPair[1].actor, intersection);
+                contactIndex += 1;
             }
         });
+        if (this.contacts.length > contactIndex) {
+            this.contacts.length = contactIndex;
+        }
+        return this.contacts;
     }
 }

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-box/check-boxes-intersection.d.ts

@@ -0,0 +1,10 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks box colliders for intersection.
+ *
+ * The SAT (separating axis theorem) is used to find the collision normal
+ * and penetration depth. Once the best axis is known, the incident edge is
+ * clipped against the reference edge to produce up to two stable contact
+ * points for impulse-based collision resolution.
+ */
+export declare const checkBoxesIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-box/check-boxes-intersection.js

@@ -0,0 +1,36 @@
+import { orientNormal } from '../utils';
+import { findMinBoxesOverlap, buildContactPoints } from './utils';
+/**
+ * Checks box colliders for intersection.
+ *
+ * The SAT (separating axis theorem) is used to find the collision normal
+ * and penetration depth. Once the best axis is known, the incident edge is
+ * clipped against the reference edge to produce up to two stable contact
+ * points for impulse-based collision resolution.
+ */
+export const checkBoxesIntersection = (arg1, arg2) => {
+    const geometry1 = arg1.geometry;
+    const geometry2 = arg2.geometry;
+    const overlap1 = findMinBoxesOverlap(geometry1, geometry2);
+    if (overlap1 === false) {
+        return false;
+    }
+    const overlap2 = findMinBoxesOverlap(geometry2, geometry1);
+    if (overlap2 === false) {
+        return false;
+    }
+    const isArg1Reference = overlap1.overlap <= overlap2.overlap;
+    const referenceGeometry = isArg1Reference ? geometry1 : geometry2;
+    const incidentGeometry = isArg1Reference ? geometry2 : geometry1;
+    const referenceOverlap = isArg1Reference ? overlap1 : overlap2;
+    const normal = orientNormal(referenceOverlap.axis.clone(), arg1.geometry.center, arg2.geometry.center);
+    const referenceNormal = normal.clone();
+    if (!isArg1Reference) {
+        referenceNormal.multiplyNumber(-1);
+    }
+    return {
+        normal,
+        penetration: referenceOverlap.overlap,
+        contactPoints: buildContactPoints(referenceGeometry, referenceNormal, incidentGeometry),
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-box/utils.d.ts

@@ -0,0 +1,23 @@
+import { Vector2 } from '../../../../../../../engine/math-lib';
+import type { BoxGeometry, Point } from '../../types';
+export declare const CONTACT_EPSILON = 0.0001;
+export declare const MAX_CONTACT_POINTS = 2;
+interface Projection {
+    min: number;
+    max: number;
+}
+export interface AxisOverlap {
+    axis: Vector2;
+    overlap: number;
+}
+export declare const projectPolygon: (polygon: BoxGeometry, axis: Vector2) => Projection;
+export declare const findMinBoxesOverlap: (geometry1: BoxGeometry, geometry2: BoxGeometry) => AxisOverlap | false;
+/**
+ * Builds up to two box-vs-box contact points by clipping the incident edge
+ * against the side planes of the reference edge.
+ *
+ * The returned points lie on the reference face plane, which makes them
+ * suitable to use as world-space contact points in a simple impulse solver.
+ */
+export declare const buildContactPoints: (referencePolygon: BoxGeometry, referenceNormal: Vector2, incidentPolygon: BoxGeometry) => Point[];
+export {};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-box/utils.js

@@ -0,0 +1,143 @@
+import { Vector2, VectorOps } from '../../../../../../../engine/math-lib';
+import { INTERSECTION_EPSILON } from '../utils';
+export const CONTACT_EPSILON = 1e-4;
+export const MAX_CONTACT_POINTS = 2;
+export const projectPolygon = (polygon, axis) => {
+    const initialProjection = VectorOps.dotProduct(polygon.points[0], axis);
+    const projection = {
+        min: initialProjection,
+        max: initialProjection,
+    };
+    for (let i = 1; i < polygon.points.length; i += 1) {
+        const value = VectorOps.dotProduct(polygon.points[i], axis);
+        if (value < projection.min) {
+            projection.min = value;
+        }
+        else if (value > projection.max) {
+            projection.max = value;
+        }
+    }
+    return projection;
+};
+export const findMinBoxesOverlap = (geometry1, geometry2) => {
+    let minOverlap = Infinity;
+    let bestAxis = geometry1.edges[0].normal;
+    for (const edge of geometry1.edges) {
+        const axis = edge.normal;
+        const projection1 = projectPolygon(geometry1, axis);
+        const projection2 = projectPolygon(geometry2, axis);
+        const distance1 = projection1.min - projection2.max;
+        const distance2 = projection2.min - projection1.max;
+        if (distance1 > INTERSECTION_EPSILON || distance2 > INTERSECTION_EPSILON) {
+            return false;
+        }
+        const overlap = Math.min(Math.abs(distance1), Math.abs(distance2));
+        if (overlap < minOverlap) {
+            minOverlap = overlap;
+            bestAxis = axis;
+        }
+    }
+    return {
+        axis: bestAxis,
+        overlap: minOverlap,
+    };
+};
+const clipSegmentToLine = (vertices, normal, offset) => {
+    const clipped = [];
+    const distance1 = VectorOps.dotProduct(vertices[0], normal) - offset;
+    const distance2 = VectorOps.dotProduct(vertices[1], normal) - offset;
+    if (distance1 <= CONTACT_EPSILON) {
+        clipped.push(vertices[0]);
+    }
+    if (distance2 <= CONTACT_EPSILON) {
+        clipped.push(vertices[1]);
+    }
+    if (distance1 * distance2 < 0) {
+        const t = distance1 / (distance1 - distance2);
+        const point1 = vertices[0];
+        const point2 = vertices[1];
+        clipped.push({
+            x: point1.x + (point2.x - point1.x) * t,
+            y: point1.y + (point2.y - point1.y) * t,
+        });
+    }
+    return clipped;
+};
+const getMostAntiParallelEdge = (polygon, normal) => {
+    let bestEdge = polygon.edges[0];
+    let minDot = VectorOps.dotProduct(bestEdge.normal, normal);
+    for (const edge of polygon.edges) {
+        const dot = VectorOps.dotProduct(edge.normal, normal);
+        if (dot < minDot) {
+            minDot = dot;
+            bestEdge = edge;
+        }
+    }
+    return bestEdge;
+};
+const getMostParallelEdge = (polygon, normal) => {
+    let bestEdge = polygon.edges[0];
+    let maxDot = VectorOps.dotProduct(bestEdge.normal, normal);
+    for (const edge of polygon.edges) {
+        const dot = VectorOps.dotProduct(edge.normal, normal);
+        if (dot > maxDot) {
+            maxDot = dot;
+            bestEdge = edge;
+        }
+    }
+    return bestEdge;
+};
+const dedupePoints = (points) => {
+    const unique = [];
+    for (const point of points) {
+        if (unique.some((entry) => Math.abs(entry.x - point.x) <= CONTACT_EPSILON &&
+            Math.abs(entry.y - point.y) <= CONTACT_EPSILON)) {
+            continue;
+        }
+        unique.push(point);
+        if (unique.length === MAX_CONTACT_POINTS) {
+            return unique;
+        }
+    }
+    return unique;
+};
+/**
+ * Builds up to two box-vs-box contact points by clipping the incident edge
+ * against the side planes of the reference edge.
+ *
+ * The returned points lie on the reference face plane, which makes them
+ * suitable to use as world-space contact points in a simple impulse solver.
+ */
+export const buildContactPoints = (referencePolygon, referenceNormal, incidentPolygon) => {
+    const referenceEdge = getMostParallelEdge(referencePolygon, referenceNormal);
+    const incidentEdge = getMostAntiParallelEdge(incidentPolygon, referenceNormal);
+    const tangent = new Vector2(referenceEdge.point2.x - referenceEdge.point1.x, referenceEdge.point2.y - referenceEdge.point1.y);
+    tangent.normalize();
+    const minTangentOffset = VectorOps.dotProduct(referenceEdge.point1, tangent);
+    const maxTangentOffset = VectorOps.dotProduct(referenceEdge.point2, tangent);
+    let clippedPoints = [incidentEdge.point1, incidentEdge.point2];
+    clippedPoints = clipSegmentToLine(clippedPoints, tangent, maxTangentOffset);
+    if (clippedPoints.length === 0) {
+        return [];
+    }
+    if (clippedPoints.length === 2) {
+        tangent.multiplyNumber(-1);
+        clippedPoints = clipSegmentToLine(clippedPoints, tangent, -minTangentOffset);
+        if (clippedPoints.length === 0) {
+            return [];
+        }
+    }
+    const frontOffset = VectorOps.dotProduct(referenceEdge.point1, referenceNormal);
+    const contacts = [];
+    clippedPoints.forEach((point) => {
+        const separation = VectorOps.dotProduct(point, referenceNormal) - frontOffset;
+        if (separation > CONTACT_EPSILON) {
+            return;
+        }
+        contacts.push({
+            x: point.x - referenceNormal.x * separation,
+            y: point.y - referenceNormal.y * separation,
+        });
+    });
+    return dedupePoints(contacts);
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-circle/check-box-and-circle-intersection.d.ts

@@ -0,0 +1,9 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks box and circle colliders for intersection.
+ *
+ * The closest point on the box is used as the world-space contact point.
+ * For circles inside the box, the nearest face normal is used as the
+ * collision direction and penetration is measured to that face.
+ */
+export declare const checkBoxAndCircleIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-circle/check-box-and-circle-intersection.js

@@ -0,0 +1,47 @@
+import { Collider } from '../../../../../../components';
+import { MathOps, Vector2, VectorOps, } from '../../../../../../../engine/math-lib';
+import { orientNormal, INTERSECTION_EPSILON } from '../utils';
+const buildNormal = (circle, closestEdge, closestPoint) => {
+    let normal = new Vector2(circle.center.x - closestPoint.x, circle.center.y - closestPoint.y);
+    if (normal.magnitude === 0) {
+        normal = closestEdge.normal.clone();
+    }
+    return normal.normalize();
+};
+/**
+ * Checks box and circle colliders for intersection.
+ *
+ * The closest point on the box is used as the world-space contact point.
+ * For circles inside the box, the nearest face normal is used as the
+ * collision direction and penetration is measured to that face.
+ */
+export const checkBoxAndCircleIntersection = (arg1, arg2) => {
+    const isBoxFirst = arg1.actor.getComponent(Collider).type === 'box';
+    const box = (isBoxFirst ? arg1.geometry : arg2.geometry);
+    const circle = (isBoxFirst ? arg2.geometry : arg1.geometry);
+    let closestEdge = box.edges[0];
+    let closestPoint = box.points[0];
+    let minDistance = Infinity;
+    box.edges.forEach((edge) => {
+        const candidate = VectorOps.getClosestPointOnEdge(circle.center, edge);
+        const distance = MathOps.getDistanceBetweenTwoPoints(candidate.x, circle.center.x, candidate.y, circle.center.y);
+        if (distance < minDistance) {
+            minDistance = distance;
+            closestEdge = edge;
+            closestPoint = candidate;
+        }
+    });
+    const isCircleInsideBox = VectorOps.isPointInPolygon(circle.center, box.edges);
+    if (!isCircleInsideBox &&
+        minDistance > circle.radius + INTERSECTION_EPSILON) {
+        return false;
+    }
+    const penetration = isCircleInsideBox
+        ? circle.radius + minDistance
+        : Math.max(0, circle.radius - minDistance);
+    return {
+        normal: orientNormal(buildNormal(circle, closestEdge, closestPoint), arg1.geometry.center, arg2.geometry.center),
+        penetration,
+        contactPoints: [closestPoint],
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/circle-circle/check-circles-intersection.d.ts

@@ -0,0 +1,12 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks circles for intersection.
+ *
+ * The manifold is straightforward:
+ * - the normal follows the line between circle centers
+ * - penetration is the overlap of the radii along that line
+ * - the contact point lies on the surface of the first circle
+ *
+ * When both centers are equal, the X axis is used as a deterministic fallback.
+ */
+export declare const checkCirclesIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/circle-circle/check-circles-intersection.js

@@ -0,0 +1,49 @@
+import { Vector2 } from '../../../../../../../engine/math-lib';
+import { INTERSECTION_EPSILON } from '../utils';
+/**
+ * Checks circles for intersection.
+ *
+ * The manifold is straightforward:
+ * - the normal follows the line between circle centers
+ * - penetration is the overlap of the radii along that line
+ * - the contact point lies on the surface of the first circle
+ *
+ * When both centers are equal, the X axis is used as a deterministic fallback.
+ */
+export const checkCirclesIntersection = (arg1, arg2) => {
+    const { radius: radius1 } = arg1.geometry;
+    const { radius: radius2 } = arg2.geometry;
+    const { x: x1, y: y1 } = arg1.geometry.center;
+    const { x: x2, y: y2 } = arg2.geometry.center;
+    const offsetX = x2 - x1;
+    const offsetY = y2 - y1;
+    const distance = Math.sqrt(offsetX ** 2 + offsetY ** 2);
+    if (distance > radius1 + radius2 + INTERSECTION_EPSILON) {
+        return false;
+    }
+    const penetration = Math.max(0, radius1 + radius2 - distance);
+    if (distance === 0) {
+        return {
+            normal: new Vector2(1, 0),
+            penetration,
+            contactPoints: [
+                {
+                    x: x1 + radius1,
+                    y: y1,
+                },
+            ],
+        };
+    }
+    const normal = new Vector2(offsetX, offsetY);
+    normal.normalize();
+    return {
+        normal,
+        penetration,
+        contactPoints: [
+            {
+                x: x1 + normal.x * radius1,
+                y: y1 + normal.y * radius1,
+            },
+        ],
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/index.d.ts

@@ -1,3 +1,3 @@
-import type { CollisionEntry, Intersection } from '../types';
-export type CheckIntersectionFn = (arg1: CollisionEntry, arg2: CollisionEntry) => Intersection | false;
+import type { Proxy, Intersection } from '../types';
+export type CheckIntersectionFn = (arg1: Proxy, arg2: Proxy) => Intersection | false;
 export declare const intersectionCheckers: Record<string, Record<string, CheckIntersectionFn>>;