excalibur 0.28.3 → 0.28.4

package/build/dist/Collision/Colliders/Shape.js

@@ -0,0 +1,99 @@
+import { PolygonCollider } from './PolygonCollider';
+import { CircleCollider } from './CircleCollider';
+import { EdgeCollider } from './EdgeCollider';
+import { BoundingBox } from '../BoundingBox';
+import { vec, Vector } from '../../Math/vector';
+import { CompositeCollider } from './CompositeCollider';
+import { Logger } from '../..';
+/**
+ * Excalibur helper for defining colliders quickly
+ */
+export class Shape {
+    /**
+     * Creates a box collider, under the hood defines a [[PolygonCollider]] collider
+     * @param width Width of the box
+     * @param height Height of the box
+     * @param anchor Anchor of the box (default (.5, .5)) which positions the box relative to the center of the collider's position
+     * @param offset Optional offset relative to the collider in local coordinates
+     */
+    static Box(width, height, anchor = Vector.Half, offset = Vector.Zero) {
+        return new PolygonCollider({
+            points: new BoundingBox(-width * anchor.x, -height * anchor.y, width - width * anchor.x, height - height * anchor.y).getPoints(),
+            offset: offset
+        });
+    }
+    /**
+     * Creates a new [[PolygonCollider|arbitrary polygon]] collider
+     *
+     * PolygonColliders are useful for creating convex polygon shapes
+     * @param points Points specified in counter clockwise
+     * @param offset Optional offset relative to the collider in local coordinates
+     */
+    static Polygon(points, offset = Vector.Zero) {
+        return new PolygonCollider({
+            points: points,
+            offset: offset
+        });
+    }
+    /**
+     * Creates a new [[CircleCollider|circle]] collider
+     *
+     * Circle colliders are useful for balls, or to make collisions more forgiving on sharp edges
+     * @param radius Radius of the circle collider
+     * @param offset Optional offset relative to the collider in local coordinates
+     */
+    static Circle(radius, offset = Vector.Zero) {
+        return new CircleCollider({
+            radius: radius,
+            offset: offset
+        });
+    }
+    /**
+     * Creates a new [[EdgeCollider|edge]] collider
+     *
+     * Edge colliders are useful for  floors, walls, and other barriers
+     * @param begin Beginning of the edge in local coordinates to the collider
+     * @param end Ending of the edge in local coordinates to the collider
+     */
+    static Edge(begin, end) {
+        return new EdgeCollider({
+            begin: begin,
+            end: end
+        });
+    }
+    /**
+     * Creates a new capsule shaped [[CompositeCollider]] using 2 circles and a box
+     *
+     * Capsule colliders are useful for platformers with incline or jagged floors to have a smooth
+     * player experience.
+     * @param width
+     * @param height
+     * @param offset Optional offset
+     */
+    static Capsule(width, height, offset = Vector.Zero) {
+        const logger = Logger.getInstance();
+        if (width === height) {
+            logger.warn('A capsule collider with equal width and height is a circle, consider using a ex.Shape.Circle or ex.CircleCollider');
+        }
+        const vertical = height >= width;
+        if (vertical) {
+            // height > width, if equal maybe use a circle
+            const capsule = new CompositeCollider([
+                Shape.Circle(width / 2, vec(0, -height / 2 + width / 2).add(offset)),
+                Shape.Box(width, height - width, Vector.Half, offset),
+                Shape.Circle(width / 2, vec(0, height / 2 - width / 2).add(offset))
+            ]);
+            return capsule;
+        }
+        else {
+            // width > height, if equal maybe use a circle
+            const capsule = new CompositeCollider([
+                Shape.Circle(height / 2, vec(-width / 2 + height / 2, 0).add(offset)),
+                Shape.Box(width - height, height, Vector.Half, offset),
+                Shape.Circle(height / 2, vec(width / 2 - height / 2, 0).add(offset))
+            ]);
+            return capsule;
+        }
+    }
+}
+//# sourceMappingURL=Shape.js.map

package/build/dist/Collision/Colliders/Shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Shape.js","sourceRoot":"","sources":["../../../../src/engine/Collision/Colliders/Shape.ts"],"names":[],"mappings":"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"}

package/build/dist/Collision/CollisionType.js

@@ -0,0 +1,33 @@
+/**
+ * An enum that describes the types of collisions bodies can participate in
+ */
+export var CollisionType;
+(function (CollisionType) {
+    /**
+     * Bodies with the `PreventCollision` setting do not participate in any
+     * collisions and do not raise collision events.
+     */
+    CollisionType["PreventCollision"] = "PreventCollision";
+    /**
+     * Bodies with the `Passive` setting only raise collision events, but are not
+     * influenced or moved by other bodies and do not influence or move other bodies.
+     * This is useful for use in trigger type behavior.
+     */
+    CollisionType["Passive"] = "Passive";
+    /**
+     * Bodies with the `Active` setting raise collision events and participate
+     * in collisions with other bodies and will be push or moved by bodies sharing
+     * the `Active` or `Fixed` setting.
+     */
+    CollisionType["Active"] = "Active";
+    /**
+     * Bodies with the `Fixed` setting raise collision events and participate in
+     * collisions with other bodies. Actors with the `Fixed` setting will not be
+     * pushed or moved by other bodies sharing the `Fixed`. Think of Fixed
+     * bodies as "immovable/unstoppable" objects. If two `Fixed` bodies meet they will
+     * not be pushed or moved by each other, they will not interact except to throw
+     * collision events.
+     */
+    CollisionType["Fixed"] = "Fixed";
+})(CollisionType || (CollisionType = {}));
+//# sourceMappingURL=CollisionType.js.map

package/build/dist/Collision/CollisionType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollisionType.js","sourceRoot":"","sources":["../../../src/engine/Collision/CollisionType.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAN,IAAY,aA2BX;AA3BD,WAAY,aAAa;IACvB;;;OAGG;IACH,sDAAqC,CAAA;IACrC;;;;OAIG;IACH,oCAAmB,CAAA;IACnB;;;;OAIG;IACH,kCAAiB,CAAA;IACjB;;;;;;;OAOG;IACH,gCAAe,CAAA;AACjB,CAAC,EA3BW,aAAa,KAAb,aAAa,QA2BxB"}

package/build/dist/Collision/Detection/CollisionContact.js

@@ -0,0 +1,51 @@
+import { Physics } from '../Physics';
+import { CollisionType } from '../CollisionType';
+import { Pair } from './Pair';
+import { BodyComponent } from '../BodyComponent';
+/**
+ * Collision contacts are used internally by Excalibur to resolve collision between colliders. This
+ * Pair prevents collisions from being evaluated more than one time
+ */
+export class CollisionContact {
+    constructor(colliderA, colliderB, mtv, normal, tangent, points, localPoints, info) {
+        var _a, _b;
+        this._canceled = false;
+        this.colliderA = colliderA;
+        this.colliderB = colliderB;
+        this.mtv = mtv;
+        this.normal = normal;
+        this.tangent = tangent;
+        this.points = points;
+        this.localPoints = localPoints;
+        this.info = info;
+        this.id = Pair.calculatePairHash(colliderA.id, colliderB.id);
+        if (colliderA.__compositeColliderId || colliderB.__compositeColliderId) {
+            // Add on the parent composite pair for start/end contact
+            this.id += '|' + Pair.calculatePairHash((_a = colliderA.__compositeColliderId) !== null && _a !== void 0 ? _a : colliderA.id, (_b = colliderB.__compositeColliderId) !== null && _b !== void 0 ? _b : colliderB.id);
+        }
+    }
+    /**
+     * Match contact awake state, except if body's are Fixed
+     */
+    matchAwake() {
+        const bodyA = this.colliderA.owner.get(BodyComponent);
+        const bodyB = this.colliderB.owner.get(BodyComponent);
+        if (bodyA && bodyB) {
+            if (bodyA.sleeping !== bodyB.sleeping) {
+                if (bodyA.sleeping && bodyA.collisionType !== CollisionType.Fixed && bodyB.sleepMotion >= Physics.wakeThreshold) {
+                    bodyA.setSleeping(false);
+                }
+                if (bodyB.sleeping && bodyB.collisionType !== CollisionType.Fixed && bodyA.sleepMotion >= Physics.wakeThreshold) {
+                    bodyB.setSleeping(false);
+                }
+            }
+        }
+    }
+    isCanceled() {
+        return this._canceled;
+    }
+    cancel() {
+        this._canceled = true;
+    }
+}
+//# sourceMappingURL=CollisionContact.js.map

package/build/dist/Collision/Detection/CollisionContact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollisionContact.js","sourceRoot":"","sources":["../../../../src/engine/Collision/Detection/CollisionContact.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;;GAGG;AACH,MAAM,OAAO,gBAAgB;IAgD3B,YACE,SAAmB,EACnB,SAAmB,EACnB,GAAW,EACX,MAAc,EACd,OAAe,EACf,MAAgB,EAChB,WAAqB,EACrB,IAAoB;;QAvDd,cAAS,GAAG,KAAK,CAAC;QAyDxB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;QAC7D,IAAI,SAAS,CAAC,qBAAqB,IAAI,SAAS,CAAC,qBAAqB,EAAE,CAAC;YACvE,yDAAyD;YACzD,IAAI,CAAC,EAAE,IAAI,GAAG,GAAG,IAAI,CAAC,iBAAiB,CACrC,MAAA,SAAS,CAAC,qBAAqB,mCAAI,SAAS,CAAC,EAAE,EAC/C,MAAA,SAAS,CAAC,qBAAqB,mCAAI,SAAS,CAAC,EAAE,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IAED;;OAEG;IACI,UAAU;QACf,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACtD,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACtD,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC;YACnB,IAAI,KAAK,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ,EAAE,CAAC;gBACtC,IAAI,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,aAAa,KAAK,aAAa,CAAC,KAAK,IAAI,KAAK,CAAC,WAAW,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;oBAChH,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;gBAC3B,CAAC;gBACD,IAAI,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,aAAa,KAAK,aAAa,CAAC,KAAK,IAAI,KAAK,CAAC,WAAW,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;oBAChH,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;gBAC3B,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAEM,UAAU;QACf,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAEM,MAAM;QACX,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IACxB,CAAC;CACF"}

package/build/dist/Collision/Detection/CollisionProcessor.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=CollisionProcessor.js.map

package/build/dist/Collision/Detection/CollisionProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollisionProcessor.js","sourceRoot":"","sources":["../../../../src/engine/Collision/Detection/CollisionProcessor.ts"],"names":[],"mappings":""}

package/build/dist/Collision/Detection/DynamicTree.js

@@ -0,0 +1,442 @@
+import { Physics } from '../Physics';
+import { BoundingBox } from '../BoundingBox';
+import { Logger } from '../../Util/Log';
+import { BodyComponent } from '../BodyComponent';
+import { Color } from '../..';
+/**
+ * Dynamic Tree Node used for tracking bounds within the tree
+ */
+export class TreeNode {
+    constructor(parent) {
+        this.parent = parent;
+        this.parent = parent || null;
+        this.data = null;
+        this.bounds = new BoundingBox();
+        this.left = null;
+        this.right = null;
+        this.height = 0;
+    }
+    isLeaf() {
+        return !this.left && !this.right;
+    }
+}
+/**
+ * The DynamicTrees provides a spatial partitioning data structure for quickly querying for overlapping bounding boxes for
+ * all tracked bodies. The worst case performance of this is O(n*log(n)) where n is the number of bodies in the tree.
+ *
+ * Internally the bounding boxes are organized as a balanced binary tree of bounding boxes, where the leaf nodes are tracked bodies.
+ * Every non-leaf node is a bounding box that contains child bounding boxes.
+ */
+export class DynamicTree {
+    constructor(worldBounds = new BoundingBox(-Number.MAX_VALUE, -Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE)) {
+        this.worldBounds = worldBounds;
+        this.root = null;
+        this.nodes = {};
+    }
+    /**
+     * Inserts a node into the dynamic tree
+     */
+    _insert(leaf) {
+        // If there are no nodes in the tree, make this the root leaf
+        if (this.root === null) {
+            this.root = leaf;
+            this.root.parent = null;
+            return;
+        }
+        // Search the tree for a node that is not a leaf and find the best place to insert
+        const leafAABB = leaf.bounds;
+        let currentRoot = this.root;
+        while (!currentRoot.isLeaf()) {
+            const left = currentRoot.left;
+            const right = currentRoot.right;
+            const area = currentRoot.bounds.getPerimeter();
+            const combinedAABB = currentRoot.bounds.combine(leafAABB);
+            const combinedArea = combinedAABB.getPerimeter();
+            // Calculate cost heuristic for creating a new parent and leaf
+            const cost = 2 * combinedArea;
+            // Minimum cost of pushing the leaf down the tree
+            const inheritanceCost = 2 * (combinedArea - area);
+            // Cost of descending
+            let leftCost = 0;
+            const leftCombined = leafAABB.combine(left.bounds);
+            let newArea;
+            let oldArea;
+            if (left.isLeaf()) {
+                leftCost = leftCombined.getPerimeter() + inheritanceCost;
+            }
+            else {
+                oldArea = left.bounds.getPerimeter();
+                newArea = leftCombined.getPerimeter();
+                leftCost = newArea - oldArea + inheritanceCost;
+            }
+            let rightCost = 0;
+            const rightCombined = leafAABB.combine(right.bounds);
+            if (right.isLeaf()) {
+                rightCost = rightCombined.getPerimeter() + inheritanceCost;
+            }
+            else {
+                oldArea = right.bounds.getPerimeter();
+                newArea = rightCombined.getPerimeter();
+                rightCost = newArea - oldArea + inheritanceCost;
+            }
+            // cost is acceptable
+            if (cost < leftCost && cost < rightCost) {
+                break;
+            }
+            // Descend to the depths
+            if (leftCost < rightCost) {
+                currentRoot = left;
+            }
+            else {
+                currentRoot = right;
+            }
+        }
+        // Create the new parent node and insert into the tree
+        const oldParent = currentRoot.parent;
+        const newParent = new TreeNode(oldParent);
+        newParent.bounds = leafAABB.combine(currentRoot.bounds);
+        newParent.height = currentRoot.height + 1;
+        if (oldParent !== null) {
+            // The sibling node was not the root
+            if (oldParent.left === currentRoot) {
+                oldParent.left = newParent;
+            }
+            else {
+                oldParent.right = newParent;
+            }
+            newParent.left = currentRoot;
+            newParent.right = leaf;
+            currentRoot.parent = newParent;
+            leaf.parent = newParent;
+        }
+        else {
+            // The sibling node was the root
+            newParent.left = currentRoot;
+            newParent.right = leaf;
+            currentRoot.parent = newParent;
+            leaf.parent = newParent;
+            this.root = newParent;
+        }
+        // Walk up the tree fixing heights and AABBs
+        let currentNode = leaf.parent;
+        while (currentNode) {
+            currentNode = this._balance(currentNode);
+            if (!currentNode.left) {
+                throw new Error('Parent of current leaf cannot have a null left child' + currentNode);
+            }
+            if (!currentNode.right) {
+                throw new Error('Parent of current leaf cannot have a null right child' + currentNode);
+            }
+            currentNode.height = 1 + Math.max(currentNode.left.height, currentNode.right.height);
+            currentNode.bounds = currentNode.left.bounds.combine(currentNode.right.bounds);
+            currentNode = currentNode.parent;
+        }
+    }
+    /**
+     * Removes a node from the dynamic tree
+     */
+    _remove(leaf) {
+        if (leaf === this.root) {
+            this.root = null;
+            return;
+        }
+        const parent = leaf.parent;
+        const grandParent = parent.parent;
+        let sibling;
+        if (parent.left === leaf) {
+            sibling = parent.right;
+        }
+        else {
+            sibling = parent.left;
+        }
+        if (grandParent) {
+            if (grandParent.left === parent) {
+                grandParent.left = sibling;
+            }
+            else {
+                grandParent.right = sibling;
+            }
+            sibling.parent = grandParent;
+            let currentNode = grandParent;
+            while (currentNode) {
+                currentNode = this._balance(currentNode);
+                currentNode.bounds = currentNode.left.bounds.combine(currentNode.right.bounds);
+                currentNode.height = 1 + Math.max(currentNode.left.height, currentNode.right.height);
+                currentNode = currentNode.parent;
+            }
+        }
+        else {
+            this.root = sibling;
+            sibling.parent = null;
+        }
+    }
+    /**
+     * Tracks a body in the dynamic tree
+     */
+    trackCollider(collider) {
+        const node = new TreeNode();
+        node.data = collider;
+        node.bounds = collider.bounds;
+        node.bounds.left -= 2;
+        node.bounds.top -= 2;
+        node.bounds.right += 2;
+        node.bounds.bottom += 2;
+        this.nodes[collider.id.value] = node;
+        this._insert(node);
+    }
+    /**
+     * Updates the dynamic tree given the current bounds of each body being tracked
+     */
+    updateCollider(collider) {
+        var _a;
+        const node = this.nodes[collider.id.value];
+        if (!node) {
+            return false;
+        }
+        const b = collider.bounds;
+        // if the body is outside the world no longer update it
+        if (!this.worldBounds.contains(b)) {
+            Logger.getInstance().warn('Collider with id ' + collider.id.value + ' is outside the world bounds and will no longer be tracked for physics');
+            this.untrackCollider(collider);
+            return false;
+        }
+        if (node.bounds.contains(b)) {
+            return false;
+        }
+        this._remove(node);
+        b.left -= Physics.boundsPadding;
+        b.top -= Physics.boundsPadding;
+        b.right += Physics.boundsPadding;
+        b.bottom += Physics.boundsPadding;
+        // THIS IS CAUSING UNECESSARY CHECKS
+        if (collider.owner) {
+            const body = (_a = collider.owner) === null || _a === void 0 ? void 0 : _a.get(BodyComponent);
+            if (body) {
+                const multdx = ((body.vel.x * 32) / 1000) * Physics.dynamicTreeVelocityMultiplier;
+                const multdy = ((body.vel.y * 32) / 1000) * Physics.dynamicTreeVelocityMultiplier;
+                if (multdx < 0) {
+                    b.left += multdx;
+                }
+                else {
+                    b.right += multdx;
+                }
+                if (multdy < 0) {
+                    b.top += multdy;
+                }
+                else {
+                    b.bottom += multdy;
+                }
+            }
+        }
+        node.bounds = b;
+        this._insert(node);
+        return true;
+    }
+    /**
+     * Untracks a body from the dynamic tree
+     */
+    untrackCollider(collider) {
+        const node = this.nodes[collider.id.value];
+        if (!node) {
+            return;
+        }
+        this._remove(node);
+        this.nodes[collider.id.value] = null;
+        delete this.nodes[collider.id.value];
+    }
+    /**
+     * Balances the tree about a node
+     */
+    _balance(node) {
+        if (node === null) {
+            throw new Error('Cannot balance at null node');
+        }
+        if (node.isLeaf() || node.height < 2) {
+            return node;
+        }
+        const left = node.left;
+        const right = node.right;
+        const a = node;
+        const b = left;
+        const c = right;
+        const d = left.left;
+        const e = left.right;
+        const f = right.left;
+        const g = right.right;
+        const balance = c.height - b.height;
+        // Rotate c node up
+        if (balance > 1) {
+            // Swap the right node with it's parent
+            c.left = a;
+            c.parent = a.parent;
+            a.parent = c;
+            // The original node's old parent should point to the right node
+            // this is mega confusing
+            if (c.parent) {
+                if (c.parent.left === a) {
+                    c.parent.left = c;
+                }
+                else {
+                    c.parent.right = c;
+                }
+            }
+            else {
+                this.root = c;
+            }
+            // Rotate
+            if (f.height > g.height) {
+                c.right = f;
+                a.right = g;
+                g.parent = a;
+                a.bounds = b.bounds.combine(g.bounds);
+                c.bounds = a.bounds.combine(f.bounds);
+                a.height = 1 + Math.max(b.height, g.height);
+                c.height = 1 + Math.max(a.height, f.height);
+            }
+            else {
+                c.right = g;
+                a.right = f;
+                f.parent = a;
+                a.bounds = b.bounds.combine(f.bounds);
+                c.bounds = a.bounds.combine(g.bounds);
+                a.height = 1 + Math.max(b.height, f.height);
+                c.height = 1 + Math.max(a.height, g.height);
+            }
+            return c;
+        }
+        // Rotate left node up
+        if (balance < -1) {
+            // swap
+            b.left = a;
+            b.parent = a.parent;
+            a.parent = b;
+            // node's old parent should point to b
+            if (b.parent) {
+                if (b.parent.left === a) {
+                    b.parent.left = b;
+                }
+                else {
+                    if (b.parent.right !== a) {
+                        throw 'Error rotating Dynamic Tree';
+                    }
+                    b.parent.right = b;
+                }
+            }
+            else {
+                this.root = b;
+            }
+            // rotate
+            if (d.height > e.height) {
+                b.right = d;
+                a.left = e;
+                e.parent = a;
+                a.bounds = c.bounds.combine(e.bounds);
+                b.bounds = a.bounds.combine(d.bounds);
+                a.height = 1 + Math.max(c.height, e.height);
+                b.height = 1 + Math.max(a.height, d.height);
+            }
+            else {
+                b.right = e;
+                a.left = d;
+                d.parent = a;
+                a.bounds = c.bounds.combine(d.bounds);
+                b.bounds = a.bounds.combine(e.bounds);
+                a.height = 1 + Math.max(c.height, d.height);
+                b.height = 1 + Math.max(a.height, e.height);
+            }
+            return b;
+        }
+        return node;
+    }
+    /**
+     * Returns the internal height of the tree, shorter trees are better. Performance drops as the tree grows
+     */
+    getHeight() {
+        if (this.root === null) {
+            return 0;
+        }
+        return this.root.height;
+    }
+    /**
+     * Queries the Dynamic Axis Aligned Tree for bodies that could be colliding with the provided body.
+     *
+     * In the query callback, it will be passed a potential collider. Returning true from this callback indicates
+     * that you are complete with your query and you do not want to continue. Returning false will continue searching
+     * the tree until all possible colliders have been returned.
+     */
+    query(collider, callback) {
+        const bounds = collider.bounds;
+        const helper = (currentNode) => {
+            if (currentNode && currentNode.bounds.overlaps(bounds)) {
+                if (currentNode.isLeaf() && currentNode.data !== collider) {
+                    if (callback.call(collider, currentNode.data)) {
+                        return true;
+                    }
+                }
+                else {
+                    return helper(currentNode.left) || helper(currentNode.right);
+                }
+            }
+            return false;
+        };
+        helper(this.root);
+    }
+    /**
+     * Queries the Dynamic Axis Aligned Tree for bodies that could be intersecting. By default the raycast query uses an infinitely
+     * long ray to test the tree specified by `max`.
+     *
+     * In the query callback, it will be passed a potential body that intersects with the raycast. Returning true from this
+     * callback indicates that your are complete with your query and do not want to continue. Return false will continue searching
+     * the tree until all possible bodies that would intersect with the ray have been returned.
+     */
+    rayCastQuery(ray, max = Infinity, callback) {
+        const helper = (currentNode) => {
+            if (currentNode && currentNode.bounds.rayCast(ray, max)) {
+                if (currentNode.isLeaf()) {
+                    if (callback.call(ray, currentNode.data)) {
+                        // ray hit a leaf! return the body
+                        return true;
+                    }
+                }
+                else {
+                    // ray hit but not at a leaf, recurse deeper
+                    return helper(currentNode.left) || helper(currentNode.right);
+                }
+            }
+            return false; // ray missed
+        };
+        helper(this.root);
+    }
+    getNodes() {
+        const helper = (currentNode) => {
+            if (currentNode) {
+                return [currentNode].concat(helper(currentNode.left), helper(currentNode.right));
+            }
+            else {
+                return [];
+            }
+        };
+        return helper(this.root);
+    }
+    debug(ex) {
+        // draw all the nodes in the Dynamic Tree
+        const helper = (currentNode) => {
+            if (currentNode) {
+                if (currentNode.isLeaf()) {
+                    currentNode.bounds.draw(ex, Color.Green);
+                }
+                else {
+                    currentNode.bounds.draw(ex, Color.White);
+                }
+                if (currentNode.left) {
+                    helper(currentNode.left);
+                }
+                if (currentNode.right) {
+                    helper(currentNode.right);
+                }
+            }
+        };
+        helper(this.root);
+    }
+}
+//# sourceMappingURL=DynamicTree.js.map