dacha 0.17.2 → 0.18.0-alpha.1

package/build/contrib/systems/renderer/builders/shape-builder/index.js

@@ -51,7 +51,11 @@ export class ShapeBuilder {
             shape.height !== meta.height ||
             shape.radius !== meta.radius ||
             shape.radiusX !== meta.radiusX ||
-            shape.radiusY !== meta.radiusY) {
+            shape.radiusY !== meta.radiusY ||
+            shape.point1X !== meta.point1X ||
+            shape.point1Y !== meta.point1Y ||
+            shape.point2X !== meta.point2X ||
+            shape.point2Y !== meta.point2Y) {
             view.label = shape.type;
             this.updateGraphicsContext(shape);
             meta.type = shape.type;
@@ -63,6 +67,10 @@ export class ShapeBuilder {
             meta.radius = shape.radius;
             meta.radiusX = shape.radiusX;
             meta.radiusY = shape.radiusY;
+            meta.point1X = shape.point1X;
+            meta.point1Y = shape.point1Y;
+            meta.point2X = shape.point2X;
+            meta.point2Y = shape.point2Y;
         }
         const graphicsContext = this.getGraphicsContext(shape);
         view.context = graphicsContext;

package/build/contrib/systems/renderer/builders/shape-builder/utils.js

@@ -61,6 +61,18 @@ export const getGraphicsContext = (shape) => {
             }
             return ellipse;
         }
+        case 'line': {
+            const { point1X, point1Y, point2X, point2Y, strokeWidth, strokeColor, strokeAlignment, pixelLine, } = shape;
+            return new GraphicsContext()
+                .moveTo(point1X, point1Y)
+                .lineTo(point2X, point2Y)
+                .stroke({
+                width: strokeWidth,
+                alignment: strokeAlignment,
+                color: strokeColor,
+                pixelLine,
+            });
+        }
     }
 };
 export const getGraphicsContextKey = (shape) => {
@@ -81,5 +93,9 @@ export const getGraphicsContextKey = (shape) => {
             const { type, radiusX, radiusY, strokeWidth, strokeColor, strokeAlignment, fill, pixelLine, } = shape;
             return `${type}_${radiusX}_${radiusY}_${strokeWidth}_${strokeColor}_${strokeAlignment}_${fill}_${pixelLine}`;
         }
+        case 'line': {
+            const { type, point1X, point1Y, point2X, point2Y, strokeWidth, strokeColor, strokeAlignment, pixelLine, } = shape;
+            return `${type}_${point1X}_${point1Y}_${point2X}_${point2Y}_${strokeWidth}_${strokeColor}_${strokeAlignment}_${pixelLine}`;
+        }
     }
 };

package/build/contrib/systems/renderer/index.d.ts

@@ -1,4 +1,4 @@
 export { Renderer } from './renderer';
-export { RendererService } from './service';
+export { RendererAPI } from './api';
 export { FilterEffect } from './filters/filter-effect';
 export { Shader } from './material/shader';

package/build/contrib/systems/renderer/index.js

@@ -1,4 +1,4 @@
 export { Renderer } from './renderer';
-export { RendererService } from './service';
+export { RendererAPI } from './api';
 export { FilterEffect } from './filters/filter-effect';
 export { Shader } from './material/shader';

package/build/contrib/systems/renderer/renderer.d.ts

@@ -14,13 +14,14 @@ export declare class Renderer extends WorldSystem {
     private sortingLayers;
     private sortFn;
     private backgroundColor;
-    private cameraService;
+    private cameraApi;
     private assets;
     private actorRenderTree?;
     private filterSystem;
     private materialSystem;
     private resources?;
     private time;
+    private rendererApi;
     constructor(options: WorldSystemOptions);
     onWorldLoad(): Promise<void>;
     onWorldDestroy(): void;

package/build/contrib/systems/renderer/renderer.js

@@ -2,9 +2,9 @@ import { Application, Container, Color, RenderLayer, } from 'pixi.js';
 import { WorldSystem, } from '../../../engine/system';
 import { Transform } from '../../components/transform';
 import { Camera } from '../../components/camera';
-import { CameraService } from '../camera-system';
+import { CameraAPI } from '../camera-system';
 import { getWindowNode } from '../../utils/get-window-node';
-import { RendererService } from './service';
+import { RendererAPI } from './api';
 import { composeSort, createSortByLayer, sortByYAxis, sortByXAxis, } from './sort';
 import { parseSortingLayers } from './sort/utils';
 import { Assets } from './assets';
@@ -26,13 +26,14 @@ export class Renderer extends WorldSystem {
     sortingLayers;
     sortFn;
     backgroundColor;
-    cameraService;
+    cameraApi;
     assets;
     actorRenderTree;
     filterSystem;
     materialSystem;
     resources;
     time;
+    rendererApi;
     constructor(options) {
         super();
         const { globalOptions, windowNodeId, backgroundColor, templateCollection, world, resources, filterEffects, } = options;
@@ -66,15 +67,16 @@ export class Renderer extends WorldSystem {
             filterEffects,
             availableFilterEffects: this.resources?.filterEffects,
         });
-        this.cameraService = world.getService(CameraService);
-        world.addService(new RendererService({
+        this.cameraApi = world.systemApi.get(CameraAPI);
+        this.rendererApi = new RendererAPI({
             application: this.application,
             worldContainer: this.worldContainer,
             getViewEntries: () => this.actorRenderTree?.viewEntries,
             sortFn: this.sortFn,
             filterSystem: this.filterSystem,
             materialSystem: this.materialSystem,
-        }));
+        });
+        world.systemApi.register(this.rendererApi);
     }
     async onWorldLoad() {
         await this.application.init({
@@ -125,7 +127,7 @@ export class Renderer extends WorldSystem {
         this.assets.unload(scene);
     }
     updateCamera() {
-        const currentCamera = this.cameraService.getCurrentCamera();
+        const currentCamera = this.cameraApi.getCurrentCamera();
         const transform = currentCamera?.getComponent(Transform);
         const camera = currentCamera?.getComponent(Camera);
         const x = transform?.world.position.x ?? 0;

package/build/engine/actor/actor-creator.js

@@ -15,10 +15,12 @@ export class ActorCreator {
         let { id, name } = options;
         id = id || uuid();
         name = name || id;
-        const template = templateId ? this.templateCollection.get(templateId) : undefined;
+        const template = templateId
+            ? this.templateCollection.get(templateId)
+            : undefined;
         if (!template) {
-            throw new Error(`Can't create actor ${name} from template. `
-                + `The template with id ${String(templateId)} is null.`);
+            throw new Error(`Can't create actor ${name} from template. ` +
+                `The template with id ${String(templateId)} is null.`);
         }
         const actor = new Actor({
             id,
@@ -52,7 +54,7 @@ export class ActorCreator {
         return actor;
     }
     buildFromScratch(options) {
-        const { name, components = [], children = [], } = options;
+        const { name, components = [], children = [] } = options;
         let { id } = options;
         id = id || uuid();
         const actor = new Actor({

package/build/engine/math-lib/math/ops.d.ts

@@ -1,7 +1,7 @@
 /**
  * A point in 2D space with x and y coordinates.
  */
-interface Point {
+export interface Point {
     /** X coordinate of the point */
     x: number;
     /** Y coordinate of the point */
@@ -119,4 +119,3 @@ export declare class MathOps {
      */
     static clamp(value: number, min: number, max: number): number;
 }
-export {};

package/build/engine/math-lib/math/ops.js

@@ -26,7 +26,7 @@ export class MathOps {
      * ```
      */
     static random(min, max) {
-        return Math.floor(min + (Math.random() * (max + 1 - min)));
+        return Math.floor(min + Math.random() * (max + 1 - min));
     }
     /**
      * Convert radians to degrees
@@ -108,8 +108,8 @@ export class MathOps {
     static getLinePoint(angle, x, y, length) {
         const angleInRad = this.degToRad(angle);
         return {
-            x: x - (length * Math.cos(angleInRad)),
-            y: y - (length * Math.sin(angleInRad)),
+            x: x - length * Math.cos(angleInRad),
+            y: y - length * Math.sin(angleInRad),
         };
     }
     /**

package/build/engine/math-lib/vector/ops.d.ts

@@ -89,7 +89,22 @@ export declare class VectorOps {
      */
     static dotProduct(point: Point, vector: Vector2): number;
     /**
-     * Projects a point onto a given edge, returning the closest point
+     * Calculates the cross product of two points.
+     *
+     * @param point1 - First point to use in the cross product
+     * @param point2 - Second point to use in the cross product
+     * @returns Scalar value representing the cross product of the two points
+     *
+     * @example
+     * ```typescript
+     * const point1 = { x: 3, y: 4 };
+     * const point2 = { x: 1, y: 2 };
+     * const cross = VectorOps.crossProduct(point1, point2);
+     * ```
+     */
+    static crossProduct(point1: Point, point2: Point): number;
+    /**
+     * Returns the closest point on an edge segment to the given point.
      *
      * @param {Point} point - Point to project. Should have properties `x` and `y`.
      * @param {Edge} edge - Edge to project onto, defined by two endpoints `point1` and `point2`.
@@ -100,10 +115,10 @@ export declare class VectorOps {
      * ```typescript
      * const point = { x: 3, y: 4 };
      * const edge = { point1: { x: 0, y: 0 }, point2: { x: 10, y: 0 } };
-     * const projected = VectorOps.projectPointToEdge(point, edge);
+     * const projected = VectorOps.getClosestPointOnEdge(point, edge);
      * ```
      */
-    static projectPointToEdge(point: Point, edge: Edge): Point;
+    static getClosestPointOnEdge(point: Point, edge: Edge): Point;
     /**
      * Determines if a point is inside a polygon.
      *

package/build/engine/math-lib/vector/ops.js

@@ -65,6 +65,9 @@ export class VectorOps {
      * ```
      */
     static getNormal(x1, x2, y1, y2) {
+        if (x1 === x2 && y1 === y2) {
+            return VectorOps.getVectorByAngle(0);
+        }
         const normal = new Vector2(y1 - y2, x2 - x1);
         normal.multiplyNumber(1 / normal.magnitude);
         return normal;
@@ -87,7 +90,24 @@ export class VectorOps {
         return point.x * vector.x + point.y * vector.y;
     }
     /**
-     * Projects a point onto a given edge, returning the closest point
+     * Calculates the cross product of two points.
+     *
+     * @param point1 - First point to use in the cross product
+     * @param point2 - Second point to use in the cross product
+     * @returns Scalar value representing the cross product of the two points
+     *
+     * @example
+     * ```typescript
+     * const point1 = { x: 3, y: 4 };
+     * const point2 = { x: 1, y: 2 };
+     * const cross = VectorOps.crossProduct(point1, point2);
+     * ```
+     */
+    static crossProduct(point1, point2) {
+        return point1.x * point2.y - point1.y * point2.x;
+    }
+    /**
+     * Returns the closest point on an edge segment to the given point.
      *
      * @param {Point} point - Point to project. Should have properties `x` and `y`.
      * @param {Edge} edge - Edge to project onto, defined by two endpoints `point1` and `point2`.
@@ -98,15 +118,18 @@ export class VectorOps {
      * ```typescript
      * const point = { x: 3, y: 4 };
      * const edge = { point1: { x: 0, y: 0 }, point2: { x: 10, y: 0 } };
-     * const projected = VectorOps.projectPointToEdge(point, edge);
+     * const projected = VectorOps.getClosestPointOnEdge(point, edge);
      * ```
      */
-    static projectPointToEdge(point, edge) {
+    static getClosestPointOnEdge(point, edge) {
         const abVector = new Vector2(edge.point2.x - edge.point1.x, edge.point2.y - edge.point1.y);
         const apVector = new Vector2(point.x - edge.point1.x, point.y - edge.point1.y);
-        const dotProduct = VectorOps.dotProduct(apVector, abVector);
         const lengthSquared = abVector.x * abVector.x + abVector.y * abVector.y;
-        const t = dotProduct / lengthSquared;
+        if (lengthSquared === 0) {
+            return edge.point1;
+        }
+        const dotProduct = VectorOps.dotProduct(apVector, abVector);
+        const t = Math.max(0, Math.min(1, dotProduct / lengthSquared));
         return {
             x: edge.point1.x + t * abVector.x,
             y: edge.point1.y + t * abVector.y,

package/build/engine/math-lib/vector/vector2.d.ts

@@ -15,28 +15,43 @@ export declare class Vector2 {
      */
     constructor(x: number, y: number);
     /**
-     * Calculates the magnitude of the vector.
+     * Returns the Euclidean length of the vector.
+     *
      * @returns Magnitude of the vector
      */
     get magnitude(): number;
     /**
-     * Adds the given vector to the current vector.
+     * Adds another vector to the current vector in place.
+     *
      * @param vector - Vector to add
+     * @returns The current vector after the addition
      */
-    add(vector: Vector2): void;
+    add(vector: Vector2): Vector2;
     /**
-     * Multiplies the current vector by the given number.
+     * Multiplies the current vector by a scalar in place.
+     *
      * @param number - Number to multiply by
+     * @returns The current vector after scaling
      */
-    multiplyNumber(number: number): void;
+    multiplyNumber(number: number): Vector2;
     /**
-     * Checks if the current vector is equal to the given vector.
+     * Normalizes the current vector to unit length in place.
+     *
+     * If the vector magnitude is zero, it remains unchanged.
+     *
+     * @returns The current vector after normalization
+     */
+    normalize(): Vector2;
+    /**
+     * Checks whether another vector has the same coordinates.
+     *
      * @param vector - Vector to compare with
      * @returns True if the vectors are equal, false otherwise
      */
     equals(vector: Vector2): boolean;
     /**
-     * Creates a new vector with the same x and y coordinates as the current vector.
+     * Creates a new vector with the same coordinates.
+     *
      * @returns A new vector with the same x and y coordinates
      */
     clone(): Vector2;

package/build/engine/math-lib/vector/vector2.js

@@ -18,30 +18,53 @@ export class Vector2 {
         this.y = y;
     }
     /**
-     * Calculates the magnitude of the vector.
+     * Returns the Euclidean length of the vector.
+     *
      * @returns Magnitude of the vector
      */
     get magnitude() {
         return Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2));
     }
     /**
-     * Adds the given vector to the current vector.
+     * Adds another vector to the current vector in place.
+     *
      * @param vector - Vector to add
+     * @returns The current vector after the addition
      */
     add(vector) {
         this.x += vector.x;
         this.y += vector.y;
+        return this;
     }
     /**
-     * Multiplies the current vector by the given number.
+     * Multiplies the current vector by a scalar in place.
+     *
      * @param number - Number to multiply by
+     * @returns The current vector after scaling
      */
     multiplyNumber(number) {
         this.x *= number;
         this.y *= number;
+        return this;
     }
     /**
-     * Checks if the current vector is equal to the given vector.
+     * Normalizes the current vector to unit length in place.
+     *
+     * If the vector magnitude is zero, it remains unchanged.
+     *
+     * @returns The current vector after normalization
+     */
+    normalize() {
+        const magnitude = this.magnitude;
+        if (magnitude === 0) {
+            return this;
+        }
+        this.multiplyNumber(1 / magnitude);
+        return this;
+    }
+    /**
+     * Checks whether another vector has the same coordinates.
+     *
      * @param vector - Vector to compare with
      * @returns True if the vectors are equal, false otherwise
      */
@@ -49,7 +72,8 @@ export class Vector2 {
         return this.x === vector.x && this.y === vector.y;
     }
     /**
-     * Creates a new vector with the same x and y coordinates as the current vector.
+     * Creates a new vector with the same coordinates.
+     *
      * @returns A new vector with the same x and y coordinates
      */
     clone() {

package/build/engine/template/template-collection.js

@@ -10,7 +10,7 @@ export class TemplateCollection {
         this.storage = {};
     }
     buildTemplate(options) {
-        const { id, name, components = [], children = [], } = options;
+        const { id, name, components = [], children = [] } = options;
         const template = new Template({ id, name });
         children.forEach((child) => {
             const childTemplate = this.buildTemplate(child);

package/build/engine/world/index.d.ts

@@ -4,19 +4,19 @@ import type { WorldEventMap, SceneEventMap, ActorEventMap } from '../../types/ev
 import { Entity } from '../entity';
 import type { EntityOptions } from '../entity';
 import type { EventType, Event, EventPayload } from '../event-target';
-import type { Constructor } from '../../types/utils';
+import { SystemAPIRegistry } from './system-api-registry';
 type WorldListenerFn<T extends EventType> = (event: T extends keyof WorldEventMap ? WorldEventMap[T] : T extends keyof SceneEventMap ? SceneEventMap[T] : T extends keyof ActorEventMap ? ActorEventMap[T] : Event) => void;
 /**
  * A world is the root container for all scenes and actors.
- * It is used to contain the overall game state and provide system services.
+ * It is also provide an access to system APIs.
  *
  * @extends {Entity}
  *
  * @category Core
  */
 export declare class World extends Entity {
-    /** Services registered in the world by systems */
-    private services;
+    /** Registry of system APIs */
+    readonly systemApi: SystemAPIRegistry;
     readonly children: Scene[];
     /** Custom data storage for world-related information */
     data: Record<string, unknown>;
@@ -31,25 +31,5 @@ export declare class World extends Entity {
     findChild(predicate: (child: Scene | Actor) => boolean, recursive?: boolean): Scene | Actor | undefined;
     findChildById(id: string, recursive?: boolean): Scene | Actor | undefined;
     findChildByName(name: string, recursive?: boolean): Scene | Actor | undefined;
-    /**
-     * Adds a service to the world.
-     * Usually added by systems to share their functionality with other systems or behaviors
-     *
-     * @param service - Service to add to the world
-     */
-    addService(service: object): void;
-    /**
-     * Removes a service from the world.
-     *
-     * @param serviceClass - Class of the service to remove
-     */
-    removeService<T>(serviceClass: Constructor<T>): void;
-    /**
-     * Gets a service from the world.
-     *
-     * @param serviceClass - Class of the service to get
-     * @returns service
-     */
-    getService<T>(serviceClass: Constructor<T>): T;
 }
 export {};

package/build/engine/world/index.js

@@ -1,21 +1,22 @@
 import { Entity } from '../entity';
+import { SystemAPIRegistry } from './system-api-registry';
 /**
  * A world is the root container for all scenes and actors.
- * It is used to contain the overall game state and provide system services.
+ * It is also provide an access to system APIs.
  *
  * @extends {Entity}
  *
  * @category Core
  */
 export class World extends Entity {
-    /** Services registered in the world by systems */
-    services;
+    /** Registry of system APIs */
+    systemApi;
     /** Custom data storage for world-related information */
     data;
     constructor(options) {
         super(options);
+        this.systemApi = new SystemAPIRegistry();
         this.data = {};
-        this.services = {};
     }
     addEventListener(type, callback) {
         super.addEventListener(type, callback);
@@ -44,33 +45,4 @@ export class World extends Entity {
     findChildByName(name, recursive = true) {
         return super.findChildByName(name, recursive);
     }
-    /**
-     * Adds a service to the world.
-     * Usually added by systems to share their functionality with other systems or behaviors
-     *
-     * @param service - Service to add to the world
-     */
-    addService(service) {
-        this.services[service.constructor.name] = service;
-    }
-    /**
-     * Removes a service from the world.
-     *
-     * @param serviceClass - Class of the service to remove
-     */
-    removeService(serviceClass) {
-        delete this.services[serviceClass.name];
-    }
-    /**
-     * Gets a service from the world.
-     *
-     * @param serviceClass - Class of the service to get
-     * @returns service
-     */
-    getService(serviceClass) {
-        if (this.services[serviceClass.name] === undefined) {
-            throw new Error(`Can't find service with the following name: ${serviceClass.name}`);
-        }
-        return this.services[serviceClass.name];
-    }
 }

package/build/engine/world/system-api-registry.d.ts

@@ -0,0 +1,17 @@
+import type { Constructor } from '../../types/utils';
+/**
+ * Registry for system-exposed APIs.
+ *
+ * APIs are stored by their class constructor as a key:
+ * `world.systemApi.get(PhysicsAPI)`.
+ *
+ * @category Core
+ */
+export declare class SystemAPIRegistry {
+    private entries;
+    constructor();
+    register<T extends object>(api: T): void;
+    unregister<T>(apiClass: Constructor<T>): void;
+    get<T>(apiClass: Constructor<T>): T;
+    has<T>(apiClass: Constructor<T>): boolean;
+}

package/build/engine/world/system-api-registry.js

@@ -0,0 +1,34 @@
+/**
+ * Registry for system-exposed APIs.
+ *
+ * APIs are stored by their class constructor as a key:
+ * `world.systemApi.get(PhysicsAPI)`.
+ *
+ * @category Core
+ */
+export class SystemAPIRegistry {
+    entries;
+    constructor() {
+        this.entries = new Map();
+    }
+    register(api) {
+        const apiClass = api.constructor;
+        if (this.entries.has(apiClass)) {
+            throw new Error(`API already registered: ${apiClass.name}`);
+        }
+        this.entries.set(apiClass, api);
+    }
+    unregister(apiClass) {
+        this.entries.delete(apiClass);
+    }
+    get(apiClass) {
+        const api = this.entries.get(apiClass);
+        if (!api) {
+            throw new Error(`Can't find API with the following name: ${apiClass.name}`);
+        }
+        return api;
+    }
+    has(apiClass) {
+        return this.entries.has(apiClass);
+    }
+}

package/build/events/index.d.ts

@@ -1,4 +1,4 @@
 export { AddActor, RemoveActor, LoadScene, EnterScene, ExitScene, DestroyScene, SceneLoaded, SceneEntered, SceneExited, SceneDestroyed, } from '../engine/events';
 export type { AddActorEvent, RemoveActorEvent, LoadSceneEvent, EnterSceneEvent, ExitSceneEvent, DestroySceneEvent, SceneLoadedEvent, SceneEnteredEvent, SceneExitedEvent, SceneDestroyedEvent, } from '../engine/events';
-export { GameStatsUpdate, KeyboardInput, MouseInput, CollisionEnter, CollisionStay, CollisionLeave, AddForce, AddImpulse, PlayAudio, StopAudio, SetAudioVolume, } from '../contrib/events';
-export type { GameStatsUpdateEvent, KeyboardInputEvent, MouseInputEvent, KeyboardControlEvent, MouseControlEvent, CollisionEnterEvent, CollisionStayEvent, CollisionLeaveEvent, AddForceEvent, AddImpulseEvent, SetAudioGroupVolumeEvent, SetAudioSourceVolumeEvent, } from '../contrib/events';
+export { GameStatsUpdate, KeyboardInput, MouseInput, CollisionEnter, CollisionStay, CollisionLeave, PlayAudio, StopAudio, SetAudioVolume, } from '../contrib/events';
+export type { GameStatsUpdateEvent, KeyboardInputEvent, MouseInputEvent, KeyboardControlEvent, MouseControlEvent, CollisionEnterEvent, CollisionStayEvent, CollisionLeaveEvent, SetAudioGroupVolumeEvent, SetAudioSourceVolumeEvent, } from '../contrib/events';

package/build/events/index.js

@@ -1,2 +1,2 @@
 export { AddActor, RemoveActor, LoadScene, EnterScene, ExitScene, DestroyScene, SceneLoaded, SceneEntered, SceneExited, SceneDestroyed, } from '../engine/events';
-export { GameStatsUpdate, KeyboardInput, MouseInput, CollisionEnter, CollisionStay, CollisionLeave, AddForce, AddImpulse, PlayAudio, StopAudio, SetAudioVolume, } from '../contrib/events';
+export { GameStatsUpdate, KeyboardInput, MouseInput, CollisionEnter, CollisionStay, CollisionLeave, PlayAudio, StopAudio, SetAudioVolume, } from '../contrib/events';

package/build/types/global.d.ts

@@ -23,6 +23,10 @@ declare module 'pixi.js' {
                 sortCenter: [number, number];
             };
             meta: Record<string, unknown>;
+            /**
+             * Flag to indicate if the view is fully initialized and ready (parent set and position updated)
+             */
+            isReady?: boolean;
         };
     }
     interface Filter {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dacha",
-  "version": "0.17.2",
+  "version": "0.18.0-alpha.1",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "exports": {
@@ -16,6 +16,9 @@
     },
     "./renderer": {
       "types": "./build/contrib/systems/renderer/types.d.ts"
+    },
+    "./physics": {
+      "types": "./build/contrib/systems/physics-system/types.d.ts"
     }
   },
   "dependencies": {

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

@@ -1,16 +0,0 @@
-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;