dacha 0.17.2 → 0.18.0-alpha.1

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

@@ -1,14 +1,14 @@
 export { Animator } from './animator';
-export { CameraSystem, CameraService } from './camera-system';
+export { CameraSystem, CameraAPI } from './camera-system';
 export { GameStatsMeter } from './game-stats-meter';
 export { KeyboardInputSystem } from './keyboard-input-system';
 export { KeyboardControlSystem } from './keyboard-control-system';
 export { MouseControlSystem } from './mouse-control-system';
 export { MouseInputSystem } from './mouse-input-system';
-export { PhysicsSystem } from './physics-system';
+export { PhysicsSystem, PhysicsAPI } from './physics-system';
 export { BehaviorSystem, Behavior } from './behavior-system';
 export type { BehaviorOptions } from './behavior-system';
 export { UIBridge } from './ui-bridge';
 export type { UIOptions, UIInitFn, UIDestroyFn, LoadUIFn } from './ui-bridge';
 export { AudioSystem } from './audio-system';
-export { Renderer, RendererService, FilterEffect, Shader } from './renderer';
+export { Renderer, RendererAPI, FilterEffect, Shader } from './renderer';

package/build/contrib/systems/index.js

@@ -1,12 +1,12 @@
 export { Animator } from './animator';
-export { CameraSystem, CameraService } from './camera-system';
+export { CameraSystem, CameraAPI } from './camera-system';
 export { GameStatsMeter } from './game-stats-meter';
 export { KeyboardInputSystem } from './keyboard-input-system';
 export { KeyboardControlSystem } from './keyboard-control-system';
 export { MouseControlSystem } from './mouse-control-system';
 export { MouseInputSystem } from './mouse-input-system';
-export { PhysicsSystem } from './physics-system';
+export { PhysicsSystem, PhysicsAPI } from './physics-system';
 export { BehaviorSystem, Behavior } from './behavior-system';
 export { UIBridge } from './ui-bridge';
 export { AudioSystem } from './audio-system';
-export { Renderer, RendererService, FilterEffect, Shader } from './renderer';
+export { Renderer, RendererAPI, FilterEffect, Shader } from './renderer';

package/build/contrib/systems/mouse-input-system/subsystems/coordinates-projector/index.d.ts

@@ -1,7 +1,6 @@
 import type { WorldSystemOptions } from '../../../../../engine/system';
 export declare class CoordinatesProjector {
     private world;
-    private cameraService;
     constructor(options: WorldSystemOptions);
     destroy(): void;
     private handleMouseInput;

package/build/contrib/systems/mouse-input-system/subsystems/coordinates-projector/index.js

@@ -1,20 +1,19 @@
 import { MouseInput } from '../../../../events';
-import { CameraService } from '../../../camera-system';
-import { getProjectedX, getProjectedY } from '../../../../utils/coordinates-projection';
+import { CameraAPI } from '../../../camera-system';
+import { getProjectedX, getProjectedY, } from '../../../../utils/coordinates-projection';
 export class CoordinatesProjector {
     world;
-    cameraService;
     constructor(options) {
         const { world } = options;
         this.world = world;
-        this.cameraService = world.getService(CameraService);
         this.world.addEventListener(MouseInput, this.handleMouseInput);
     }
     destroy() {
         this.world.removeEventListener(MouseInput, this.handleMouseInput);
     }
     handleMouseInput = (event) => {
-        const currentCamera = this.cameraService.getCurrentCamera();
+        const cameraApi = this.world.systemApi.get(CameraAPI);
+        const currentCamera = cameraApi.getCurrentCamera();
         event.x = currentCamera ? getProjectedX(event.x, currentCamera) : event.x;
         event.y = currentCamera ? getProjectedY(event.y, currentCamera) : event.y;
     };

package/build/contrib/systems/physics-system/api.d.ts

@@ -0,0 +1,58 @@
+import type { Actor } from '../../../engine/actor';
+import type { CollisionDetectionSubsystem } from './subsystems';
+import type { RaycastHit, RaycastParams, OverlapBoxParams, OverlapCircleParams, OverlapPointParams } from './types';
+/**
+ * API that provides methods for performing physics queries such as raycasting and overlap tests.
+ *
+ * Query results are based on the latest prepared physics state.
+ * That state is updated during the physics system fixed update step,
+ * so direct transform or collider changes made outside physics update
+ * are not guaranteed to be reflected immediately in query results.
+ *
+ * @category Systems
+ */
+export declare class PhysicsAPI {
+    private collisionDetectionSubsystem;
+    constructor(collisionDetectionSubsystem: CollisionDetectionSubsystem);
+    /**
+     * Casts a ray and returns the nearest hit, if any.
+     *
+     * The ray starts at `params.origin`, travels in `params.direction`,
+     * and is limited by `params.maxDistance`.
+     *
+     * @param params - Raycast parameters
+     * @returns The nearest hit or `null` when nothing is hit
+     */
+    raycast(params: RaycastParams): RaycastHit | null;
+    /**
+     * Casts a ray and returns all hits sorted by distance.
+     *
+     * The ray starts at `params.origin`, travels in `params.direction`,
+     * and is limited by `params.maxDistance`.
+     *
+     * @param params - Raycast parameters
+     * @returns All hits sorted from nearest to farthest
+     */
+    raycastAll(params: RaycastParams): RaycastHit[];
+    /**
+     * Returns all actors whose colliders contain the given point.
+     *
+     * @param params - Point overlap parameters
+     * @returns Actors whose colliders overlap the point
+     */
+    overlapPoint(params: OverlapPointParams): Actor[];
+    /**
+     * Returns all actors whose colliders overlap the given circle.
+     *
+     * @param params - Circle overlap parameters
+     * @returns Actors whose colliders overlap the circle
+     */
+    overlapCircle(params: OverlapCircleParams): Actor[];
+    /**
+     * Returns all actors whose colliders overlap the given box.
+     *
+     * @param params - Box overlap parameters
+     * @returns Actors whose colliders overlap the box
+     */
+    overlapBox(params: OverlapBoxParams): Actor[];
+}

package/build/contrib/systems/physics-system/api.js

@@ -0,0 +1,67 @@
+/**
+ * API that provides methods for performing physics queries such as raycasting and overlap tests.
+ *
+ * Query results are based on the latest prepared physics state.
+ * That state is updated during the physics system fixed update step,
+ * so direct transform or collider changes made outside physics update
+ * are not guaranteed to be reflected immediately in query results.
+ *
+ * @category Systems
+ */
+export class PhysicsAPI {
+    collisionDetectionSubsystem;
+    constructor(collisionDetectionSubsystem) {
+        this.collisionDetectionSubsystem = collisionDetectionSubsystem;
+    }
+    /**
+     * Casts a ray and returns the nearest hit, if any.
+     *
+     * The ray starts at `params.origin`, travels in `params.direction`,
+     * and is limited by `params.maxDistance`.
+     *
+     * @param params - Raycast parameters
+     * @returns The nearest hit or `null` when nothing is hit
+     */
+    raycast(params) {
+        return this.collisionDetectionSubsystem.raycast(params);
+    }
+    /**
+     * Casts a ray and returns all hits sorted by distance.
+     *
+     * The ray starts at `params.origin`, travels in `params.direction`,
+     * and is limited by `params.maxDistance`.
+     *
+     * @param params - Raycast parameters
+     * @returns All hits sorted from nearest to farthest
+     */
+    raycastAll(params) {
+        return this.collisionDetectionSubsystem.raycastAll(params);
+    }
+    /**
+     * Returns all actors whose colliders contain the given point.
+     *
+     * @param params - Point overlap parameters
+     * @returns Actors whose colliders overlap the point
+     */
+    overlapPoint(params) {
+        return this.collisionDetectionSubsystem.overlapPoint(params);
+    }
+    /**
+     * Returns all actors whose colliders overlap the given circle.
+     *
+     * @param params - Circle overlap parameters
+     * @returns Actors whose colliders overlap the circle
+     */
+    overlapCircle(params) {
+        return this.collisionDetectionSubsystem.overlapCircle(params);
+    }
+    /**
+     * Returns all actors whose colliders overlap the given box.
+     *
+     * @param params - Box overlap parameters
+     * @returns Actors whose colliders overlap the box
+     */
+    overlapBox(params) {
+        return this.collisionDetectionSubsystem.overlapBox(params);
+    }
+}

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

@@ -1,21 +1,2 @@
-import { SceneSystem } from '../../../engine/system';
-import type { SceneSystemOptions, UpdateOptions } from '../../../engine/system';
-/**
- * Physics system that handles 2D physics simulation and collision detection
- *
- * Manages rigid body physics and collision detection and resolution.
- *
- * @extends SceneSystem
- *
- * @category Systems
- */
-export declare class PhysicsSystem extends SceneSystem {
-    private physicsSubsystem;
-    private collisionDetectionSubsystem;
-    private collisionBroadcastSubsystem;
-    private collisionSolver;
-    private constraintSolver;
-    constructor(options: SceneSystemOptions);
-    onSceneDestroy(): void;
-    fixedUpdate(options: UpdateOptions): void;
-}
+export { PhysicsSystem } from './physics-system';
+export { PhysicsAPI } from './api';

package/build/contrib/systems/physics-system/index.js

@@ -1,40 +1,2 @@
-import { SceneSystem } from '../../../engine/system';
-import { PhysicsSubsystem, CollisionDetectionSubsystem, CollisionBroadcastSubsystem, CollisionSolver, ConstraintSolver, } from './subsystems';
-/**
- * Physics system that handles 2D physics simulation and collision detection
- *
- * Manages rigid body physics and collision detection and resolution.
- *
- * @extends SceneSystem
- *
- * @category Systems
- */
-export class PhysicsSystem extends SceneSystem {
-    physicsSubsystem;
-    collisionDetectionSubsystem;
-    collisionBroadcastSubsystem;
-    collisionSolver;
-    constraintSolver;
-    constructor(options) {
-        super();
-        this.physicsSubsystem = new PhysicsSubsystem(options);
-        this.collisionDetectionSubsystem = new CollisionDetectionSubsystem(options);
-        this.collisionBroadcastSubsystem = new CollisionBroadcastSubsystem(options);
-        this.collisionSolver = new CollisionSolver(options);
-        this.constraintSolver = new ConstraintSolver(options);
-    }
-    onSceneDestroy() {
-        this.physicsSubsystem.destroy();
-        this.collisionDetectionSubsystem.destroy();
-        this.collisionSolver.destroy();
-        this.constraintSolver.destroy();
-        this.collisionBroadcastSubsystem.destroy();
-    }
-    fixedUpdate(options) {
-        this.physicsSubsystem.update(options);
-        this.collisionDetectionSubsystem.update();
-        this.constraintSolver.update();
-        this.collisionBroadcastSubsystem.update();
-    }
-}
-PhysicsSystem.systemName = 'PhysicsSystem';
+export { PhysicsSystem } from './physics-system';
+export { PhysicsAPI } from './api';

package/build/contrib/systems/physics-system/physics-system.d.ts

@@ -0,0 +1,24 @@
+import { SceneSystem } from '../../../engine/system';
+import type { SceneSystemOptions, UpdateOptions } from '../../../engine/system';
+/**
+ * Physics system that handles 2D physics simulation and collision detection
+ *
+ * Manages rigid body physics and collision detection and resolution.
+ *
+ * @extends SceneSystem
+ *
+ * @category Systems
+ */
+export declare class PhysicsSystem extends SceneSystem {
+    private world;
+    private physicsSubsystem;
+    private collisionDetectionSubsystem;
+    private collisionBroadcastSubsystem;
+    private constraintSolver;
+    private physicsApi;
+    constructor(options: SceneSystemOptions);
+    onSceneEnter(): void;
+    onSceneExit(): void;
+    onSceneDestroy(): void;
+    fixedUpdate(options: UpdateOptions): void;
+}

package/build/contrib/systems/physics-system/physics-system.js

@@ -0,0 +1,47 @@
+import { SceneSystem } from '../../../engine/system';
+import { PhysicsSubsystem, CollisionDetectionSubsystem, CollisionBroadcastSubsystem, ConstraintSolver, } from './subsystems';
+import { PhysicsAPI } from './api';
+/**
+ * Physics system that handles 2D physics simulation and collision detection
+ *
+ * Manages rigid body physics and collision detection and resolution.
+ *
+ * @extends SceneSystem
+ *
+ * @category Systems
+ */
+export class PhysicsSystem extends SceneSystem {
+    world;
+    physicsSubsystem;
+    collisionDetectionSubsystem;
+    collisionBroadcastSubsystem;
+    constraintSolver;
+    physicsApi;
+    constructor(options) {
+        super();
+        this.world = options.world;
+        this.physicsSubsystem = new PhysicsSubsystem(options);
+        this.collisionDetectionSubsystem = new CollisionDetectionSubsystem(options);
+        this.collisionBroadcastSubsystem = new CollisionBroadcastSubsystem();
+        this.constraintSolver = new ConstraintSolver();
+        this.physicsApi = new PhysicsAPI(this.collisionDetectionSubsystem);
+    }
+    onSceneEnter() {
+        this.world.systemApi.register(this.physicsApi);
+    }
+    onSceneExit() {
+        this.world.systemApi.unregister(PhysicsAPI);
+    }
+    onSceneDestroy() {
+        this.world.systemApi.unregister(PhysicsAPI);
+        this.physicsSubsystem.destroy();
+        this.collisionDetectionSubsystem.destroy();
+    }
+    fixedUpdate(options) {
+        this.physicsSubsystem.update(options);
+        const contacts = this.collisionDetectionSubsystem.update();
+        this.constraintSolver.update(contacts);
+        this.collisionBroadcastSubsystem.update(contacts);
+    }
+}
+PhysicsSystem.systemName = 'PhysicsSystem';

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

@@ -1,13 +1,15 @@
 import type { Actor } from '../../../../../engine/actor';
 import type { Vector2 } from '../../../../../engine/math-lib';
+import type { Point } from '../collision-detection/types';
 export type CollisionState = 'enter' | 'stay' | 'leave';
 export declare class Collision {
     private lifetime;
     actor1: Actor;
     actor2: Actor;
-    mtv1: Vector2;
-    mtv2: Vector2;
-    constructor(actor1: Actor, actor2: Actor, mtv1: Vector2, mtv2: Vector2);
+    normal: Vector2;
+    penetration: number;
+    contactPoints: Point[];
+    constructor(actor1: Actor, actor2: Actor, normal: Vector2, penetration: number, contactPoints: Point[]);
     isFinished(): boolean;
     signal(): void;
     tick(): void;

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

@@ -7,14 +7,16 @@ export class Collision {
     lifetime;
     actor1;
     actor2;
-    mtv1;
-    mtv2;
-    constructor(actor1, actor2, mtv1, mtv2) {
+    normal;
+    penetration;
+    contactPoints;
+    constructor(actor1, actor2, normal, penetration, contactPoints) {
         this.actor1 = actor1;
         this.actor2 = actor2;
         this.lifetime = 2;
-        this.mtv1 = mtv1;
-        this.mtv2 = mtv2;
+        this.normal = normal;
+        this.penetration = penetration;
+        this.contactPoints = contactPoints;
     }
     isFinished() {
         return this.lifetime < 0;

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

@@ -1,11 +1,9 @@
-import type { SceneSystemOptions } from '../../../../../engine/system';
+import type { Contact } from '../collision-detection/types';
 export declare class CollisionBroadcastSubsystem {
-    private scene;
     private collisionMap;
     private activeCollisions;
-    constructor(options: SceneSystemOptions);
-    destroy(): void;
-    private handleCollision;
+    constructor();
+    private trackCollision;
     private publishEvent;
-    update(): void;
+    update(contacts: Contact[]): void;
 }

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

@@ -1,4 +1,4 @@
-import { Collision as RawCollision, CollisionEnter, CollisionStay, CollisionLeave, } from '../../../../events';
+import { CollisionEnter, CollisionStay, CollisionLeave, } from '../../../../events';
 import { Collision } from './collision';
 const STATE_TO_EVENT = {
     enter: CollisionEnter,
@@ -6,40 +6,43 @@ const STATE_TO_EVENT = {
     leave: CollisionLeave,
 };
 export class CollisionBroadcastSubsystem {
-    scene;
     collisionMap;
     activeCollisions;
-    constructor(options) {
-        this.scene = options.scene;
+    constructor() {
         this.collisionMap = {};
         this.activeCollisions = [];
-        this.scene.addEventListener(RawCollision, this.handleCollision);
     }
-    destroy() {
-        this.scene.removeEventListener(RawCollision, this.handleCollision);
-    }
-    handleCollision = (event) => {
-        const { actor1, actor2, mtv1, mtv2, } = event;
+    trackCollision(actor1, actor2, normal, penetration, contactPoints) {
         this.collisionMap[actor1.id] = this.collisionMap[actor1.id] || {};
         if (!this.collisionMap[actor1.id][actor2.id]) {
-            const collision = new Collision(actor1, actor2, mtv1, mtv2);
+            const collision = new Collision(actor1, actor2, normal, penetration, contactPoints);
             this.collisionMap[actor1.id][actor2.id] = collision;
             this.activeCollisions.push(collision);
         }
         else {
-            this.collisionMap[actor1.id][actor2.id].mtv1 = mtv1;
-            this.collisionMap[actor1.id][actor2.id].mtv2 = mtv2;
+            this.collisionMap[actor1.id][actor2.id].normal = normal;
+            this.collisionMap[actor1.id][actor2.id].penetration = penetration;
+            this.collisionMap[actor1.id][actor2.id].contactPoints = contactPoints;
             this.collisionMap[actor1.id][actor2.id].signal();
         }
-    };
+    }
     publishEvent(collision) {
-        const { actor1, actor2, mtv1, } = collision;
+        const { actor1, actor2, normal, penetration, contactPoints } = collision;
         actor1.dispatchEvent(STATE_TO_EVENT[collision.getState()], {
             actor: actor2,
-            mtv: mtv1,
+            normal,
+            penetration,
+            contactPoints,
         });
     }
-    update() {
+    update(contacts) {
+        contacts.forEach((contact) => {
+            const { actor1, actor2, normal, penetration, contactPoints } = contact;
+            const normal2 = contact.normal.clone();
+            normal2.multiplyNumber(-1);
+            this.trackCollision(actor1, actor2, normal, penetration, contactPoints);
+            this.trackCollision(actor2, actor1, normal2, penetration, contactPoints);
+        });
         this.activeCollisions = this.activeCollisions.filter((collision) => {
             const { actor1, actor2 } = collision;
             this.publishEvent(collision);

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

@@ -1,6 +1,5 @@
 export const buildCircleAABB = (geometry) => {
-    const { radius } = geometry;
-    const { x: centerX, y: centerY } = geometry.center;
+    const { radius, center: { x: centerX, y: centerY }, } = geometry;
     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/build-point-aabb.d.ts

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

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

@@ -0,0 +1,7 @@
+export const buildPointAABB = (geometry) => {
+    const { center } = geometry;
+    return {
+        min: { ...center },
+        max: { ...center },
+    };
+};

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

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

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

@@ -0,0 +1,9 @@
+export const buildRayAABB = (geometry) => {
+    const { origin, direction, maxDistance } = geometry;
+    const endX = origin.x + direction.x * maxDistance;
+    const endY = origin.y + direction.y * maxDistance;
+    return {
+        min: { x: Math.min(origin.x, endX), y: Math.min(origin.y, endY) },
+        max: { x: Math.max(origin.x, endX), y: Math.max(origin.y, endY) },
+    };
+};

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

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

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

@@ -0,0 +1,14 @@
+import { INTERSECTION_EPSILON } from '../intersection-checkers/utils';
+export const buildSegmentAABB = (geometry) => {
+    const { point1, point2 } = geometry;
+    return {
+        min: {
+            x: Math.min(point1.x, point2.x) - INTERSECTION_EPSILON,
+            y: Math.min(point1.y, point2.y) - INTERSECTION_EPSILON,
+        },
+        max: {
+            x: Math.max(point1.x, point2.x) + INTERSECTION_EPSILON,
+            y: Math.max(point1.y, point2.y) + INTERSECTION_EPSILON,
+        },
+    };
+};

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

@@ -1,6 +1,12 @@
 import { buildBoxAABB } from './build-box-aabb';
 import { buildCircleAABB } from './build-circle-aabb';
+import { buildPointAABB } from './build-point-aabb';
+import { buildRayAABB } from './build-ray-aabb';
+import { buildSegmentAABB } from './build-segment-aabb';
 export const aabbBuilders = {
     box: buildBoxAABB,
     circle: buildCircleAABB,
+    segment: buildSegmentAABB,
+    point: buildPointAABB,
+    ray: buildRayAABB,
 };

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

@@ -1,3 +1,5 @@
 import type { Collider, Transform } from '../../../../../components';
 import type { BoxGeometry } from '../types';
-export declare const buildBoxGeometry: (collider: Collider, transform: Transform) => BoxGeometry;
+import type { OverlapBoxParams } from '../../../types';
+export declare function buildBoxGeometry(overlap: OverlapBoxParams): BoxGeometry;
+export declare function buildBoxGeometry(collider: Collider, transform: Transform): BoxGeometry;

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

@@ -1,16 +1,50 @@
 import { VectorOps } from '../../../../../../engine/math-lib';
-export const buildBoxGeometry = (collider, transform) => {
-    const { world: { position, rotation, scale }, } = transform;
-    let { centerX, centerY } = collider;
-    const { sizeX, sizeY } = collider;
+export function buildBoxGeometry(colliderOrOverlap, transform) {
+    let centerX;
+    let centerY;
+    let sizeX;
+    let sizeY;
+    let positionX;
+    let positionY;
+    let rotation;
+    let scaleX;
+    let scaleY;
+    if (transform !== undefined) {
+        const collider = colliderOrOverlap;
+        centerX = collider.centerX;
+        centerY = collider.centerY;
+        sizeX = collider.sizeX;
+        sizeY = collider.sizeY;
+        positionX = transform.world.position.x;
+        positionY = transform.world.position.y;
+        rotation = transform.world.rotation;
+        scaleX = transform.world.scale.x;
+        scaleY = transform.world.scale.y;
+    }
+    else {
+        const overlap = colliderOrOverlap;
+        centerX = 0;
+        centerY = 0;
+        sizeX = overlap.size.x;
+        sizeY = overlap.size.y;
+        positionX = overlap.center.x;
+        positionY = overlap.center.y;
+        rotation = overlap.rotation ?? 0;
+        scaleX = 1;
+        scaleY = 1;
+    }
     const x1 = -(sizeX / 2);
     const x2 = sizeX / 2;
     const y1 = -(sizeY / 2);
     const y2 = sizeY / 2;
     const cos = Math.cos(rotation);
     const sin = Math.sin(rotation);
-    centerX += position.x;
-    centerY += position.y;
+    centerX += positionX;
+    centerY += positionY;
+    const center = {
+        x: centerX,
+        y: centerY,
+    };
     const points = [
         { x: x1, y: y1 },
         { x: x1, y: y2 },
@@ -19,27 +53,29 @@ export const buildBoxGeometry = (collider, transform) => {
     ];
     points.forEach((point) => {
         const { x, y } = point;
-        const scaledX = x * scale.x;
-        const scaledY = y * scale.y;
+        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;
+        point.x = rotatedX + center.x;
+        point.y = rotatedY + center.y;
     });
     const edges = points.map((point1, index, array) => {
         const point2 = array[(index + 1) % array.length];
+        const normal = VectorOps.getNormal(point1.x, point2.x, point1.y, point2.y);
+        const offset = VectorOps.dotProduct(point1, normal);
+        if (VectorOps.dotProduct(center, normal) - offset > 0) {
+            normal.multiplyNumber(-1);
+        }
         return {
             point1,
             point2,
-            normal: VectorOps.getNormal(point1.x, point2.x, point1.y, point2.y),
+            normal,
         };
     });
     return {
-        center: {
-            x: centerX,
-            y: centerY,
-        },
+        center,
         points,
         edges,
     };
-};
+}

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

@@ -1,3 +1,5 @@
 import type { Collider, Transform } from '../../../../../components';
 import type { CircleGeometry } from '../types';
-export declare const buildCircleGeometry: (collider: Collider, transform: Transform) => CircleGeometry;
+import type { OverlapCircleParams } from '../../../types';
+export declare function buildCircleGeometry(overlap: OverlapCircleParams): CircleGeometry;
+export declare function buildCircleGeometry(collider: Collider, transform: Transform): CircleGeometry;