melonjs 14.0.1 → 14.1.0

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

@@ -0,0 +1,460 @@
+/*!
+ * 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 pool from '../system/pooling.js';
+import Vector2d from '../math/vector2.js';
+
+/**
+ * @classdesc
+ * a bound object contains methods for creating and manipulating axis-aligned bounding boxes (AABB).
+ */
+class Bounds {
+    /**
+     * @param {Vector2d[]} [vertices] - an array of me.Vector2d points
+     */
+    constructor(vertices) {
+        // @ignore
+        this._center = new Vector2d();
+        this.onResetEvent(vertices);
+    }
+
+    /**
+     * @ignore
+     */
+    onResetEvent(vertices) {
+        if (typeof this.min === "undefined") {
+            this.min = { x: Infinity,  y: Infinity };
+            this.max = { x: -Infinity, y: -Infinity };
+        } else {
+            this.clear();
+        }
+        if (typeof vertices !== "undefined") {
+            this.update(vertices);
+        }
+    }
+
+    /**
+     * reset the bound
+     * @name clear
+     * @memberof Bounds
+     */
+    clear() {
+        this.setMinMax(Infinity, Infinity, -Infinity, -Infinity);
+
+    }
+
+    /**
+     * sets the bounds to the given min and max value
+     * @name setMinMax
+     * @memberof Bounds
+     * @param {number} minX
+     * @param {number} minY
+     * @param {number} maxX
+     * @param {number} maxY
+     */
+    setMinMax(minX, minY, maxX, maxY) {
+        this.min.x = minX;
+        this.min.y = minY;
+
+        this.max.x = maxX;
+        this.max.y = maxY;
+    }
+
+    /**
+     * x position of the bound
+     * @public
+     * @type {number}
+     * @name x
+     * @memberof Bounds
+     */
+    get x() {
+        return this.min.x;
+    }
+
+    set x(value) {
+        var deltaX = this.max.x - this.min.x;
+        this.min.x = value;
+        this.max.x = value + deltaX;
+    }
+
+    /**
+     * y position of the bounds
+     * @public
+     * @type {number}
+     * @name y
+     * @memberof Bounds
+     */
+    get y() {
+        return this.min.y;
+    }
+
+    set y(value) {
+        var deltaY = this.max.y - this.min.y;
+
+        this.min.y = value;
+        this.max.y = value + deltaY;
+    }
+
+    /**
+     * width of the bounds
+     * @public
+     * @type {number}
+     * @name width
+     * @memberof Bounds
+     */
+    get width() {
+        return this.max.x - this.min.x;
+    }
+
+    set width(value) {
+        this.max.x = this.min.x + value;
+    }
+
+    /**
+     * width of the bounds
+     * @public
+     * @type {number}
+     * @name width
+     * @memberof Bounds
+     */
+    get height() {
+        return this.max.y - this.min.y;
+    }
+
+    set height(value) {
+        this.max.y = this.min.y + value;
+    }
+
+    /**
+     * left coordinate of the bound
+     * @public
+     * @type {number}
+     * @name left
+     * @memberof Bounds
+     */
+    get left() {
+        return this.min.x;
+    }
+
+    /**
+     * right coordinate of the bound
+     * @public
+     * @type {number}
+     * @name right
+     * @memberof Bounds
+     */
+    get right() {
+        return this.max.x;
+    }
+
+    /**
+     * top coordinate of the bound
+     * @public
+     * @type {number}
+     * @name top
+     * @memberof Bounds
+     */
+    get top() {
+        return this.min.y;
+    }
+
+    /**
+     * bottom coordinate of the bound
+     * @public
+     * @type {number}
+     * @name bottom
+     * @memberof Bounds
+     */
+    get bottom() {
+        return this.max.y;
+    }
+
+    /**
+     * center position of the bound on the x axis
+     * @public
+     * @type {number}
+     * @name centerX
+     * @memberof Bounds
+     */
+    get centerX() {
+        return this.min.x + (this.width / 2);
+    }
+
+    /**
+     * center position of the bound on the y axis
+     * @public
+     * @type {number}
+     * @name centerY
+     * @memberof Bounds
+     */
+    get centerY() {
+        return this.min.y + (this.height / 2);
+    }
+
+    /**
+     * return the center position of the bound
+     * @public
+     * @type {Vector2d}
+     * @name center
+     * @memberof Bounds
+     */
+    get center() {
+        return this._center.set(this.centerX, this.centerY);
+    }
+
+    /**
+     * Updates bounds using the given vertices
+     * @name update
+     * @memberof Bounds
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points
+     */
+    update(vertices) {
+        this.add(vertices, true);
+    }
+
+    /**
+     * add the given vertices to the bounds definition.
+     * @name add
+     * @memberof Bounds
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points
+     * @param {boolean} [clear=false] - either to reset the bounds before adding the new vertices
+     */
+    add(vertices, clear = false) {
+        if (clear === true) {
+            this.clear();
+        }
+        for (var i = 0; i < vertices.length; i++) {
+            var vertex = vertices[i];
+            if (vertex.x > this.max.x) this.max.x = vertex.x;
+            if (vertex.x < this.min.x) this.min.x = vertex.x;
+            if (vertex.y > this.max.y) this.max.y = vertex.y;
+            if (vertex.y < this.min.y) this.min.y = vertex.y;
+        }
+    }
+
+    /**
+     * add the given bounds to the bounds definition.
+     * @name addBounds
+     * @memberof Bounds
+     * @param {Bounds} bounds
+     * @param {boolean} [clear=false] - either to reset the bounds before adding the new vertices
+     */
+    addBounds(bounds, clear = false) {
+        if (clear === true) {
+            this.max.x = bounds.max.x;
+            this.min.x = bounds.min.x;
+            this.max.y = bounds.max.y;
+            this.min.y = bounds.min.y;
+        } else {
+            if (bounds.max.x > this.max.x) this.max.x = bounds.max.x;
+            if (bounds.min.x < this.min.x) this.min.x = bounds.min.x;
+            if (bounds.max.y > this.max.y) this.max.y = bounds.max.y;
+            if (bounds.min.y < this.min.y) this.min.y = bounds.min.y;
+        }
+    }
+
+    /**
+     * add the given point to the bounds definition.
+     * @name addPoint
+     * @memberof Bounds
+     * @param {Vector2d|Point} point - the point to be added to the bounds
+     * @param {Matrix2d} [m] - an optional transform to apply to the given point (only if the given point is a vector)
+     */
+    addPoint(point, m) {
+        if ((typeof m !== "undefined") && (typeof point.rotate === "function")) {
+            // only Vectors object have a rotate function
+            point = m.apply(point);
+        }
+        this.min.x = Math.min(this.min.x, point.x);
+        this.max.x = Math.max(this.max.x, point.x);
+        this.min.y = Math.min(this.min.y, point.y);
+        this.max.y = Math.max(this.max.y, point.y);
+    }
+
+    /**
+     * add the given quad coordinates to this bound definition, multiplied by the given matrix
+     * @name addFrame
+     * @memberof Bounds
+     * @param {number} x0 - left X coordinates of the quad
+     * @param {number} y0 - top Y coordinates of the quad
+     * @param {number} x1 - right X coordinates of the quad
+     * @param {number} y1 - bottom y coordinates of the quad
+     * @param {Matrix2d} [m] - an optional transform to apply to the given frame coordinates
+     */
+    addFrame(x0, y0, x1, y1, m) {
+        var v = pool.pull("Vector2d");
+
+        // transform all points and add to the bound definition
+        this.addPoint(v.set(x0, y0), m);
+        this.addPoint(v.set(x1, y0), m);
+        this.addPoint(v.set(x0, y1), m);
+        this.addPoint(v.set(x1, y1), m);
+
+        pool.push(v);
+    }
+
+    /**
+     * Returns true if the bounds contains the given point.
+     * @name contains
+     * @memberof Bounds
+     * @method
+     * @param {Vector2d} point
+     * @returns {boolean} True if the bounds contain the point, otherwise false
+     */
+    /**
+     * Returns true if the bounds contains the given point.
+     * @name contains
+     * @memberof Bounds
+     * @param {number} x
+     * @param {number} y
+     * @returns {boolean} True if the bounds contain the point, otherwise false
+     */
+    contains() {
+        var arg0 = arguments[0];
+        var _x1, _x2, _y1, _y2;
+        if (arguments.length === 2) {
+            // x, y
+            _x1 = _x2 = arg0;
+            _y1 = _y2 = arguments[1];
+        } else {
+            if (arg0 instanceof Bounds) {
+                // bounds
+                _x1 = arg0.min.x;
+                _x2 = arg0.max.x;
+                _y1 = arg0.min.y;
+                _y2 = arg0.max.y;
+            } else {
+                // vector
+                _x1 = _x2 = arg0.x;
+                _y1 = _y2 = arg0.y;
+            }
+        }
+
+        return _x1 >= this.min.x && _x2 <= this.max.x
+            && _y1 >= this.min.y && _y2 <= this.max.y;
+    }
+
+    /**
+     * Returns true if the two bounds intersect.
+     * @name overlaps
+     * @memberof Bounds
+     * @param {Bounds|Rect} bounds
+     * @returns {boolean} True if the bounds overlap, otherwise false
+     */
+    overlaps(bounds) {
+        return !(this.right < bounds.left || this.left > bounds.right ||
+                 this.bottom < bounds.top || this.top > bounds.bottom);
+    }
+
+    /**
+     * determines whether all coordinates of this bounds are finite numbers.
+     * @name isFinite
+     * @memberof Bounds
+     * @returns {boolean} false if all coordinates are positive or negative Infinity or NaN; otherwise, true.
+     */
+    isFinite() {
+        return (isFinite(this.min.x) && isFinite(this.max.x) && isFinite(this.min.y) && isFinite(this.max.y));
+    }
+
+    /**
+     * Translates the bounds by the given vector.
+     * @name translate
+     * @memberof Bounds
+     * @method
+     * @param {Vector2d} vector
+     */
+    /**
+     * Translates the bounds by x on the x axis, and y on the y axis
+     * @name translate
+     * @memberof Bounds
+     * @param {number} x
+     * @param {number} y
+     */
+    translate() {
+        var _x, _y;
+        if (arguments.length === 2) {
+            // x, y
+            _x = arguments[0];
+            _y = arguments[1];
+        } else {
+            // vector
+            _x = arguments[0].x;
+            _y = arguments[0].y;
+        }
+        this.min.x += _x;
+        this.max.x += _x;
+        this.min.y += _y;
+        this.max.y += _y;
+    }
+
+    /**
+     * Shifts the bounds to the given position vector.
+     * @name shift
+     * @memberof Bounds
+     * @method
+     * @param {Vector2d} position
+     */
+    /**
+     * Shifts the bounds to the given x, y position.
+     * @name shift
+     * @memberof Bounds
+     * @param {number} x
+     * @param {number} y
+     */
+    shift() {
+        var _x, _y;
+
+        if (arguments.length === 2) {
+            // x, y
+            _x = arguments[0];
+            _y = arguments[1];
+        } else {
+            // vector
+            _x = arguments[0].x;
+            _y = arguments[0].y;
+        }
+
+        var deltaX = this.max.x - this.min.x,
+            deltaY = this.max.y - this.min.y;
+
+        this.min.x = _x;
+        this.max.x = _x + deltaX;
+        this.min.y = _y;
+        this.max.y = _y + deltaY;
+    }
+
+    /**
+     * clone this bounds
+     * @name clone
+     * @memberof Bounds
+     * @returns {Bounds}
+     */
+    clone() {
+        var bounds = new Bounds();
+        bounds.addBounds(this);
+        return bounds;
+    }
+
+    /**
+     * Returns a polygon whose edges are the same as this bounds.
+     * @name toPolygon
+     * @memberof Bounds
+     * @returns {Polygon} a new Polygon that represents this bounds.
+     */
+    toPolygon () {
+        return pool.pull("Polygon", this.x, this.y, [
+            pool.pull("Vector2d", 0,          0),
+            pool.pull("Vector2d", this.width, 0),
+            pool.pull("Vector2d", this.width, this.height),
+            pool.pull("Vector2d", 0,          this.height)
+        ]);
+    }
+
+}
+var Bounds$1 = Bounds;
+
+export { Bounds$1 as default };

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

@@ -0,0 +1,132 @@
+/*!
+ * 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 { rayCast } from './detector.js';
+
+/**
+ * Collision detection (and projection-based collision response) of 2D shapes.<br>
+ * Based on the Separating Axis Theorem and supports detecting collisions between simple Axis-Aligned Boxes, convex polygons and circles based shapes.
+ * @namespace collision
+ */
+
+var collision = {
+
+     /**
+      * The maximum number of children that a quadtree node can contain before it is split into sub-nodes.
+      * @name maxChildren
+      * @memberof collision
+      * @public
+      * @type {number}
+      * @default 8
+      * @see game.world.broadphase
+      */
+     maxChildren : 8,
+
+     /**
+      * The maximum number of levels that the quadtree will create.
+      * @name maxDepth
+      * @memberof collision
+      * @public
+      * @type {number}
+      * @default 4
+      * @see game.world.broadphase
+      */
+     maxDepth : 4,
+
+    /**
+     * Enum for collision type values.
+     * @property {number} NO_OBJECT to disable collision check
+     * @property {number} PLAYER_OBJECT playbable characters
+     * @property {number} NPC_OBJECT non playable characters
+     * @property {number} ENEMY_OBJECT enemies objects
+     * @property {number} COLLECTABLE_OBJECT collectable objects
+     * @property {number} ACTION_OBJECT e.g. doors
+     * @property {number} PROJECTILE_OBJECT e.g. missiles
+     * @property {number} WORLD_SHAPE e.g. walls; for map collision shapes
+     * @property {number} USER user-defined collision types (see example)
+     * @property {number} ALL_OBJECT all of the above (including user-defined types)
+     * @readonly
+     * @enum {number}
+     * @name types
+     * @memberof collision
+     * @see Body.setCollisionMask
+     * @see Body.collisionType
+     * @example
+     * // set the body collision type
+     * myEntity.body.collisionType = me.collision.types.PLAYER_OBJECT;
+     *
+     * // filter collision detection with collision shapes, enemies and collectables
+     * myEntity.body.setCollisionMask(
+     *     me.collision.types.WORLD_SHAPE |
+     *     me.collision.types.ENEMY_OBJECT |
+     *     me.collision.types.COLLECTABLE_OBJECT
+     * );
+     *
+     * // User-defined collision types are defined using BITWISE LEFT-SHIFT:
+     * game.collisionTypes = {
+     *     LOCKED_DOOR : me.collision.types.USER << 0,
+     *     OPEN_DOOR   : me.collision.types.USER << 1,
+     *     LOOT        : me.collision.types.USER << 2,
+     * };
+     *
+     * // Set collision type for a door entity
+     * myDoorEntity.body.collisionType = game.collisionTypes.LOCKED_DOOR;
+     *
+     * // Set collision mask for the player entity, so it collides with locked doors and loot
+     * myPlayerEntity.body.setCollisionMask(
+     *     me.collision.types.ENEMY_OBJECT |
+     *     me.collision.types.WORLD_SHAPE |
+     *     game.collisionTypes.LOCKED_DOOR |
+     *     game.collisionTypes.LOOT
+     * );
+     */
+    types : {
+        /** to disable collision check */
+        NO_OBJECT           : 0,
+        PLAYER_OBJECT       : 1 << 0,
+        NPC_OBJECT          : 1 << 1,
+        ENEMY_OBJECT        : 1 << 2,
+        COLLECTABLE_OBJECT  : 1 << 3,
+        ACTION_OBJECT       : 1 << 4, // door, etc...
+        PROJECTILE_OBJECT   : 1 << 5, // missiles, etc...
+        WORLD_SHAPE         : 1 << 6, // walls, etc...
+        USER                : 1 << 7, // user-defined types start here...
+        ALL_OBJECT          : 0xFFFFFFFF // all objects
+    },
+
+    /**
+     * Checks for object colliding with the given line
+     * @name rayCast
+     * @memberof collision
+     * @public
+     * @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) {
+     *        // ...
+     *    }
+     */
+    rayCast(line, result) { return rayCast(line, result); }
+};
+
+var collision$1 = collision;
+
+export { collision$1 as default };