melonjs 14.0.1 → 14.1.0

package/dist/melonjs.mjs/physics/detector.js

@@ -0,0 +1,194 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import * as sat from './sat.js';
+import ResponseObject from './response.js';
+import Vector2d from '../math/vector2.js';
+import game from '../game.js';
+import Bounds from './bounds.js';
+
+// a dummy object when using Line for raycasting
+let dummyObj = {
+    pos : new Vector2d(0, 0),
+    ancestor : {
+        _absPos : new Vector2d(0, 0),
+        getAbsolutePosition : function () {
+            return this._absPos;
+        }
+    }
+};
+
+let boundsA = new Bounds();
+let boundsB = new Bounds();
+
+// the global response object used for collisions
+let globalResponse = new ResponseObject();
+
+/**
+ * a function used to determine if two objects should collide (based on both respective objects collision mask and type).<br>
+ * you can redefine this function if you need any specific rules over what should collide with what.
+ * @name shouldCollide
+ * @memberof collision
+ * @ignore
+ * @param {Renderable} a - a reference to the object A.
+ * @param {Renderable} b - a reference to the object B.
+ * @returns {boolean} true if they should collide, false otherwise
+ */
+function shouldCollide(a, b) {
+    var bodyA = a.body,
+        bodyB = b.body;
+    return (
+        a !== b &&
+        a.isKinematic !== true && b.isKinematic !== true &&
+        typeof bodyA === "object" && typeof bodyB === "object" &&
+        bodyA.shapes.length > 0 && bodyB.shapes.length > 0 &&
+        !(bodyA.isStatic === true && bodyB.isStatic === true) &&
+        (bodyA.collisionMask & bodyB.collisionType) !== 0 &&
+        (bodyA.collisionType & bodyB.collisionMask) !== 0
+    );
+}
+
+
+
+/**
+ * find all the collisions for the specified object
+ * @name collisionCheck
+ * @ignore
+ * @param {Renderable} objA - object to be tested for collision
+ * @param {ResponseObject} [response] - a user defined response object that will be populated if they intersect.
+ * @returns {boolean} in case of collision, false otherwise
+ */
+function collisionCheck(objA, response = globalResponse) {
+    var collisionCounter = 0;
+    // retreive a list of potential colliding objects from the game world
+    var candidates = game.world.broadphase.retrieve(objA);
+
+    boundsA.addBounds(objA.getBounds(), true);
+    boundsA.addBounds(objA.body.getBounds());
+
+    candidates.forEach((objB) => {
+        // check if both objects "should" collide
+        if (shouldCollide(objA, objB)) {
+
+            boundsB.addBounds(objB.getBounds(), true);
+            boundsB.addBounds(objB.body.getBounds());
+
+            // fast AABB check if both bounding boxes are overlaping
+            if (boundsA.overlaps(boundsB)) {
+                // for each shape in body A
+                objA.body.shapes.forEach((shapeA, indexA) => {
+                    // for each shape in body B
+                    objB.body.shapes.forEach((shapeB, indexB) => {
+                        // full SAT collision check
+                        if (sat["test" + shapeA.shapeType + shapeB.shapeType].call(
+                                this,
+                                objA, // a reference to the object A
+                                shapeA,
+                                objB,  // a reference to the object B
+                                shapeB,
+                                // clear response object before reusing
+                                response.clear()) === true
+                        ) {
+                            // we touched something !
+                            collisionCounter++;
+
+                            // set the shape index
+                            response.indexShapeA = indexA;
+                            response.indexShapeB = indexB;
+
+                            // execute the onCollision callback
+                            if (objA.onCollision && objA.onCollision(response, objB) !== false && objA.body.isStatic === false) {
+                                objA.body.respondToCollision.call(objA.body, response);
+                            }
+                            if (objB.onCollision && objB.onCollision(response, objA) !== false && objB.body.isStatic === false) {
+                                objB.body.respondToCollision.call(objB.body, response);
+                            }
+                        }
+                    });
+                });
+            }
+        }
+    });
+    // we could return the amount of objects we collided with ?
+    return collisionCounter > 0;
+}
+
+/**
+ * Checks for object colliding with the given line
+ * @name rayCast
+ * @ignore
+ * @param {Line} line - line to be tested for collision
+ * @param {Array.<Renderable>} [result] - a user defined array that will be populated with intersecting physic objects.
+ * @returns {Array.<Renderable>} an array of intersecting physic objects
+ * @example
+ *    // define a line accross the viewport
+ *    var ray = new me.Line(
+ *        // absolute position of the line
+ *        0, 0, [
+ *        // starting point relative to the initial position
+ *        new me.Vector2d(0, 0),
+ *        // ending point
+ *        new me.Vector2d(me.game.viewport.width, me.game.viewport.height)
+ *    ]);
+ *
+ *    // check for collition
+ *    result = me.collision.rayCast(ray);
+ *
+ *    if (result.length > 0) {
+ *        // ...
+ *    }
+ */
+function rayCast(line, result = []) {
+    var collisionCounter = 0;
+
+    // retrieve a list of potential colliding objects from the game world
+    var candidates = game.world.broadphase.retrieve(line);
+
+    for (var i = candidates.length, objB; i--, (objB = candidates[i]);) {
+
+        // fast AABB check if both bounding boxes are overlaping
+        if (objB.body && line.getBounds().overlaps(objB.getBounds())) {
+
+            // go trough all defined shapes in B (if any)
+            var bLen = objB.body.shapes.length;
+            if ( objB.body.shapes.length === 0) {
+                continue;
+            }
+
+            var shapeA = line;
+
+            // go through all defined shapes in B
+            var indexB = 0;
+            do {
+                var shapeB = objB.body.getShape(indexB);
+
+                // full SAT collision check
+                if (sat["test" + shapeA.shapeType + shapeB.shapeType]
+                    .call(
+                        this,
+                        dummyObj, // a reference to the object A
+                        shapeA,
+                        objB,  // a reference to the object B
+                        shapeB
+                )) {
+                    // we touched something !
+                    result[collisionCounter] = objB;
+                    collisionCounter++;
+                }
+                indexB++;
+            } while (indexB < bLen);
+        }
+    }
+
+    // cap result in case it was not empty
+    result.length = collisionCounter;
+
+    // return the list of colliding objects
+    return result;
+}
+
+export { collisionCheck, rayCast };

package/dist/melonjs.mjs/physics/quadtree.js

@@ -0,0 +1,391 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import Vector2d from '../math/vector2.js';
+import Container from '../renderable/container.js';
+import { remove } from '../utils/array.js';
+
+/*
+ * A QuadTree implementation in JavaScript, a 2d spatial subdivision algorithm.
+ * Based on the QuadTree Library by Timo Hausmann and released under the MIT license
+ * https://github.com/timohausmann/quadtree-js/
+**/
+
+
+/**
+ * a pool of `QuadTree` objects
+ * @ignore
+ */
+var QT_ARRAY = [];
+
+/**
+ * will pop a quadtree object from the array
+ * or create a new one if the array is empty
+ * @ignore
+ */
+function QT_ARRAY_POP(world, bounds, max_objects = 4, max_levels = 4, level = 0) {
+    if (QT_ARRAY.length > 0) {
+        var _qt =  QT_ARRAY.pop();
+        _qt.world = world;
+        _qt.bounds = bounds;
+        _qt.max_objects = max_objects;
+        _qt.max_levels  = max_levels;
+        _qt.level = level;
+        return _qt;
+    } else {
+        return new QuadTree(world, bounds, max_objects, max_levels, level);
+    }
+}
+
+/**
+ * Push back a quadtree back into the array
+ * @ignore
+ */
+function QT_ARRAY_PUSH(qt) {
+    QT_ARRAY.push(qt);
+}
+
+/**
+ * a temporary vector object to be reused
+ * @ignore
+ */
+var QT_VECTOR = new Vector2d();
+
+/**
+ * @classdesc
+ * a QuadTree implementation in JavaScript, a 2d spatial subdivision algorithm.
+ * @see game.world.broadphase
+ */
+class QuadTree {
+    /**
+     * @param {World} world - the physic world this QuadTree belongs to
+     * @param {Bounds} bounds - bounds of the node
+     * @param {number} [max_objects=4] - max objects a node can hold before splitting into 4 subnodes
+     * @param {number} [max_levels=4] - total max levels inside root Quadtree
+     * @param {number} [level] - deepth level, required for subnodes
+     */
+    constructor(world, bounds, max_objects = 4, max_levels = 4, level = 0) {
+
+        this.world = world;
+        this.bounds = bounds;
+
+        this.max_objects = max_objects;
+        this.max_levels  = max_levels;
+
+        this.level = level;
+        this.bounds = bounds;
+
+        this.objects = [];
+        this.nodes = [];
+    }
+
+    /*
+     * Split the node into 4 subnodes
+     */
+    split() {
+        this.level + 1;
+            var subWidth  = this.bounds.width / 2,
+            subHeight = this.bounds.height / 2,
+            left = this.bounds.left,
+            top = this.bounds.top;
+
+         //top right node
+        this.nodes[0] = QT_ARRAY_POP(
+            this.world,
+            this.bounds, {
+                left : left + subWidth,
+                top : top,
+                width : subWidth,
+                height : subHeight
+            },
+            this.max_objects,
+            this.max_levels);
+
+        //top left node
+        this.nodes[1] = QT_ARRAY_POP(
+            this.world,
+            this.bounds, {
+                left : left,
+                top: top,
+                width : subWidth,
+                height : subHeight
+            },
+            this.max_objects,
+            this.max_levels);
+
+        //bottom left node
+        this.nodes[2] = QT_ARRAY_POP(
+            this.world,
+            this.bounds, {
+                left : left,
+                top : top + subHeight,
+                width : subWidth,
+                height : subHeight
+            },
+            this.max_objects,
+            this.max_levels);
+
+        //bottom right node
+        this.nodes[3] = QT_ARRAY_POP(
+            this.world,
+            this.bounds, {
+                left : left + subWidth,
+                top : top + subHeight,
+                width : subWidth,
+                height : subHeight
+            },
+            this.max_objects,
+            this.max_levels);
+    }
+
+    /*
+     * Determine which node the object belongs to
+     * @param {Rect} rect bounds of the area to be checked
+     * @returns Integer index of the subnode (0-3), or -1 if rect cannot completely fit within a subnode and is part of the parent node
+     */
+    getIndex(item) {
+        var pos;
+        var bounds = item.getBounds();
+
+        // use game world coordinates for floating items
+        if (item.isFloating === true) {
+            pos = this.world.app.viewport.localToWorld(bounds.left, bounds.top, QT_VECTOR);
+        } else {
+            pos = QT_VECTOR.set(bounds.left, bounds.top);
+        }
+
+        var index = -1,
+            rx = pos.x,
+            ry = pos.y,
+            rw = bounds.width,
+            rh = bounds.height,
+            verticalMidpoint = this.bounds.left + (this.bounds.width / 2),
+            horizontalMidpoint = this.bounds.top + (this.bounds.height / 2),
+            //rect can completely fit within the top quadrants
+            topQuadrant = (ry < horizontalMidpoint && ry + rh < horizontalMidpoint),
+            //rect can completely fit within the bottom quadrants
+            bottomQuadrant = (ry > horizontalMidpoint);
+
+        //rect can completely fit within the left quadrants
+        if (rx < verticalMidpoint && rx + rw < verticalMidpoint) {
+            if (topQuadrant) {
+                index = 1;
+            } else if (bottomQuadrant) {
+                index = 2;
+            }
+        } else if (rx > verticalMidpoint) {
+            //rect can completely fit within the right quadrants
+            if (topQuadrant) {
+                index = 0;
+            } else if (bottomQuadrant) {
+                index = 3;
+            }
+        }
+
+        return index;
+    }
+
+    /**
+     * Insert the given object container into the node.
+     * @name insertContainer
+     * @memberof QuadTree
+     * @param {Container} container - group of objects to be added
+     */
+    insertContainer(container) {
+        for (var i = container.children.length, child; i--, (child = container.children[i]);) {
+            if (child.isKinematic !== true) {
+                if (child instanceof Container) {
+                    if (child.name !== "rootContainer") {
+                        this.insert(child);
+                    }
+                    // recursivly insert all childs
+                    this.insertContainer(child);
+                } else {
+                    // only insert object with a bounding box
+                    // Probably redundant with `isKinematic`
+                    if (typeof (child.getBounds) === "function") {
+                        this.insert(child);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Insert the given object into the node. If the node
+     * exceeds the capacity, it will split and add all
+     * objects to their corresponding subnodes.
+     * @name insert
+     * @memberof QuadTree
+     * @param {object} item - object to be added
+     */
+    insert(item) {
+        var index = -1;
+
+        //if we have subnodes ...
+        if (this.nodes.length > 0) {
+            index = this.getIndex(item);
+
+            if (index !== -1) {
+                this.nodes[index].insert(item);
+                return;
+            }
+        }
+
+        this.objects.push(item);
+
+        if (this.objects.length > this.max_objects && this.level < this.max_levels) {
+
+            //split if we don't already have subnodes
+            if (this.nodes.length === 0) {
+                this.split();
+            }
+
+            var i = 0;
+
+            //add all objects to there corresponding subnodes
+            while (i < this.objects.length) {
+
+                index = this.getIndex(this.objects[i]);
+
+                if (index !== -1) {
+                    this.nodes[index].insert(this.objects.splice(i, 1)[0]);
+                } else {
+                    i = i + 1;
+                }
+            }
+        }
+    }
+
+    /**
+     * Return all objects that could collide with the given object
+     * @name retrieve
+     * @memberof QuadTree
+     * @param {object} item - object to be checked against
+     * @param {object} [fn] - a sorting function for the returned array
+     * @returns {object[]} array with all detected objects
+     */
+    retrieve(item, fn) {
+        var returnObjects = this.objects;
+
+        //if we have subnodes ...
+        if (this.nodes.length > 0) {
+
+            var index = this.getIndex(item);
+
+            //if rect fits into a subnode ..
+            if (index !== -1) {
+                returnObjects = returnObjects.concat(this.nodes[index].retrieve(item));
+            } else {
+                 //if rect does not fit into a subnode, check it against all subnodes
+                for (var i = 0; i < this.nodes.length; i = i + 1) {
+                    returnObjects = returnObjects.concat(this.nodes[i].retrieve(item));
+                }
+            }
+        }
+
+        if (typeof(fn) === "function") {
+            returnObjects.sort(fn);
+        }
+
+        return returnObjects;
+    }
+
+    /**
+     * Remove the given item from the quadtree.
+     * (this function won't recalculate the impacted node)
+     * @name remove
+     * @memberof QuadTree
+     * @param {object} item - object to be removed
+     * @returns {boolean} true if the item was found and removed.
+     */
+     remove(item) {
+        var found = false;
+
+        if (typeof (item.getBounds) === "undefined") {
+            // ignore object that cannot be added in the first place
+            return false;
+        }
+
+        //if we have subnodes ...
+        if (this.nodes.length > 0) {
+            // determine to which node the item belongs to
+            var index = this.getIndex(item);
+
+            if (index !== -1) {
+                found = remove(this.nodes[index], item);
+                // trim node if empty
+                if (found && this.nodes[index].isPrunable()) {
+                    this.nodes.splice(index, 1);
+                }
+            }
+        }
+
+        if (found === false) {
+            // try and remove the item from the list of items in this node
+            if (this.objects.indexOf(item) !== -1) {
+                remove(this.objects, item);
+                found = true;
+            }
+        }
+
+        return found;
+    }
+
+    /**
+     * return true if the node is prunable
+     * @name isPrunable
+     * @memberof QuadTree
+     * @returns {boolean} true if the node is prunable
+     */
+    isPrunable() {
+        return !(this.hasChildren() || (this.objects.length > 0));
+    }
+
+    /**
+     * return true if the node has any children
+     * @name hasChildren
+     * @memberof QuadTree
+     * @returns {boolean} true if the node has any children
+     */
+    hasChildren() {
+        for (var i = 0; i < this.nodes.length; i = i + 1) {
+            var subnode = this.nodes[i];
+            if (subnode.length > 0 || subnode.objects.length > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * clear the quadtree
+     * @name clear
+     * @memberof QuadTree
+     * @param {Bounds} [bounds=this.bounds] - the bounds to be cleared
+     */
+    clear(bounds) {
+        this.objects.length = 0;
+
+        for (var i = 0; i < this.nodes.length; i++) {
+            this.nodes[i].clear();
+            // recycle the quadTree object
+            QT_ARRAY_PUSH(this.nodes[i]);
+        }
+        // empty the array
+        this.nodes.length = 0;
+
+        // resize the root bounds if required
+        if (typeof bounds !== "undefined") {
+            this.bounds.setMinMax(bounds.min.x, bounds.min.y, bounds.max.x, bounds.max.y);
+        }
+    }
+}
+
+var QuadTree$1 = QuadTree;
+
+export { QuadTree$1 as default };

package/dist/melonjs.mjs/physics/response.js

@@ -0,0 +1,57 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import Vector2d from '../math/vector2.js';
+
+/**
+ * @classdesc
+ * An object representing the result of an intersection.
+ * @property {Renderable} a The first object participating in the intersection
+ * @property {Renderable} b The second object participating in the intersection
+ * @property {number} overlap Magnitude of the overlap on the shortest colliding axis
+ * @property {Vector2d} overlapV The overlap vector (i.e. `overlapN.scale(overlap, overlap)`). If this vector is subtracted from the position of a, a and b will no longer be colliding
+ * @property {Vector2d} overlapN The shortest colliding axis (unit-vector)
+ * @property {boolean} aInB Whether the first object is entirely inside the second
+ * @property {boolean} bInA Whether the second object is entirely inside the first
+ * @property {number} indexShapeA The index of the colliding shape for the object a body
+ * @property {number} indexShapeB The index of the colliding shape for the object b body
+ * @name ResponseObject
+ * @public
+ */
+class ResponseObject {
+    constructor() {
+        this.a = null;
+        this.b = null;
+        this.overlapN = new Vector2d();
+        this.overlapV = new Vector2d();
+        this.aInB = true;
+        this.bInA = true;
+        this.indexShapeA = -1;
+        this.indexShapeB = -1;
+        this.overlap = Number.MAX_VALUE;
+    }
+
+    /**
+     * Set some values of the response back to their defaults. <br>
+     * Call this between tests if you are going to reuse a single <br>
+     * Response object for multiple intersection tests <br>
+     * (recommended as it will avoid allocating extra memory) <br>
+     * @name clear
+     * @public
+     * @returns {object} this object for chaining
+     */
+    clear () {
+        this.aInB = true;
+        this.bInA = true;
+        this.overlap = Number.MAX_VALUE;
+        this.indexShapeA = -1;
+        this.indexShapeB = -1;
+        return this;
+    }
+}
+
+export { ResponseObject as default };