dacha 0.13.0

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-box-aabb.js

@@ -0,0 +1,13 @@
+export const buildBoxAABB = (geometry) => {
+    const { points } = geometry;
+    return {
+        min: {
+            x: Math.min(points[0].x, points[1].x, points[2].x, points[3].x),
+            y: Math.min(points[0].y, points[1].y, points[2].y, points[3].y),
+        },
+        max: {
+            x: Math.max(points[0].x, points[1].x, points[2].x, points[3].x),
+            y: Math.max(points[0].y, points[1].y, points[2].y, points[3].y),
+        },
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-circle-aabb.d.ts

@@ -0,0 +1,2 @@
+import type { AABB, Geometry } from '../types';
+export declare const buildCircleAABB: (geometry: Geometry) => AABB;

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-circle-aabb.js

@@ -0,0 +1,8 @@
+export const buildCircleAABB = (geometry) => {
+    const { radius } = geometry;
+    const { x: centerX, y: centerY } = geometry.center;
+    return {
+        min: { x: centerX - radius, y: centerY - radius },
+        max: { x: centerX + radius, y: centerY + radius },
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/index.d.ts

@@ -0,0 +1,3 @@
+import type { AABB, Geometry } from '../types';
+export type BuildAABBFn = (geometry: Geometry) => AABB;
+export declare const aabbBuilders: Record<string, BuildAABBFn>;

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

@@ -0,0 +1,6 @@
+import { buildBoxAABB } from './build-box-aabb';
+import { buildCircleAABB } from './build-circle-aabb';
+export const aabbBuilders = {
+    boxCollider: buildBoxAABB,
+    circleCollider: buildCircleAABB,
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/dispersion-calculator/index.d.ts

@@ -0,0 +1,11 @@
+import type { Axis, AABB } from '../types';
+export declare class DispersionCalculator {
+    private axis;
+    private sampleSize;
+    private sum;
+    private squaredSum;
+    constructor(axis: Axis);
+    addToSample(aabb: AABB): void;
+    removeFromSample(aabb: AABB): void;
+    getDispersion(): number;
+}

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

@@ -0,0 +1,27 @@
+export class DispersionCalculator {
+    axis;
+    sampleSize;
+    sum;
+    squaredSum;
+    constructor(axis) {
+        this.axis = axis;
+        this.sampleSize = 0;
+        this.sum = 0;
+        this.squaredSum = 0;
+    }
+    addToSample(aabb) {
+        const average = (aabb.min[this.axis] + aabb.max[this.axis]) * 0.5;
+        this.sum += average;
+        this.squaredSum += average ** 2;
+        this.sampleSize += 1;
+    }
+    removeFromSample(aabb) {
+        const average = (aabb.min[this.axis] + aabb.max[this.axis]) * 0.5;
+        this.sum -= average;
+        this.squaredSum -= average ** 2;
+        this.sampleSize -= 1;
+    }
+    getDispersion() {
+        return (this.squaredSum / this.sampleSize) - (this.sum / this.sampleSize) ** 2;
+    }
+}

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-box-geometry.d.ts

@@ -0,0 +1,3 @@
+import type { ColliderContainer, Transform } from '../../../../../components';
+import type { BoxGeometry } from '../types';
+export declare const buildBoxGeometry: (container: ColliderContainer, transform: Transform) => BoxGeometry;

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-box-geometry.js

@@ -0,0 +1,46 @@
+import { VectorOps } from '../../../../../../engine/math-lib';
+export const buildBoxGeometry = (container, transform) => {
+    const { offsetX, offsetY, scaleX, scaleY, rotation, } = transform;
+    let { centerX, centerY } = container.collider;
+    const { sizeX, sizeY } = container.collider;
+    const x1 = -(sizeX / 2);
+    const x2 = (sizeX / 2);
+    const y1 = -(sizeY / 2);
+    const y2 = (sizeY / 2);
+    const angle = (rotation * Math.PI) / 180;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    centerX += offsetX;
+    centerY += offsetY;
+    const points = [
+        { x: x1, y: y1 },
+        { x: x1, y: y2 },
+        { x: x2, y: y2 },
+        { x: x2, y: y1 },
+    ];
+    points.forEach((point) => {
+        const { x, y } = point;
+        const scaledX = x * scaleX;
+        const scaledY = y * scaleY;
+        const rotatedX = scaledX * cos - scaledY * sin;
+        const rotatedY = scaledX * sin + scaledY * cos;
+        point.x = rotatedX + centerX;
+        point.y = rotatedY + centerY;
+    });
+    const edges = points.map((point1, index, array) => {
+        const point2 = array[(index + 1) % array.length];
+        return {
+            point1,
+            point2,
+            normal: VectorOps.getNormal(point1.x, point2.x, point1.y, point2.y),
+        };
+    });
+    return {
+        center: {
+            x: centerX,
+            y: centerY,
+        },
+        points,
+        edges,
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-circle-geometry.d.ts

@@ -0,0 +1,3 @@
+import type { ColliderContainer, Transform } from '../../../../../components';
+import type { CircleGeometry } from '../types';
+export declare const buildCircleGeometry: (container: ColliderContainer, transform: Transform) => CircleGeometry;

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-circle-geometry.js

@@ -0,0 +1,13 @@
+export const buildCircleGeometry = (container, transform) => {
+    const { offsetX, offsetY, scaleX, scaleY, } = transform;
+    const { centerX, centerY, radius } = container.collider;
+    const center = {
+        x: centerX + offsetX,
+        y: centerY + offsetY,
+    };
+    const scaledRadius = radius * Math.max(scaleX, scaleY);
+    return {
+        center,
+        radius: scaledRadius,
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/index.d.ts

@@ -0,0 +1,4 @@
+import type { ColliderContainer, Transform } from '../../../../../components';
+import type { Geometry } from '../types';
+export type BuildGeometryFn = (container: ColliderContainer, transform: Transform) => Geometry;
+export declare const geometryBuilders: Record<string, BuildGeometryFn>;

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

@@ -0,0 +1,6 @@
+import { buildBoxGeometry } from './build-box-geometry';
+import { buildCircleGeometry } from './build-circle-geometry';
+export const geometryBuilders = {
+    boxCollider: buildBoxGeometry,
+    circleCollider: buildCircleGeometry,
+};

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

@@ -0,0 +1,29 @@
+import type { SystemOptions } from '../../../../../engine/system';
+export declare class CollisionDetectionSubsystem {
+    private actorCollection;
+    private scene;
+    private axis;
+    private entriesMap;
+    private collisionPairs;
+    private entriesToDelete;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    private handleActorAdd;
+    private handleActorRemove;
+    private checkOnReorientation;
+    private getOrientationData;
+    private addCollisionEntry;
+    private updateCollisionEntry;
+    private addToSortedList;
+    private updateSortedList;
+    private clearSortedList;
+    private getAxes;
+    private areStaticBodies;
+    private testAABB;
+    private sweepAndPrune;
+    private checkOnIntersection;
+    private sendCollisionEvent;
+    private clearDeletedEntries;
+    update(): void;
+}

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

@@ -0,0 +1,235 @@
+import { ActorCollection } from '../../../../../engine/actor';
+import { Transform, ColliderContainer, 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';
+import { intersectionCheckers } from './intersection-checkers';
+import { DispersionCalculator } from './dispersion-calculator';
+import { checkTransform, checkCollider } from './reorientation-checkers';
+export class CollisionDetectionSubsystem {
+    actorCollection;
+    scene;
+    axis;
+    entriesMap;
+    collisionPairs;
+    entriesToDelete;
+    constructor(options) {
+        this.actorCollection = new ActorCollection(options.scene, {
+            components: [
+                ColliderContainer,
+                Transform,
+            ],
+        });
+        this.scene = options.scene;
+        this.axis = {
+            x: {
+                sortedList: [],
+                dispersionCalculator: new DispersionCalculator('x'),
+            },
+            y: {
+                sortedList: [],
+                dispersionCalculator: new DispersionCalculator('y'),
+            },
+        };
+        this.entriesMap = new Map();
+        this.collisionPairs = [];
+        this.entriesToDelete = new Set();
+    }
+    mount() {
+        this.actorCollection.forEach((actor) => this.addCollisionEntry(actor));
+        this.actorCollection.addEventListener(AddActor, this.handleActorAdd);
+        this.actorCollection.addEventListener(RemoveActor, this.handleActorRemove);
+    }
+    unmount() {
+        this.actorCollection.removeEventListener(AddActor, this.handleActorAdd);
+        this.actorCollection.removeEventListener(RemoveActor, this.handleActorRemove);
+    }
+    handleActorAdd = (event) => {
+        this.addCollisionEntry(event.actor);
+    };
+    handleActorRemove = (event) => {
+        this.entriesToDelete.add(event.actor.id);
+    };
+    checkOnReorientation(actor) {
+        const entry = this.entriesMap.get(actor.id);
+        if (!entry) {
+            return true;
+        }
+        const transform = actor.getComponent(Transform);
+        const colliderContainer = actor.getComponent(ColliderContainer);
+        const transformOld = entry.orientationData.transform;
+        const colliderOld = entry.orientationData.collider;
+        return checkTransform(transform, transformOld) || checkCollider(colliderContainer, colliderOld);
+    }
+    getOrientationData(actor) {
+        const transform = actor.getComponent(Transform);
+        const colliderContainer = actor.getComponent(ColliderContainer);
+        return {
+            transform: {
+                offsetX: transform.offsetX,
+                offsetY: transform.offsetY,
+                rotation: transform.rotation,
+                scaleX: transform.scaleX,
+                scaleY: transform.scaleY,
+            },
+            collider: {
+                type: colliderContainer.type,
+                centerX: colliderContainer.collider.centerX,
+                centerY: colliderContainer.collider.centerY,
+                sizeX: colliderContainer.collider.sizeX,
+                sizeY: colliderContainer.collider.sizeY,
+                radius: colliderContainer.collider.radius,
+            },
+        };
+    }
+    addCollisionEntry(actor) {
+        const transform = actor.getComponent(Transform);
+        const colliderContainer = actor.getComponent(ColliderContainer);
+        const geometry = geometryBuilders[colliderContainer.type](colliderContainer, transform);
+        const aabb = aabbBuilders[colliderContainer.type](geometry);
+        const entry = {
+            actor,
+            aabb,
+            geometry,
+            orientationData: this.getOrientationData(actor),
+        };
+        this.axis.x.dispersionCalculator.addToSample(aabb);
+        this.addToSortedList(entry, 'x');
+        this.axis.y.dispersionCalculator.addToSample(aabb);
+        this.addToSortedList(entry, 'y');
+        this.entriesMap.set(actor.id, entry);
+    }
+    updateCollisionEntry(actor) {
+        const transform = actor.getComponent(Transform);
+        const colliderContainer = actor.getComponent(ColliderContainer);
+        const geometry = geometryBuilders[colliderContainer.type](colliderContainer, transform);
+        const aabb = aabbBuilders[colliderContainer.type](geometry);
+        const entry = this.entriesMap.get(actor.id);
+        const prevAABB = entry.aabb;
+        entry.aabb = aabb;
+        entry.geometry = geometry;
+        entry.orientationData = this.getOrientationData(actor);
+        this.axis.x.dispersionCalculator.removeFromSample(prevAABB);
+        this.axis.x.dispersionCalculator.addToSample(aabb);
+        this.updateSortedList(entry, 'x');
+        this.axis.y.dispersionCalculator.removeFromSample(prevAABB);
+        this.axis.y.dispersionCalculator.addToSample(aabb);
+        this.updateSortedList(entry, 'y');
+    }
+    addToSortedList(entry, axis) {
+        const min = { value: entry.aabb.min[axis], entry };
+        const max = { value: entry.aabb.max[axis], entry };
+        this.axis[axis].sortedList.push(min, max);
+        entry.edges ??= {};
+        entry.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;
+    }
+    clearSortedList(axis) {
+        this.axis[axis].sortedList = this.axis[axis].sortedList.filter((item) => !this.entriesToDelete.has(item.entry.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;
+        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;
+        return aabb1.max[axis] > aabb2.min[axis] && aabb1.min[axis] < aabb2.max[axis];
+    }
+    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;
+        for (const item of sortedList) {
+            const { entry } = item;
+            if (!activeEntries.has(entry)) {
+                activeEntries.forEach((activeEntry) => {
+                    if (!this.testAABB(entry, activeEntry, secondAxis)) {
+                        return;
+                    }
+                    if (this.areStaticBodies(entry, activeEntry)) {
+                        return;
+                    }
+                    this.collisionPairs[collisionIndex] = [entry, activeEntry];
+                    collisionIndex += 1;
+                });
+                activeEntries.add(entry);
+            }
+            else {
+                activeEntries.delete(entry);
+            }
+        }
+        if (this.collisionPairs.length > collisionIndex) {
+            this.collisionPairs.length = collisionIndex;
+        }
+    }
+    checkOnIntersection(pair) {
+        const [arg1, arg2] = pair;
+        const type1 = arg1.actor.getComponent(ColliderContainer).type;
+        const type2 = arg2.actor.getComponent(ColliderContainer).type;
+        return intersectionCheckers[type1][type2](arg1, arg2);
+    }
+    sendCollisionEvent(actor1, actor2, intersection) {
+        const { mtv1, mtv2 } = intersection;
+        this.scene.dispatchEventImmediately(Collision, {
+            actor1,
+            actor2,
+            mtv1,
+            mtv2,
+        });
+        this.scene.dispatchEventImmediately(Collision, {
+            actor1: actor2,
+            actor2: actor1,
+            mtv1: mtv2,
+            mtv2: mtv1,
+        });
+    }
+    clearDeletedEntries() {
+        if (this.entriesToDelete.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.entriesToDelete.clear();
+    }
+    update() {
+        this.clearDeletedEntries();
+        this.actorCollection.forEach((actor) => {
+            if (!this.checkOnReorientation(actor)) {
+                return;
+            }
+            this.updateCollisionEntry(actor);
+        });
+        this.sweepAndPrune();
+        this.collisionPairs.forEach((pair) => {
+            const intersection = this.checkOnIntersection(pair);
+            if (intersection) {
+                this.sendCollisionEvent(pair[0].actor, pair[1].actor, intersection);
+            }
+        });
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { CollisionEntry, Intersection } from '../types';
+/**
+  * Checks box and circle colliders at the intersection.
+  * The main target is to check two possible scenarios:
+  * - circle lies inside box
+  * - circle intersects one of the boxe's edges
+  * Steps of the algorithm:
+  * 1. Find the nearest edge to circle center and check wether it intersects with circle or not
+  *    For each edge three points should be considered: corners and circle center projection
+  * 2. Determine is the circle center lies inside of the box or not.
+  *    This affects how we should compute mtv distance
+  * 3. If circle doesn't have any intersection with boxe's edges
+  *    and circle center lies outside of the box – return false.
+  *    Otherwise compute mtv vectors considering relative position of circle and box centers
+  */
+export declare const checkBoxAndCircleIntersection: (arg1: CollisionEntry, arg2: CollisionEntry) => Intersection | false;

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

@@ -0,0 +1,80 @@
+import { ColliderContainer } from '../../../../../components';
+import { MathOps, Vector2, VectorOps } from '../../../../../../engine/math-lib';
+const getMtvs = (axis, overlap, point1, point2) => {
+    axis.multiplyNumber((1 / axis.magnitude) * overlap);
+    const positiveX = Math.abs(axis.x);
+    const negativeX = -Math.abs(axis.x);
+    const positiveY = Math.abs(axis.y);
+    const negativeY = -Math.abs(axis.y);
+    return {
+        mtv1: new Vector2(point1.x < point2.x ? negativeX : positiveX, point1.y < point2.y ? negativeY : positiveY),
+        mtv2: new Vector2(point2.x > point1.x ? positiveX : negativeX, point2.y > point1.y ? positiveY : negativeY),
+    };
+};
+/**
+  * Checks box and circle colliders at the intersection.
+  * The main target is to check two possible scenarios:
+  * - circle lies inside box
+  * - circle intersects one of the boxe's edges
+  * Steps of the algorithm:
+  * 1. Find the nearest edge to circle center and check wether it intersects with circle or not
+  *    For each edge three points should be considered: corners and circle center projection
+  * 2. Determine is the circle center lies inside of the box or not.
+  *    This affects how we should compute mtv distance
+  * 3. If circle doesn't have any intersection with boxe's edges
+  *    and circle center lies outside of the box – return false.
+  *    Otherwise compute mtv vectors considering relative position of circle and box centers
+  */
+export const checkBoxAndCircleIntersection = (arg1, arg2) => {
+    let box;
+    let circle;
+    if (arg1.actor.getComponent(ColliderContainer).type === 'boxCollider') {
+        box = arg1.geometry;
+        circle = arg2.geometry;
+    }
+    else {
+        box = arg2.geometry;
+        circle = arg1.geometry;
+    }
+    let isIntersection = false;
+    let minDistance = Infinity;
+    let minDistanceAxis;
+    const { center: circleCenter } = circle;
+    for (const edge of box.edges) {
+        const projectedPoint = VectorOps.projectPointToEdge(circleCenter, edge);
+        const minX = Math.min(edge.point1.x, edge.point2.x);
+        const maxX = Math.max(edge.point1.x, edge.point2.x);
+        const minY = Math.min(edge.point1.y, edge.point2.y);
+        const maxY = Math.max(edge.point1.y, edge.point2.y);
+        const isPointOnEdge = projectedPoint.x >= minX
+            && projectedPoint.x <= maxX
+            && projectedPoint.y >= minY
+            && projectedPoint.y <= maxY;
+        const distanceProjection = isPointOnEdge ? MathOps.getDistanceBetweenTwoPoints(circleCenter.x, projectedPoint.x, circleCenter.y, projectedPoint.y) : Infinity;
+        const distance1 = MathOps.getDistanceBetweenTwoPoints(circleCenter.x, edge.point1.x, circleCenter.y, edge.point1.y);
+        const distance2 = MathOps.getDistanceBetweenTwoPoints(circleCenter.x, edge.point2.x, circleCenter.y, edge.point2.y);
+        const isInsideCircle = Math.min(distanceProjection, distance1, distance2) < circle.radius;
+        isIntersection = isIntersection || isInsideCircle;
+        if (isPointOnEdge && distanceProjection < minDistance) {
+            minDistance = distanceProjection;
+            minDistanceAxis = edge.normal.clone();
+        }
+        if (distance1 < minDistance) {
+            minDistance = distance1;
+            minDistanceAxis = minDistance !== 0
+                ? new Vector2(edge.point1.x - circleCenter.x, edge.point1.y - circleCenter.y)
+                : edge.normal.clone();
+        }
+        if (distance2 < minDistance) {
+            minDistance = distance2;
+            minDistanceAxis = minDistance !== 0
+                ? new Vector2(edge.point2.x - circleCenter.x, edge.point2.y - circleCenter.y)
+                : edge.normal.clone();
+        }
+    }
+    const isInsidePolygon = VectorOps.isPointInPolygon(circleCenter, box.edges);
+    if (!isIntersection && !isInsidePolygon) {
+        return false;
+    }
+    return getMtvs(minDistanceAxis, isInsidePolygon ? circle.radius + minDistance : circle.radius - minDistance, arg1.geometry.center, arg2.geometry.center);
+};

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

@@ -0,0 +1,6 @@
+import type { CollisionEntry, Intersection } from '../types';
+/**
+  * Checks boxes colliders at the intersection.
+  * The SAT (separating axis theorem) is used to determine an intersection and mtvs.
+  */
+export declare const checkBoxesIntersection: (arg1: CollisionEntry, arg2: CollisionEntry) => Intersection | false;

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

@@ -0,0 +1,72 @@
+import { Vector2, VectorOps } from '../../../../../../engine/math-lib';
+const projectPolygon = (polygon, axisVector) => {
+    const initialProjectionValue = VectorOps.dotProduct(polygon.edges[0].point1, axisVector);
+    const projection = {
+        min: initialProjectionValue,
+        max: initialProjectionValue,
+    };
+    for (let i = 1; i < polygon.edges.length; i += 1) {
+        const projectionValue = VectorOps.dotProduct(polygon.edges[i].point1, axisVector);
+        if (projectionValue < projection.min) {
+            projection.min = projectionValue;
+        }
+        else if (projectionValue > projection.max) {
+            projection.max = projectionValue;
+        }
+    }
+    return projection;
+};
+/**
+  * Checks boxes colliders at the intersection.
+  * The SAT (separating axis theorem) is used to determine an intersection and mtvs.
+  */
+export const checkBoxesIntersection = (arg1, arg2) => {
+    let overlap = Infinity;
+    let normal;
+    const geometry1 = arg1.geometry;
+    const geometry2 = arg2.geometry;
+    // Consider arg1 box normals as axes
+    for (const edge of geometry1.edges) {
+        const axis = edge.normal;
+        const aProjection = projectPolygon(geometry1, axis);
+        const bProjection = projectPolygon(geometry2, axis);
+        const aDistance = aProjection.min - bProjection.max;
+        const bDistance = bProjection.min - aProjection.max;
+        if (aDistance > 0 || bDistance > 0) {
+            return false;
+        }
+        const axisOverlap = Math.min(Math.abs(aDistance), Math.abs(bDistance));
+        if (axisOverlap < overlap) {
+            overlap = axisOverlap;
+            normal = axis;
+        }
+    }
+    // Consider arg2 box normals as axes
+    for (const edge of geometry2.edges) {
+        const axis = edge.normal;
+        const aProjection = projectPolygon(geometry1, axis);
+        const bProjection = projectPolygon(geometry2, axis);
+        const aDistance = aProjection.min - bProjection.max;
+        const bDistance = bProjection.min - aProjection.max;
+        if (aDistance > 0 || bDistance > 0) {
+            return false;
+        }
+        const axisOverlap = Math.min(Math.abs(aDistance), Math.abs(bDistance));
+        if (axisOverlap < overlap) {
+            overlap = axisOverlap;
+            normal = axis;
+        }
+    }
+    const { x: xArg1, y: yArg1 } = geometry1.center;
+    const { x: xArg2, y: yArg2 } = geometry2.center;
+    const mtv = normal.clone();
+    mtv.multiplyNumber(overlap);
+    const positiveX = Math.abs(mtv.x);
+    const negativeX = -Math.abs(mtv.x);
+    const positiveY = Math.abs(mtv.y);
+    const negativeY = -Math.abs(mtv.y);
+    return {
+        mtv1: new Vector2(xArg1 < xArg2 ? negativeX : positiveX, yArg1 < yArg2 ? negativeY : positiveY),
+        mtv2: new Vector2(xArg2 > xArg1 ? positiveX : negativeX, yArg2 > yArg1 ? positiveY : negativeY),
+    };
+};

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

@@ -0,0 +1,11 @@
+import type { CollisionEntry, Intersection } from '../types';
+/**
+  * Checks circles at the intersection.
+  * Steps of the alghorith:
+  * 1. Calculate distance between circles centers.
+  * 2. If distance greater or equal to summ of circles radiuses then is no intersection.
+  * 3. If distance is zero then circles centers lie at the same point, so just X axis used for mtv.
+  * 4. If distance less than summ of circles radiuses and it's non-zero
+  *  then circles centers used to get the axis.
+  */
+export declare const checkCirclesIntersection: (arg1: CollisionEntry, arg2: CollisionEntry) => Intersection | false;

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

@@ -0,0 +1,39 @@
+import { Vector2 } from '../../../../../../engine/math-lib';
+/**
+  * Checks circles at the intersection.
+  * Steps of the alghorith:
+  * 1. Calculate distance between circles centers.
+  * 2. If distance greater or equal to summ of circles radiuses then is no intersection.
+  * 3. If distance is zero then circles centers lie at the same point, so just X axis used for mtv.
+  * 4. If distance less than summ of circles radiuses and it's non-zero
+  *  then circles centers used to get the axis.
+  */
+export const checkCirclesIntersection = (arg1, arg2) => {
+    const { radius: rArg1 } = arg1.geometry;
+    const { radius: rArg2 } = arg2.geometry;
+    const { x: xArg1, y: yArg1 } = arg1.geometry.center;
+    const { x: xArg2, y: yArg2 } = arg2.geometry.center;
+    const x = xArg1 - xArg2;
+    const y = yArg1 - yArg2;
+    const distance = Math.sqrt((x ** 2) + (y ** 2));
+    if (distance >= rArg1 + rArg2) {
+        return false;
+    }
+    if (distance === 0) {
+        return {
+            mtv1: new Vector2(rArg1 + rArg2, 0),
+            mtv2: new Vector2(-(rArg1 + rArg2), 0),
+        };
+    }
+    const mtv = new Vector2(x, y);
+    const overlap = rArg1 + rArg2 - distance;
+    mtv.multiplyNumber((1 / distance) * overlap);
+    const positiveX = Math.abs(mtv.x);
+    const negativeX = -Math.abs(mtv.x);
+    const positiveY = Math.abs(mtv.y);
+    const negativeY = -Math.abs(mtv.y);
+    return {
+        mtv1: new Vector2(xArg1 < xArg2 ? negativeX : positiveX, yArg1 < yArg2 ? negativeY : positiveY),
+        mtv2: new Vector2(xArg2 < xArg1 ? negativeX : positiveX, yArg2 < yArg1 ? negativeY : positiveY),
+    };
+};

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

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