dacha 0.17.2 → 0.18.0-alpha.1

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);
-        }
-    }
-}

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

@@ -1,3 +0,0 @@
-import { type Container, type Matrix } from 'pixi.js';
-import { type Bounds } from '../types';
-export declare const convertBounds: (container: Container, matrix: Matrix) => Bounds;