@ue-too/dynamics 0.5.1

package/index.js

@@ -0,0 +1,925 @@
+import { PointCal } from '@ue-too/math';
+
+class BaseRigidBody {
+    constructor(center, _orientationAngle = 0, mass = 50, isStaticBody = false, frictionEnabled = false) {
+        this._mass = 50;
+        this._orientationAngle = 0;
+        this.isStaticBody = false;
+        this._staticFrictionCoeff = 0.3;
+        this.dynamicFrictionCoeff = 0.3;
+        this.frictionEnabled = false;
+        this.isMovingStaticBody = false;
+        this.angularDampingFactor = 0.005;
+        this._center = center;
+        this._orientationAngle = _orientationAngle;
+        this._mass = mass;
+        this.isStaticBody = isStaticBody;
+        this.frictionEnabled = frictionEnabled;
+        this.force = { x: 0, y: 0 };
+        this.linearAcceleartion = { x: 0, y: 0 };
+        this._linearVelocity = { x: 0, y: 0 };
+        this._angularVelocity = 0;
+    }
+    move(delta) {
+        if (!this.isStatic()) {
+            this._center = PointCal.addVector(this._center, delta);
+        }
+    }
+    rotateRadians(angle) {
+        this._orientationAngle += angle;
+    }
+    getCenter() {
+        return this._center;
+    }
+    getOrientationAngle() {
+        return this._orientationAngle;
+    }
+    get angularVelocity() {
+        return this._angularVelocity;
+    }
+    set angularVelocity(angularVelocity) {
+        this._angularVelocity = angularVelocity;
+    }
+    get orientationAngle() {
+        return this._orientationAngle;
+    }
+    isStatic() {
+        return this.isStaticBody;
+    }
+    isMovingStatic() {
+        return this.isMovingStaticBody;
+    }
+    setLinearVelocity(linearVelocity) {
+        this._linearVelocity = linearVelocity;
+    }
+    setMovingStatic(movingStatic) {
+        this.isMovingStaticBody = movingStatic;
+    }
+    setOrientationAngle(angle) {
+        this._orientationAngle = angle;
+    }
+    applyForce(force) {
+        if (PointCal.magnitude(this.force) !== 0) {
+            this.force = PointCal.addVector(this.force, force);
+        }
+        else {
+            this.force = force;
+        }
+    }
+    applyForceInOrientation(force) {
+        let forceTransformed;
+        if (typeof force === "number") {
+            forceTransformed = PointCal.rotatePoint({ x: force, y: 0 }, this._orientationAngle);
+        }
+        else {
+            forceTransformed = PointCal.rotatePoint(force, this._orientationAngle);
+        }
+        this.applyForce(forceTransformed);
+    }
+    step(deltaTime) {
+        if (this.frictionEnabled) {
+            if (this.isStatic() ||
+                (this.linearVelocity.x == 0 &&
+                    this.linearVelocity.y == 0 &&
+                    PointCal.magnitude(PointCal.subVector({ x: this.force.x, y: this.force.y }, { x: 0, y: 0 })) >= 0 &&
+                    PointCal.magnitude({ x: this.force.x, y: this.force.y }) < this.staticFrictionCoeff * this.mass * 9.81)) {
+                if (this.force.z != undefined) {
+                    this.force = { x: 0, y: 0, z: this.force.z };
+                }
+                else {
+                    this.force = { x: 0, y: 0 };
+                }
+                // return;
+            }
+            else {
+                let kineticFrictionDirection = PointCal.multiplyVectorByScalar(PointCal.unitVector({ x: this._linearVelocity.x, y: this._linearVelocity.y }), -1);
+                let kineticFriction = PointCal.multiplyVectorByScalar(kineticFrictionDirection, this.dynamicFrictionCoeff * this.mass * 9.81);
+                this.force = PointCal.addVector(this.force, kineticFriction);
+            }
+        }
+        const angularDamping = this._angularVelocity != 0 ? this._angularVelocity > 0 ? -this.angularDampingFactor : this.angularDampingFactor : 0;
+        // console.log("angular velocity", this._angularVelocity);
+        // console.log("angular damping", angularDamping);
+        if (Math.abs(this._angularVelocity) < Math.abs(angularDamping)) {
+            this._angularVelocity = 0;
+        }
+        else {
+            this._angularVelocity += angularDamping;
+        }
+        this._orientationAngle += this._angularVelocity * deltaTime;
+        if (PointCal.magnitude({ x: this._linearVelocity.x, y: this._linearVelocity.y }) < PointCal.magnitude(PointCal.divideVectorByScalar(PointCal.multiplyVectorByScalar(this.force, deltaTime), this.mass))) {
+            if (this._linearVelocity.z != undefined) {
+                this._linearVelocity = { x: 0, y: 0, z: this._linearVelocity.z };
+            }
+            else {
+                this._linearVelocity = { x: 0, y: 0 };
+            }
+        }
+        const gravitationalForce = -9.81 * this._mass;
+        this.force = PointCal.addVector(this.force, { x: 0, y: 0, z: gravitationalForce });
+        this._linearVelocity = PointCal.addVector(this._linearVelocity, PointCal.divideVectorByScalar(PointCal.multiplyVectorByScalar(this.force, deltaTime), this.mass));
+        this._center = PointCal.addVector(this._center, PointCal.multiplyVectorByScalar(this._linearVelocity, deltaTime));
+        if (this._center.z != undefined && this._center.z < 0) {
+            this._center.z = 0;
+        }
+        this.force = { x: 0, y: 0 };
+    }
+    get center() {
+        return this._center;
+    }
+    set center(dest) {
+        this._center = dest;
+    }
+    get linearVelocity() {
+        return this._linearVelocity;
+    }
+    set linearVelocity(dest) {
+        this._linearVelocity = dest;
+    }
+    get mass() {
+        return this._mass;
+    }
+    get staticFrictionCoeff() {
+        return this._staticFrictionCoeff;
+    }
+    set staticFrictionCoeff(coeff) {
+        this._staticFrictionCoeff = coeff;
+    }
+}
+class VisaulCircleBody {
+    constructor(center = { x: 0, y: 0 }, radius, drawingContext, _orientationAngle = 0, mass = 50, isStatic = false, frictionEnabled = true) {
+        this._circle = new Circle(center, radius, _orientationAngle, mass, isStatic, frictionEnabled);
+        this._context = drawingContext;
+    }
+    draw(ctx) {
+        ctx.beginPath();
+        ctx.arc(this._circle.center.x, this._circle.center.y, this._circle.radius, 0, 2 * Math.PI);
+        ctx.stroke();
+    }
+    step(deltaTime) {
+        this._circle.step(deltaTime);
+        this.draw(this._context);
+    }
+    isStatic() {
+        return this._circle.isStatic();
+    }
+    isMovingStatic() {
+        return this._circle.isMovingStatic();
+    }
+    getMinMaxProjection(unitvector) {
+        return this._circle.getMinMaxProjection(unitvector);
+    }
+    getCollisionAxes(relativeBody) {
+        return this._circle.getCollisionAxes(relativeBody);
+    }
+    applyForce(force) {
+        this._circle.applyForce(force);
+    }
+    get AABB() {
+        return this._circle.AABB;
+    }
+    getMass() {
+        return this._circle.mass;
+    }
+    applyForceInOrientation(force) {
+        this._circle.applyForceInOrientation(force);
+    }
+    move(delta) {
+        this._circle.move(delta);
+    }
+    getSignificantVertices(collisionNormal) {
+        return this._circle.getSignificantVertices(collisionNormal);
+    }
+    get center() {
+        return this._circle.center;
+    }
+    set center(dest) {
+        this._circle.center = dest;
+    }
+    get linearVelocity() {
+        return this._circle.linearVelocity;
+    }
+    set linearVelocity(dest) {
+        this._circle.linearVelocity = dest;
+    }
+    get orientationAngle() {
+        return this._circle.orientationAngle;
+    }
+    significantVertex(collisionNormal) {
+        return this._circle.significantVertex(collisionNormal);
+    }
+    set angularVelocity(angularVelocity) {
+        this._circle.angularVelocity = angularVelocity;
+    }
+    get angularVelocity() {
+        return this._circle.angularVelocity;
+    }
+    get mass() {
+        return this._circle.mass;
+    }
+    getNormalOfSignificantFace(collisionNormal) {
+        return this._circle.getNormalOfSignificantFace(collisionNormal);
+    }
+    get staticFrictionCoeff() {
+        return this._circle.staticFrictionCoeff;
+    }
+    set staticFrictionCoeff(coeff) {
+        this._circle.staticFrictionCoeff = coeff;
+    }
+    getAdjacentFaces(collisionNormal) {
+        return this._circle.getAdjacentFaces(collisionNormal);
+    }
+    get momentOfInertia() {
+        return this._circle.momentOfInertia;
+    }
+}
+class VisualPolygonBody {
+    constructor(center = { x: 0, y: 0 }, vertices, drawingContext, _orientationAngle = 0, mass = 50, isStatic = false, frictionEnabled = true) {
+        this._polygon = new Polygon(center, vertices, _orientationAngle, mass, isStatic, frictionEnabled);
+        this._context = drawingContext;
+    }
+    draw(ctx) {
+        ctx.beginPath();
+        let vertices = this._polygon.getVerticesAbsCoord();
+        ctx.moveTo(vertices[0].x, vertices[0].y);
+        vertices.forEach(vertex => {
+            ctx.lineTo(vertex.x, vertex.y);
+        });
+        ctx.lineTo(vertices[0].x, vertices[0].y);
+        ctx.stroke();
+        // ctx.beginPath();
+        // ctx.rect(this._polygon.AABB.min.x, this._polygon.AABB.min.y, this._polygon.AABB.max.x - this._polygon.AABB.min.x, this._polygon.AABB.max.y - this._polygon.AABB.min.y);
+        // ctx.stroke();
+    }
+    step(deltaTime) {
+        this._polygon.step(deltaTime);
+        this.draw(this._context);
+    }
+    isStatic() {
+        return this._polygon.isStatic();
+    }
+    isMovingStatic() {
+        return this._polygon.isMovingStatic();
+    }
+    getMinMaxProjection(unitvector) {
+        return this._polygon.getMinMaxProjection(unitvector);
+    }
+    getCollisionAxes(relativeBody) {
+        return this._polygon.getCollisionAxes(relativeBody);
+    }
+    applyForce(force) {
+        this._polygon.applyForce(force);
+    }
+    applyForceInOrientation(force) {
+        this._polygon.applyForceInOrientation(force);
+    }
+    setLinearVelocity(linearVelocity) {
+        this._polygon.setLinearVelocity(linearVelocity);
+    }
+    move(delta) {
+        this._polygon.move(delta);
+    }
+    get center() {
+        return this._polygon.center;
+    }
+    set center(dest) {
+        this._polygon.center = dest;
+    }
+    get linearVelocity() {
+        return this._polygon.linearVelocity;
+    }
+    set linearVelocity(dest) {
+        this._polygon.linearVelocity = dest;
+    }
+    get angularVelocity() {
+        return this._polygon.angularVelocity;
+    }
+    set angularVelocity(angularVelocity) {
+        this._polygon.angularVelocity = angularVelocity;
+    }
+    get orientationAngle() {
+        return this._polygon.orientationAngle;
+    }
+    significantVertex(collisionNormal) {
+        return this._polygon.significantVertex(collisionNormal);
+    }
+    getSignificantVertices(collisionNormal) {
+        return this._polygon.getSignificantVertices(collisionNormal);
+    }
+    get AABB() {
+        return this._polygon.AABB;
+    }
+    get mass() {
+        return this._polygon.mass;
+    }
+    get staticFrictionCoeff() {
+        return this._polygon.staticFrictionCoeff;
+    }
+    set staticFrictionCoeff(coeff) {
+        this._polygon.staticFrictionCoeff = coeff;
+    }
+    get momentOfInertia() {
+        return this._polygon.momentOfInertia;
+    }
+    getNormalOfSignificantFace(collisionNormal) {
+        return this._polygon.getNormalOfSignificantFace(collisionNormal);
+    }
+    getAdjacentFaces(collisionNormal) {
+        return this._polygon.getAdjacentFaces(collisionNormal);
+    }
+}
+class Polygon extends BaseRigidBody {
+    constructor(center = { x: 0, y: 0 }, vertices, _orientationAngle = 0, mass = 50, isStatic = false, frictionEnabled = true) {
+        super(center, _orientationAngle, mass, isStatic, frictionEnabled);
+        this.vertices = vertices;
+        this.step = this.step.bind(this);
+        let numerator = this.vertices.reduce((acc, vertex, index) => {
+            let nextPointIndex = index < this.vertices.length - 1 ? index + 1 : 0;
+            let nextPoint = this.vertices[nextPointIndex];
+            let crossProduct = PointCal.crossProduct(nextPoint, vertex);
+            return acc + PointCal.magnitude(crossProduct) * (PointCal.dotProduct(vertex, vertex) + PointCal.dotProduct(vertex, nextPoint) + PointCal.dotProduct(nextPoint, nextPoint));
+        }, 0);
+        let denomiator = this.vertices.reduce((acc, vertex, index) => {
+            return acc + PointCal.magnitude(PointCal.crossProduct(this.vertices[index < this.vertices.length - 1 ? index + 1 : 0], vertex));
+        }, 0);
+        this._momentOfInertia = this._mass * numerator / (6 * denomiator);
+    }
+    getVerticesAbsCoord() {
+        return this.vertices.map(vertex => {
+            return PointCal.addVector(this._center, PointCal.rotatePoint(vertex, this._orientationAngle));
+        });
+    }
+    getCollisionAxes(relativeBody) {
+        return this.getVerticesAbsCoord().map((vertex, index, absVertices) => {
+            let vector = PointCal.subVector(vertex, absVertices[absVertices.length - 1]);
+            if (index > 0) {
+                vector = PointCal.subVector(vertex, absVertices[index - 1]);
+            }
+            return PointCal.unitVector(PointCal.rotatePoint(vector, Math.PI / 2));
+        });
+    }
+    getMinMaxProjection(unitvector) {
+        let vertices = this.getVerticesAbsCoord();
+        let projections = vertices.map(vertex => {
+            return PointCal.dotProduct(vertex, unitvector);
+        });
+        return { min: Math.min(...projections), max: Math.max(...projections) };
+    }
+    get AABB() {
+        let points = this.getVerticesAbsCoord();
+        let xCoords = points.map(vertex => vertex.x);
+        let yCoords = points.map(vertex => vertex.y);
+        return { min: { x: Math.min(...xCoords), y: Math.min(...yCoords) }, max: { x: Math.max(...xCoords), y: Math.max(...yCoords) } };
+    }
+    significantVertex(collisionNormal) {
+        let vertices = this.getVerticesAbsCoord();
+        let verticesProjected = vertices.map(vertex => PointCal.dotProduct(vertex, collisionNormal));
+        let maxIndex = verticesProjected.indexOf(Math.max(...verticesProjected));
+        return vertices[maxIndex];
+    }
+    getSignificantVertices(collisionNormal) {
+        let vertices = this.getVerticesAbsCoord();
+        let verticesProjected = vertices.map(vertex => PointCal.dotProduct(vertex, collisionNormal));
+        let maxIndex = verticesProjected.indexOf(Math.max(...verticesProjected));
+        const tipVertex = vertices[maxIndex];
+        let prevPointIndex = maxIndex > 0 ? maxIndex - 1 : vertices.length - 1;
+        let nextPointIndex = maxIndex < vertices.length - 1 ? maxIndex + 1 : 0;
+        const prevPoint = vertices[prevPointIndex];
+        const nextPoint = vertices[nextPointIndex];
+        const prevPointProjected = PointCal.dotProduct(prevPoint, collisionNormal);
+        const nextPointProjected = PointCal.dotProduct(nextPoint, collisionNormal);
+        if (prevPointProjected > nextPointProjected) {
+            return [prevPoint, tipVertex];
+        }
+        else {
+            return [tipVertex, nextPoint];
+        }
+    }
+    getNormalOfSignificantFace(collisionNormal) {
+        const vertices = this.getSignificantVertices(collisionNormal);
+        const direction = PointCal.unitVectorFromA2B(vertices[0], vertices[1]);
+        return PointCal.rotatePoint(direction, -Math.PI / 2);
+    }
+    getAdjacentFaces(collisionNormal) {
+        let vertices = this.getVerticesAbsCoord();
+        let verticesProjected = vertices.map(vertex => PointCal.dotProduct(vertex, collisionNormal));
+        let maxIndex = verticesProjected.indexOf(Math.max(...verticesProjected));
+        const tipVertex = vertices[maxIndex];
+        let prevPointIndex = maxIndex > 0 ? maxIndex - 1 : vertices.length - 1;
+        let nextPointIndex = maxIndex < vertices.length - 1 ? maxIndex + 1 : 0;
+        const prevPoint = vertices[prevPointIndex];
+        const nextPoint = vertices[nextPointIndex];
+        const prevPointProjected = PointCal.dotProduct(prevPoint, collisionNormal);
+        const nextPointProjected = PointCal.dotProduct(nextPoint, collisionNormal);
+        const adjacentFacesWithIndex = [];
+        if (prevPointProjected > nextPointProjected) {
+            adjacentFacesWithIndex.push({ startPoint: { coord: prevPoint, index: prevPointIndex }, endPoint: { coord: tipVertex, index: maxIndex } });
+            // the nextface is the next face
+            adjacentFacesWithIndex.unshift({ startPoint: { coord: tipVertex, index: maxIndex }, endPoint: { coord: nextPoint, index: nextPointIndex } });
+            // need to get the previous face of the previous face
+            let prevPrevPointIndex = prevPointIndex > 0 ? prevPointIndex - 1 : vertices.length - 1;
+            adjacentFacesWithIndex.unshift({ startPoint: { coord: vertices[prevPrevPointIndex], index: prevPrevPointIndex }, endPoint: { coord: prevPoint, index: prevPointIndex } });
+        }
+        else {
+            adjacentFacesWithIndex.push({ startPoint: { coord: tipVertex, index: maxIndex }, endPoint: { coord: nextPoint, index: nextPointIndex } });
+            // need to get the next face of the next face
+            let nextNextPointIndex = nextPointIndex < vertices.length - 1 ? nextPointIndex + 1 : 0;
+            adjacentFacesWithIndex.unshift({ startPoint: { coord: nextPoint, index: nextPointIndex }, endPoint: { coord: vertices[nextNextPointIndex], index: nextNextPointIndex } });
+            // the prevoius face is the previous face
+            adjacentFacesWithIndex.unshift({ startPoint: { coord: prevPoint, index: prevPointIndex }, endPoint: { coord: tipVertex, index: maxIndex } });
+        }
+        return adjacentFacesWithIndex;
+    }
+    get momentOfInertia() {
+        return this._momentOfInertia;
+    }
+}
+class Circle extends BaseRigidBody {
+    constructor(center = { x: 0, y: 0 }, radius, _orientationAngle = 0, mass = 50, isStatic = false, frictionEnabled = true) {
+        super(center, _orientationAngle, mass, isStatic, frictionEnabled);
+        this._radius = radius;
+        this.step = this.step.bind(this);
+        this._momentOfInertia = this._mass * this._radius * this._radius / 2;
+    }
+    getMinMaxProjection(unitvector) {
+        let PositiveFurthest = PointCal.addVector(this._center, PointCal.multiplyVectorByScalar(unitvector, this._radius));
+        let NegativeFurthest = PointCal.addVector(this._center, PointCal.multiplyVectorByScalar(unitvector, -this._radius));
+        return { min: PointCal.dotProduct(NegativeFurthest, unitvector), max: PointCal.dotProduct(PositiveFurthest, unitvector) };
+    }
+    getCollisionAxes(relativeBody) {
+        return [PointCal.unitVector(PointCal.subVector(relativeBody.center, this._center))];
+    }
+    get AABB() {
+        return { min: PointCal.subVector(this._center, { x: this._radius, y: this._radius }), max: PointCal.addVector(this._center, { x: this._radius, y: this._radius }) };
+    }
+    significantVertex(collisionNormal) {
+        return PointCal.addVector(this._center, PointCal.multiplyVectorByScalar(collisionNormal, this._radius));
+    }
+    get radius() {
+        return this._radius;
+    }
+    getSignificantVertices(collisionNormal) {
+        return [PointCal.addVector(this._center, PointCal.multiplyVectorByScalar(collisionNormal, this._radius))];
+    }
+    getNormalOfSignificantFace(collisionNormal) {
+        return PointCal.unitVector(collisionNormal);
+    }
+    getAdjacentFaces(collisionNormal) {
+        return [];
+    }
+    get momentOfInertia() {
+        return this._momentOfInertia;
+    }
+}
+
+class RectangleBound {
+    constructor(bottomLeft, width, height) {
+        this.bottomLeft = bottomLeft;
+        this.width = width;
+        this.height = height;
+    }
+    getWidth() {
+        return this.width;
+    }
+    getHeight() {
+        return this.height;
+    }
+    getbottomLeft() {
+        return this.bottomLeft;
+    }
+}
+class QuadTree {
+    constructor(level, bounds) {
+        this.MAX_OBJECTS = 10; // per node
+        this.MAX_LEVELS = 5;
+        this.objects = [];
+        this.nodes = [];
+        this.level = level;
+        this.objects = [];
+        this.bounds = bounds;
+        this.nodes = [undefined, undefined, undefined, undefined];
+    }
+    draw(context) {
+        context.beginPath();
+        context.rect(this.bounds.getbottomLeft().x, this.bounds.getbottomLeft().y, this.bounds.getWidth(), this.bounds.getHeight());
+        context.stroke();
+        // console.log("objects: ", this.objects.length, "level: ", this.level);
+        for (let index = 0; index < this.nodes.length; index++) {
+            let node = this.nodes[index];
+            if (node != undefined) {
+                node.draw(context);
+            }
+        }
+    }
+    clear() {
+        this.objects = [];
+        for (let index = 0; index < this.nodes.length; index++) {
+            let node = this.nodes[index];
+            if (node != undefined) {
+                node.clear();
+                node = undefined;
+            }
+        }
+    }
+    split() {
+        // console.log("split");
+        let subWidth = this.bounds.getWidth() / 2;
+        let subHeight = this.bounds.getHeight() / 2;
+        let bottomLeft = this.bounds.getbottomLeft();
+        // bottom left is the first node and it goes clock wise 
+        this.nodes[0] = new QuadTree(this.level + 1, new RectangleBound({ x: bottomLeft.x, y: bottomLeft.y }, subWidth, subHeight));
+        this.nodes[1] = new QuadTree(this.level + 1, new RectangleBound({ x: bottomLeft.x, y: bottomLeft.y + subHeight }, subWidth, subHeight));
+        this.nodes[2] = new QuadTree(this.level + 1, new RectangleBound({ x: bottomLeft.x + subWidth, y: bottomLeft.y + subHeight }, subWidth, subHeight));
+        this.nodes[3] = new QuadTree(this.level + 1, new RectangleBound({ x: bottomLeft.x + subWidth, y: bottomLeft.y }, subWidth, subHeight));
+    }
+    getIndex(vBody) {
+        let midPoint = { x: this.bounds.getbottomLeft().x + this.bounds.getWidth() / 2, y: this.bounds.getbottomLeft().y + this.bounds.getHeight() / 2 };
+        let points = vBody.AABB;
+        let bottom = points.max.y < midPoint.y && points.min.y > this.bounds.getbottomLeft().y;
+        let left = points.max.x < midPoint.x && points.min.x > this.bounds.getbottomLeft().x;
+        let right = points.max.x > midPoint.x && points.min.x > midPoint.x;
+        let top = points.max.y > midPoint.y && points.min.y > midPoint.y;
+        // console.log("level", this.level);
+        if (bottom && left) {
+            return 0;
+        }
+        else if (bottom && right) {
+            return 3;
+        }
+        else if (top && left) {
+            return 1;
+        }
+        else if (top && right) {
+            return 2;
+        }
+        return -1;
+    }
+    insert(vBody) {
+        let node = this.nodes[0];
+        if (node != undefined) {
+            let index = this.getIndex(vBody);
+            if (index !== -1) {
+                node = this.nodes[index];
+                node?.insert(vBody);
+                return;
+            }
+        }
+        this.objects.push(vBody);
+        if (this.objects.length > this.MAX_OBJECTS && this.level < this.MAX_LEVELS) {
+            if (this.nodes[0] == null || this.nodes[0] == undefined) {
+                this.split();
+            }
+            let i = 0;
+            while (i < this.objects.length) {
+                let index = this.getIndex(this.objects[i]);
+                let node = this.nodes[index];
+                if (index != -1 && node !== undefined) {
+                    let vBody = this.objects[i];
+                    this.objects.splice(i, 1);
+                    node.insert(vBody);
+                }
+                else {
+                    i++;
+                }
+            }
+        }
+    }
+    retrieve(vBody) {
+        let index = this.getIndex(vBody);
+        let res = [];
+        let node = this.nodes[index];
+        if (index !== -1 && node !== undefined) {
+            res.push(...node.retrieve(vBody));
+        }
+        res.push(...this.objects);
+        return res;
+    }
+}
+
+function resolveCollision(bodyA, bodyB, normal) {
+    // console.log("resolve");
+    if (bodyA.isStatic() && bodyB.isStatic()) {
+        return;
+    }
+    let inverseMassA = bodyA.isStatic() || bodyA.isMovingStatic() ? 0 : 1 / bodyA.mass;
+    let inverseMassB = bodyB.isStatic() || bodyB.isMovingStatic() ? 0 : 1 / bodyB.mass;
+    // console.log("inverse mass a", inverseMassA);
+    // console.log("inverse mass b", inverseMassB);
+    let relativeVelocity = PointCal.subVector(bodyA.linearVelocity, bodyB.linearVelocity);
+    // console.log("relative velocity: ", relativeVelocity);
+    // console.log("linear velocity of a", bodyA.getLinearVelocity());
+    // console.log("linear veolcity of b", bodyB.getLinearVelocity());
+    let J = -1.4 * PointCal.dotProduct(relativeVelocity, normal);
+    J /= inverseMassA + inverseMassB;
+    let deltaVelocityA = PointCal.multiplyVectorByScalar(normal, J * inverseMassA);
+    let deltaVelocityB = PointCal.multiplyVectorByScalar(normal, J * inverseMassB);
+    // console.log("delta velocity A:", deltaVelocityA);
+    // console.log("delta velocity B:", deltaVelocityB);
+    bodyA.linearVelocity = PointCal.addVector(bodyA.linearVelocity, deltaVelocityA);
+    bodyB.linearVelocity = PointCal.subVector(bodyB.linearVelocity, deltaVelocityB);
+}
+function resolveCollisionWithRotation(bodyA, bodyB, contactManifold) {
+    // console.log("resolve");
+    if (bodyA.isStatic() && bodyB.isStatic()) {
+        return;
+    }
+    let inverseMassA = bodyA.isStatic() || bodyA.isMovingStatic() ? 0 : 1 / bodyA.mass;
+    let inverseMassB = bodyB.isStatic() || bodyB.isMovingStatic() ? 0 : 1 / bodyB.mass;
+    let inverseMMOIA = bodyA.isStatic() || bodyA.isMovingStatic() ? 0 : 1 / bodyA.momentOfInertia;
+    let inverseMMOIB = bodyB.isStatic() || bodyB.isMovingStatic() ? 0 : 1 / bodyB.momentOfInertia;
+    const Js = [];
+    for (let index = 0; index < contactManifold.contactPoints.length; index++) {
+        const contactPoint = contactManifold.contactPoints[index];
+        const rA = PointCal.subVector(contactPoint, bodyA.center);
+        const rB = PointCal.subVector(contactPoint, bodyB.center);
+        const rAPerpendicular = { x: -rA.y, y: rA.x };
+        const rBPerpendicular = { x: -rB.y, y: rB.x };
+        const angularVelocityA = PointCal.multiplyVectorByScalar(rAPerpendicular, bodyA.angularVelocity);
+        const angularVelocityB = PointCal.multiplyVectorByScalar(rBPerpendicular, bodyB.angularVelocity);
+        // console.log("inverse mass a", inverseMassA);
+        // console.log("inverse mass b", inverseMassB);
+        let relativeVelocity = PointCal.subVector(PointCal.addVector(bodyA.linearVelocity, angularVelocityA), PointCal.addVector(bodyB.linearVelocity, angularVelocityB));
+        // console.log("relative velocity: ", relativeVelocity);
+        // console.log("linear velocity of a", bodyA.getLinearVelocity());
+        // console.log("linear veolcity of b", bodyB.getLinearVelocity());
+        let relativeVelocityNormal = PointCal.dotProduct(relativeVelocity, contactManifold.normal);
+        const rAPerpendicularNormal = PointCal.dotProduct(rAPerpendicular, contactManifold.normal);
+        const rBPerpendicularNormal = PointCal.dotProduct(rBPerpendicular, contactManifold.normal);
+        const denominator = inverseMassA + inverseMassB + rAPerpendicularNormal * rAPerpendicularNormal * inverseMMOIA + rBPerpendicularNormal * rBPerpendicularNormal * inverseMMOIB;
+        let J = -1.4 * relativeVelocityNormal;
+        J /= denominator;
+        J /= contactManifold.contactPoints.length;
+        Js.push(PointCal.multiplyVectorByScalar(contactManifold.normal, J));
+    }
+    Js.forEach((impulse, index) => {
+        let deltaVelocityA = PointCal.multiplyVectorByScalar(impulse, inverseMassA);
+        let deltaVelocityB = PointCal.multiplyVectorByScalar(impulse, inverseMassB);
+        bodyA.linearVelocity = PointCal.addVector(bodyA.linearVelocity, deltaVelocityA);
+        let resA = PointCal.crossProduct(PointCal.subVector(contactManifold.contactPoints[index], bodyA.center), impulse).z;
+        resA = resA == undefined ? 0 : resA;
+        let resB = PointCal.crossProduct(PointCal.subVector(contactManifold.contactPoints[index], bodyB.center), impulse).z;
+        resB = resB == undefined ? 0 : resB;
+        bodyA.angularVelocity += resA * inverseMMOIA;
+        bodyB.angularVelocity -= resB * inverseMMOIB;
+        bodyB.linearVelocity = PointCal.subVector(bodyB.linearVelocity, deltaVelocityB);
+    });
+}
+function aabbIntersects(aabbA, aabbB) {
+    if ((aabbA.min.x <= aabbB.max.x && aabbB.min.x <= aabbA.max.x) && (aabbA.min.y <= aabbB.max.y && aabbB.min.y <= aabbA.max.y)) {
+        return true;
+    }
+    return false;
+}
+function intersects(bodyA, bodyB) {
+    let axis = [];
+    let bodyAAxes = bodyA.getCollisionAxes(bodyB);
+    let bodyBAxes = bodyB.getCollisionAxes(bodyA);
+    axis.push(...bodyAAxes);
+    axis.push(...bodyBAxes);
+    let collision = true;
+    let minDepth = Number.MAX_VALUE;
+    let minAxis = axis[0];
+    axis.forEach(projAxis => {
+        let bodyAInterval = bodyA.getMinMaxProjection(projAxis);
+        let bodyBInterval = bodyB.getMinMaxProjection(projAxis);
+        if (bodyAInterval.min >= bodyBInterval.max || bodyBInterval.min >= bodyAInterval.max) {
+            collision = false;
+        }
+        else {
+            let depth = Math.abs(Math.min(bodyAInterval.max, bodyBInterval.max) - Math.max(bodyBInterval.min, bodyAInterval.min));
+            if (depth < minDepth) {
+                minDepth = depth;
+                minAxis = projAxis;
+                if (bodyAInterval.max < bodyBInterval.max) {
+                    minAxis = PointCal.multiplyVectorByScalar(minAxis, -1);
+                }
+            }
+        }
+    });
+    if (collision) {
+        return { collision: collision, depth: minDepth, normal: minAxis };
+    }
+    else {
+        return { collision: false, depth: undefined, normal: undefined };
+    }
+}
+function narrowPhaseWithRigidBody(bodies, combinationsToCheck, resolveCollisionFlag) {
+    if (!resolveCollisionFlag) {
+        return [];
+    }
+    const contactPoints = [];
+    combinationsToCheck.forEach(combination => {
+        let bodyA = combination.bodyA;
+        let bodyB = combination.bodyB;
+        if (bodyA == bodyB) {
+            // console.log("same body");
+            return;
+        }
+        let bodyAZ = bodyA.center.z == undefined ? 0 : bodyA.center.z;
+        let bodyBZ = bodyB.center.z == undefined ? 0 : bodyB.center.z;
+        if (Math.abs(bodyAZ - bodyBZ) > 0.5) {
+            // console.log("z-index difference is too large");
+            return;
+        }
+        let { collision, depth, normal: normalAxis } = intersects(bodyA, bodyB);
+        if (collision && normalAxis !== undefined && depth !== undefined) {
+            // the normal axis points in the direction that push bodyA away from bodyB
+            let moveDisplacement = PointCal.multiplyVectorByScalar(normalAxis, depth / 2);
+            let revMoveDisplacement = PointCal.multiplyVectorByScalar(normalAxis, -depth / 2);
+            if (!bodyA.isStatic()) {
+                bodyA.move(moveDisplacement);
+            }
+            if (!bodyB.isStatic()) {
+                bodyB.move(revMoveDisplacement);
+            }
+            if (bodyA.isStatic()) {
+                // bodyA.move(revMoveDisplacement);
+                bodyB.move(revMoveDisplacement);
+            }
+            if (bodyB.isStatic()) {
+                bodyA.move(moveDisplacement);
+                // bodyB.move(moveDisplacement);
+            }
+            // finding the collision contact point(s)
+            const bodyASigNormal = bodyA.getNormalOfSignificantFace(PointCal.multiplyVectorByScalar(normalAxis, -1));
+            const bodyBSigNormal = bodyB.getNormalOfSignificantFace(normalAxis);
+            const bodyASigVertices = bodyA.getSignificantVertices(PointCal.multiplyVectorByScalar(normalAxis, -1));
+            const bodyBSigVertices = bodyB.getSignificantVertices(normalAxis);
+            const bodyAParallelIndicator = Math.abs(PointCal.dotProduct(bodyASigNormal, PointCal.multiplyVectorByScalar(normalAxis, -1)));
+            const bodyBParallelIndicator = Math.abs(PointCal.dotProduct(bodyBSigNormal, normalAxis));
+            if (bodyBSigVertices.length == 1 || bodyASigVertices.length == 1) {
+                // one of the body is a circle
+                // console.log("involving a circle");
+                if (bodyBSigVertices.length == 1) {
+                    // bodyB is a circle
+                    // contact point is on the perimeter of the circle and the direction is the collision normal
+                    contactPoints.push(bodyBSigVertices[0]);
+                }
+                else {
+                    // bodyA is a circle
+                    // contact point is on the perimeter of the circle and the direction is the collision normal
+                    contactPoints.push(bodyASigVertices[0]);
+                }
+            }
+            else if (bodyAParallelIndicator > bodyBParallelIndicator) {
+                // bodyA has the normal that is the most parallel to the collision normal
+                const adjacentFaces = bodyA.getAdjacentFaces(PointCal.multiplyVectorByScalar(normalAxis, -1));
+                let faceToClip = [...bodyBSigVertices];
+                for (let index = 0; index < adjacentFaces.length - 1; index++) {
+                    let startPoint = adjacentFaces[index].startPoint.coord;
+                    let endPoint = adjacentFaces[index].endPoint.coord;
+                    let direction = PointCal.subVector(endPoint, startPoint);
+                    let sigStart = PointCal.subVector(faceToClip[0], startPoint);
+                    let sigEnd = PointCal.subVector(faceToClip[1], startPoint);
+                    let startInside = PointCal.angleFromA2B(direction, sigStart) >= 0;
+                    let endInside = PointCal.angleFromA2B(direction, sigEnd) >= 0;
+                    if ((startInside ? 1 : 0) ^ (endInside ? 1 : 0)) {
+                        // one of the point is outside the face
+                        let intersectionPoint = PointCal.getLineIntersection(startPoint, endPoint, faceToClip[0], faceToClip[1]);
+                        if (intersectionPoint.intersects && intersectionPoint.intersection !== undefined) {
+                            if (startInside) {
+                                faceToClip[1] = intersectionPoint.intersection;
+                            }
+                            else {
+                                faceToClip[0] = intersectionPoint.intersection;
+                            }
+                        }
+                    }
+                }
+                const referenceFace = adjacentFaces[adjacentFaces.length - 1];
+                let startPoint = referenceFace.startPoint.coord;
+                let endPoint = referenceFace.endPoint.coord;
+                let direction = PointCal.subVector(endPoint, startPoint);
+                let sigStart = PointCal.subVector(faceToClip[0], startPoint);
+                let sigEnd = PointCal.subVector(faceToClip[1], startPoint);
+                let startInside = PointCal.angleFromA2B(direction, sigStart) >= 0;
+                let endInside = PointCal.angleFromA2B(direction, sigEnd) >= 0;
+                if (startInside) {
+                    contactPoints.push(faceToClip[0]);
+                }
+                if (endInside) {
+                    contactPoints.push(faceToClip[1]);
+                }
+            }
+            else {
+                // bodyB has the normal that is the most parallel to the collision normal
+                const adjacentFaces = bodyB.getAdjacentFaces(normalAxis);
+                let faceToClip = [...bodyASigVertices];
+                if (faceToClip.length == 0) {
+                    console.log("warning");
+                }
+                for (let index = 0; index < adjacentFaces.length - 1; index++) {
+                    let startPoint = adjacentFaces[index].startPoint.coord;
+                    let endPoint = adjacentFaces[index].endPoint.coord;
+                    let direction = PointCal.subVector(endPoint, startPoint);
+                    let sigStart = PointCal.subVector(faceToClip[0], startPoint);
+                    let sigEnd = PointCal.subVector(faceToClip[1], startPoint);
+                    let startInside = PointCal.angleFromA2B(direction, sigStart) >= 0;
+                    let endInside = PointCal.angleFromA2B(direction, sigEnd) >= 0;
+                    if ((startInside ? 1 : 0) ^ (endInside ? 1 : 0)) {
+                        // one of the point is outside the face
+                        let intersectionPoint = PointCal.getLineIntersection(startPoint, endPoint, faceToClip[0], faceToClip[1]);
+                        if (intersectionPoint.intersects && intersectionPoint.intersection !== undefined) {
+                            if (startInside) {
+                                faceToClip[1] = intersectionPoint.intersection;
+                            }
+                            else {
+                                faceToClip[0] = intersectionPoint.intersection;
+                            }
+                        }
+                    }
+                }
+                const referenceFace = adjacentFaces[adjacentFaces.length - 1];
+                let startPoint = referenceFace.startPoint.coord;
+                let endPoint = referenceFace.endPoint.coord;
+                let direction = PointCal.subVector(endPoint, startPoint);
+                let sigStart = PointCal.subVector(faceToClip[0], startPoint);
+                let sigEnd = PointCal.subVector(faceToClip[1], startPoint);
+                let startInside = PointCal.angleFromA2B(direction, sigStart) >= 0;
+                let endInside = PointCal.angleFromA2B(direction, sigEnd) >= 0;
+                if (startInside) {
+                    contactPoints.push(faceToClip[0]);
+                }
+                if (endInside) {
+                    contactPoints.push(faceToClip[1]);
+                }
+            }
+            if (resolveCollisionFlag) {
+                resolveCollisionWithRotation(bodyA, bodyB, { normal: normalAxis, contactPoints: contactPoints });
+                // resolveCollision(bodyA, bodyB, normalAxis);
+            }
+        }
+    });
+    return contactPoints;
+}
+function narrowPhase(bodies, combinationsToCheck, resolveCollisionFlag) {
+    if (!resolveCollisionFlag) {
+        return;
+    }
+    combinationsToCheck.forEach(combination => {
+        let bodyA = bodies[combination.bodyAIndex];
+        let bodyB = bodies[combination.bodyBIndex];
+        let { collision, depth, normal: normalAxis } = intersects(bodyA, bodyB);
+        if (collision && normalAxis !== undefined && depth !== undefined) {
+            // console.log("collision");
+            let moveDisplacement = PointCal.multiplyVectorByScalar(normalAxis, depth / 2);
+            let revMoveDisplacement = PointCal.multiplyVectorByScalar(normalAxis, -depth / 2);
+            if (!bodyA.isStatic()) {
+                bodyA.move(moveDisplacement);
+            }
+            if (!bodyB.isStatic()) {
+                bodyB.move(revMoveDisplacement);
+            }
+            if (bodyA.isStatic()) {
+                // bodyA.move(revMoveDisplacement);
+                bodyB.move(revMoveDisplacement);
+            }
+            if (bodyB.isStatic()) {
+                bodyA.move(moveDisplacement);
+                // bodyB.move(moveDisplacement);
+            }
+            if (resolveCollisionFlag) {
+                resolveCollision(bodyA, bodyB, normalAxis);
+            }
+        }
+    });
+}
+function broadPhaseWithRigidBodyReturned(quadTree, bodies) {
+    let possibleCombi = [];
+    for (let index = 0; index <= bodies.length - 1; index++) {
+        let objsToCheck = quadTree.retrieve(bodies[index]);
+        for (let jindex = 0; jindex <= objsToCheck.length - 1; jindex++) {
+            let bodyA = bodies[index];
+            let bodyB = objsToCheck[jindex];
+            if (bodyA.isStatic() && bodyB.isStatic()) {
+                continue;
+            }
+            if (!aabbIntersects(bodyA.AABB, bodyB.AABB)) {
+                continue;
+            }
+            possibleCombi.push({ bodyA: bodyA, bodyB: bodyB });
+        }
+    }
+    return possibleCombi;
+}
+function broadPhase(quadTree, bodies) {
+    let possibleCombi = [];
+    for (let index = 0; index <= bodies.length - 1; index++) {
+        let objsToCheck = quadTree.retrieve(bodies[index]);
+        for (let jindex = 0; jindex <= objsToCheck.length - 1; jindex++) {
+            let bodyA = bodies[index];
+            let bodyB = objsToCheck[jindex];
+            if (bodyA.isStatic() && bodyB.isStatic()) {
+                continue;
+            }
+            if (!aabbIntersects(bodyA.AABB, bodyB.AABB)) {
+                continue;
+            }
+            possibleCombi.push({ bodyAIndex: index, bodyBIndex: jindex });
+        }
+    }
+    return possibleCombi;
+}
+
+export { BaseRigidBody, Circle, Polygon, QuadTree, RectangleBound, VisaulCircleBody, VisualPolygonBody, aabbIntersects, broadPhase, broadPhaseWithRigidBodyReturned, intersects, narrowPhase, narrowPhaseWithRigidBody, resolveCollision, resolveCollisionWithRotation };
+//# sourceMappingURL=index.js.map