dacha 0.17.2 → 0.18.0-alpha.0

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

@@ -89,7 +89,7 @@ export declare class VectorOps {
      */
     static dotProduct(point: Point, vector: Vector2): number;
     /**
-     * Projects a point onto a given edge, returning the closest point
+     * 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 +100,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

@@ -87,7 +87,7 @@ export class VectorOps {
         return point.x * vector.x + point.y * vector.y;
     }
     /**
-     * Projects a point onto a given edge, returning the closest point
+     * 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 +98,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dacha",
-  "version": "0.17.2",
+  "version": "0.18.0-alpha.0",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "exports": {

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;

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

@@ -1,80 +0,0 @@
-import { Collider } 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(Collider).type === 'box') {
-        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

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

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

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

@@ -1,39 +0,0 @@
-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-solver/index.d.ts

@@ -1,10 +0,0 @@
-import type { SceneSystemOptions } from '../../../../../engine/system';
-export declare class CollisionSolver {
-    private scene;
-    private gravity;
-    constructor(options: SceneSystemOptions);
-    destroy(): void;
-    private handleCollision;
-    private validateCollision;
-    private addReactionForce;
-}

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

@@ -1,50 +0,0 @@
-import { Vector2 } from '../../../../../engine/math-lib';
-import { RigidBody } from '../../../../components/rigid-body';
-import { Collision, AddForce, StopMovement } from '../../../../events';
-import { RIGID_BODY_TYPE } from '../../consts';
-const REACTION_FORCE_VECTOR_X = 0;
-const REACTION_FORCE_VECTOR_Y = -1;
-export class CollisionSolver {
-    scene;
-    gravity;
-    constructor(options) {
-        const { scene, gravity } = options;
-        this.scene = scene;
-        this.gravity = gravity;
-        this.scene.addEventListener(Collision, this.handleCollision);
-    }
-    destroy() {
-        this.scene.removeEventListener(Collision, this.handleCollision);
-    }
-    handleCollision = (event) => {
-        const { actor1, actor2, mtv1 } = event;
-        if (!this.validateCollision(actor1, actor2)) {
-            return;
-        }
-        this.addReactionForce(actor1, mtv1);
-    };
-    validateCollision(actor1, actor2) {
-        const rigidBody1 = actor1.getComponent(RigidBody);
-        const rigidBody2 = actor2.getComponent(RigidBody);
-        if (!rigidBody1 || !rigidBody2) {
-            return false;
-        }
-        if (rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
-            return !rigidBody1.ghost && !rigidBody2.ghost;
-        }
-        return !rigidBody1.ghost && !rigidBody1.isPermeable
-            && !rigidBody2.ghost && !rigidBody2.isPermeable;
-    }
-    addReactionForce(actor, mtv) {
-        const rigidBody = actor.getComponent(RigidBody);
-        const { useGravity, mass } = rigidBody;
-        if (useGravity && mtv.y && Math.sign(mtv.y) === -1 && !mtv.x) {
-            const reactionForce = new Vector2(REACTION_FORCE_VECTOR_X, REACTION_FORCE_VECTOR_Y);
-            reactionForce.multiplyNumber(mass * this.gravity);
-            actor.dispatchEventImmediately(AddForce, {
-                value: reactionForce,
-            });
-            actor.dispatchEventImmediately(StopMovement);
-        }
-    }
-}