melonjs 10.2.0 → 10.3.0

package/src/physics/bounds.js

@@ -1,15 +1,13 @@
 import Vector2d from "./../math/vector2.js";
-import Polygon from "./../shapes/poly.js";
+import Polygon from "./../geometries/poly.js";
 
 /**
  * @classdesc
  * a bound object contains methods for creating and manipulating axis-aligned bounding boxes (AABB).
  * @class Bounds
- * @memberOf me
- * @constructor
- * @memberOf me
+ * @memberof me
  * @param {me.Vector2d[]} [vertices] an array of me.Vector2d points
- * @return {me.Bounds} A new bounds object
+ * @returns {me.Bounds} A new bounds object
  */
 
 class Bounds {
@@ -36,7 +34,7 @@ class Bounds {
     /**
      * reset the bound
      * @name clear
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
      */
     clear() {
@@ -47,12 +45,12 @@ class Bounds {
     /**
      * sets the bounds to the given min and max value
      * @name setMinMax
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
-     * @param {Number} minX
-     * @param {Number} minY
-     * @param {Number} maxX
-     * @param {Number} maxY
+     * @param {number} minX
+     * @param {number} minY
+     * @param {number} maxX
+     * @param {number} maxY
      */
     setMinMax(minX, minY, maxX, maxY) {
         this.min.x = minX;
@@ -65,9 +63,9 @@ class Bounds {
     /**
      * x position of the bound
      * @public
-     * @type {Number}
+     * @type {number}
      * @name x
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      */
     get x() {
         return this.min.x;
@@ -82,9 +80,9 @@ class Bounds {
     /**
      * y position of the bounds
      * @public
-     * @type {Number}
+     * @type {number}
      * @name y
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      */
     get y() {
         return this.min.y;
@@ -100,9 +98,9 @@ class Bounds {
     /**
      * width of the bounds
      * @public
-     * @type {Number}
+     * @type {number}
      * @name width
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      */
     get width() {
         return this.max.x - this.min.x;
@@ -115,9 +113,9 @@ class Bounds {
     /**
      * width of the bounds
      * @public
-     * @type {Number}
+     * @type {number}
      * @name width
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      */
     get height() {
         return this.max.y - this.min.y;
@@ -130,9 +128,9 @@ class Bounds {
     /**
      * left coordinate of the bound
      * @public
-     * @type {Number}
+     * @type {number}
      * @name left
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      */
     get left() {
         return this.min.x;
@@ -141,9 +139,9 @@ class Bounds {
     /**
      * right coordinate of the bound
      * @public
-     * @type {Number}
+     * @type {number}
      * @name right
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      */
     get right() {
         return this.max.x;
@@ -152,9 +150,9 @@ class Bounds {
     /**
      * top coordinate of the bound
      * @public
-     * @type {Number}
+     * @type {number}
      * @name top
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      */
     get top() {
         return this.min.y;
@@ -163,9 +161,9 @@ class Bounds {
     /**
      * bottom coordinate of the bound
      * @public
-     * @type {Number}
+     * @type {number}
      * @name bottom
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      */
     get bottom() {
         return this.max.y;
@@ -174,9 +172,9 @@ class Bounds {
     /**
      * center position of the bound on the x axis
      * @public
-     * @type {Number}
+     * @type {number}
      * @name centerX
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      */
     get centerX() {
         return this.min.x + (this.width / 2);
@@ -185,9 +183,9 @@ class Bounds {
     /**
      * center position of the bound on the y axis
      * @public
-     * @type {Number}
+     * @type {number}
      * @name centerY
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      */
     get centerY() {
         return this.min.y + (this.height / 2);
@@ -198,7 +196,7 @@ class Bounds {
      * @public
      * @type {me.Vector2d}
      * @name center
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      */
     get center() {
         return this._center.set(this.centerX, this.centerY);
@@ -207,7 +205,7 @@ class Bounds {
     /**
      * Updates bounds using the given vertices
      * @name update
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
      * @param {me.Vector2d[]} vertices an array of me.Vector2d points
      */
@@ -218,7 +216,7 @@ class Bounds {
     /**
      * add the given vertices to the bounds definition.
      * @name add
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
      * @param {me.Vector2d[]} vertices an array of me.Vector2d points
      * @param {boolean} [clear=false] either to reset the bounds before adding the new vertices
@@ -239,7 +237,7 @@ class Bounds {
     /**
      * add the given bounds to the bounds definition.
      * @name addBounds
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
      * @param {me.Bounds} bounds
      * @param {boolean} [clear=false] either to reset the bounds before adding the new vertices
@@ -258,10 +256,10 @@ class Bounds {
     /**
      * add the given point to the bounds definition.
      * @name addPoint
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
-     * @param {me.Vector2d} vector
-     * @param {me.Matrix2d} [matrix] an optional transform to apply to the given point
+     * @param {me.Vector2d} v
+     * @param {me.Matrix2d} [m] an optional transform to apply to the given point
      */
     addPoint(v, m) {
         if (typeof m !== "undefined") {
@@ -276,13 +274,13 @@ class Bounds {
     /**
      * add the given quad coordinates to this bound definition, multiplied by the given matrix
      * @name addFrame
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
-     * @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 {me.Matrix2d} [matrix] an optional transform to apply to the given frame coordinates
+     * @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 {me.Matrix2d} [m] an optional transform to apply to the given frame coordinates
      */
     addFrame(x0, y0, x1, y1, m) {
         var v = me.pool.pull("Vector2d");
@@ -299,19 +297,19 @@ class Bounds {
     /**
      * Returns true if the bounds contains the given point.
      * @name contains
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
      * @param {me.Vector2d} point
-     * @return {boolean} True if the bounds contain the point, otherwise false
+     * @returns {boolean} True if the bounds contain the point, otherwise false
      */
     /**
      * Returns true if the bounds contains the given point.
      * @name contains
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
-     * @param {Number} x
-     * @param {Number} y
-     * @return {boolean} True if the bounds contain the point, otherwise false
+     * @param {number} x
+     * @param {number} y
+     * @returns {boolean} True if the bounds contain the point, otherwise false
      */
     contains() {
         var arg0 = arguments[0];
@@ -341,10 +339,10 @@ class Bounds {
     /**
      * Returns true if the two bounds intersect.
      * @name overlaps
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
      * @param {me.Bounds|me.Rect} bounds
-     * @return {boolean} True if the bounds overlap, otherwise false
+     * @returns {boolean} True if the bounds overlap, otherwise false
      */
     overlaps(bounds) {
         return !(this.right < bounds.left || this.left > bounds.right ||
@@ -354,9 +352,9 @@ class Bounds {
     /**
      * determines whether all coordinates of this bounds are finite numbers.
      * @name isFinite
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
-     * @return {boolean} false if all coordinates are positive or negative Infinity or NaN; otherwise, true.
+     * @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));
@@ -365,17 +363,17 @@ class Bounds {
     /**
      * Translates the bounds by the given vector.
      * @name translate
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
      * @param {me.Vector2d} vector
      */
     /**
      * Translates the bounds by x on the x axis, and y on the y axis
      * @name translate
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
-     * @param {Number} x
-     * @param {Number} y
+     * @param {number} x
+     * @param {number} y
      */
     translate() {
         var _x, _y;
@@ -397,17 +395,17 @@ class Bounds {
     /**
      * Shifts the bounds to the given position vector.
      * @name shift
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
      * @param {me.Vector2d} position
      */
     /**
      * Shifts the bounds to the given x, y position.
      * @name shift
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
-     * @param {Number} x
-     * @param {Number} y
+     * @param {number} x
+     * @param {number} y
      */
     shift() {
         var _x, _y;
@@ -434,9 +432,9 @@ class Bounds {
     /**
      * clone this bounds
      * @name clone
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
-     * @return {me.Bounds}
+     * @returns {me.Bounds}
      */
     clone() {
         var bounds = new Bounds();
@@ -447,9 +445,9 @@ class Bounds {
     /**
      * Returns a polygon whose edges are the same as this bounds.
      * @name toPolygon
-     * @memberOf me.Bounds
+     * @memberof me.Bounds
      * @function
-     * @return {me.Polygon} a new Polygon that represents this bounds.
+     * @returns {me.Polygon} a new Polygon that represents this bounds.
      */
     toPolygon () {
         return new Polygon(this.x, this.y, [

package/src/physics/collision.js

@@ -4,7 +4,7 @@ import { rayCast, globalResponse } 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
- * @memberOf me
+ * @memberof me
  */
 
 var collision = {
@@ -12,9 +12,9 @@ var collision = {
      /**
       * The maximum number of children that a quadtree node can contain before it is split into sub-nodes.
       * @name maxChildren
-      * @memberOf me.collision
+      * @memberof me.collision
       * @public
-      * @type {Number}
+      * @type {number}
       * @default 8
       * @see me.game.world.broadphase
       */
@@ -23,31 +23,30 @@ var collision = {
      /**
       * The maximum number of levels that the quadtree will create.
       * @name maxDepth
-      * @memberOf me.collision
+      * @memberof me.collision
       * @public
-      * @type {Number}
+      * @type {number}
       * @default 4
       * @see me.game.world.broadphase
-      *
       */
      maxDepth : 4,
 
     /**
      * Enum for collision type values.
-     * @property NO_OBJECT to disable collision check
-     * @property PLAYER_OBJECT
-     * @property NPC_OBJECT
-     * @property ENEMY_OBJECT
-     * @property COLLECTABLE_OBJECT
-     * @property ACTION_OBJECT e.g. doors
-     * @property PROJECTILE_OBJECT e.g. missiles
-     * @property WORLD_SHAPE e.g. walls; for map collision shapes
-     * @property USER user-defined collision types (see example)
-     * @property ALL_OBJECT all of the above (including user-defined types)
+     * @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}
+     * @enum {number}
      * @name types
-     * @memberOf me.collision
+     * @memberof me.collision
      * @see me.body.setCollisionMask
      * @see me.body.collisionType
      * @example
@@ -98,7 +97,7 @@ var collision = {
      * a global instance of a response object used for collision detection <br>
      * this object will be reused amongst collision detection call if not user-defined response is specified
      * @name response
-     * @memberOf me.collision
+     * @memberof me.collision
      * @public
      * @type {me.collision.ResponseObject}
      */
@@ -107,12 +106,12 @@ var collision = {
     /**
      * Checks for object colliding with the given line
      * @name rayCast
-     * @memberOf me.collision
+     * @memberof me.collision
      * @public
      * @function
      * @param {me.Line} line line to be tested for collision
      * @param {Array.<me.Renderable>} [result] a user defined array that will be populated with intersecting physic objects.
-     * @return {Array.<me.Renderable>} an array of intersecting physic objects
+     * @returns {Array.<me.Renderable>} an array of intersecting physic objects
      * @example
      *    // define a line accross the viewport
      *    var ray = new me.Line(
@@ -131,7 +130,7 @@ var collision = {
      *        // ...
      *    }
      */
-    rayCast(line, resultArray) { return rayCast(line, resultArray); }
+    rayCast(line, result) { return rayCast(line, result); }
 };
 
 export default collision;

package/src/physics/detector.js

@@ -17,12 +17,12 @@ var dummyObj = {
  * 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 me.collision
+ * @memberof me.collision
  * @ignore
  * @function
  * @param {me.Renderable} a a reference to the object A.
  * @param {me.Renderable} b a reference to the object B.
- * @return {Boolean} true if they should collide, false otherwise
+ * @returns {boolean} true if they should collide, false otherwise
  */
 function shouldCollide(a, b) {
     return (
@@ -38,15 +38,15 @@ function shouldCollide(a, b) {
  * An object representing the result of an intersection.
  * @property {me.Renderable} a The first object participating in the intersection
  * @property {me.Renderable} b The second object participating in the intersection
- * @property {Number} overlap Magnitude of the overlap on the shortest colliding axis
+ * @property {number} overlap Magnitude of the overlap on the shortest colliding axis
  * @property {me.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 {me.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
+ * @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
- * @memberOf me.collision
+ * @memberof me.collision
  * @public
  */
 class ResponseObject {
@@ -60,7 +60,6 @@ class ResponseObject {
         this.indexShapeA = -1;
         this.indexShapeB = -1;
         this.overlap = Number.MAX_VALUE;
-        return this;
     }
 
     /**
@@ -69,9 +68,10 @@ class ResponseObject {
      * Response object for multiple intersection tests <br>
      * (recommended as it will avoid allocating extra memory) <br>
      * @name clear
-     * @memberOf me.collision.ResponseObject
+     * @memberof me.collision.ResponseObject
      * @public
      * @function
+     * @returns {object} this object for chaining
      */
     clear () {
         this.aInB = true;
@@ -91,9 +91,9 @@ export var globalResponse = new ResponseObject();
  * @name collisionCheck
  * @ignore
  * @function
- * @param {me.Renderable} obj object to be tested for collision
+ * @param {me.Renderable} objA object to be tested for collision
  * @param {me.collision.ResponseObject} [response=me.collision.response] a user defined response object that will be populated if they intersect.
- * @return {Boolean} in case of collision, false otherwise
+ * @returns {boolean} in case of collision, false otherwise
  */
 export function collisionCheck(objA, response = globalResponse) {
     var collisionCounter = 0;
@@ -165,7 +165,7 @@ export function collisionCheck(objA, response = globalResponse) {
  * @function
  * @param {me.Line} line line to be tested for collision
  * @param {Array.<me.Renderable>} [result] a user defined array that will be populated with intersecting physic objects.
- * @return {Array.<me.Renderable>} an array of intersecting physic objects
+ * @returns {Array.<me.Renderable>} an array of intersecting physic objects
  * @example
  *    // define a line accross the viewport
  *    var ray = new me.Line(

package/src/physics/quadtree.js

@@ -53,13 +53,12 @@ var QT_VECTOR = new Vector2d();
  * a QuadTree implementation in JavaScript, a 2d spatial subdivision algorithm.
  * @class
  * @name QuadTree
- * @memberOf me
- * @constructor
+ * @memberof me
  * @see me.game.world.broadphase
  * @param {me.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
+ * @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
  */
 class QuadTree {
 
@@ -120,14 +119,15 @@ class QuadTree {
     /*
      * Determine which node the object belongs to
      * @param {me.Rect} rect bounds of the area to be checked
-     * @return Integer index of the subnode (0-3), or -1 if rect cannot completely fit within a subnode and is part of the parent node
+     * @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.floating || (item.ancestor && item.ancestor.floating)) {
-            pos = viewport.localToWorld(item.left, item.top, QT_VECTOR);
+        if (item.isFloating === true) {
+            pos = viewport.localToWorld(bounds.left, bounds.top, QT_VECTOR);
         } else {
             pos = QT_VECTOR.set(item.left, item.top);
         }
@@ -135,8 +135,8 @@ class QuadTree {
         var index = -1,
             rx = pos.x,
             ry = pos.y,
-            rw = item.width,
-            rh = item.height,
+            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
@@ -166,7 +166,7 @@ class QuadTree {
     /**
      * Insert the given object container into the node.
      * @name insertContainer
-     * @memberOf me.QuadTree
+     * @memberof me.QuadTree
      * @function
      * @param {me.Container} container group of objects to be added
      */
@@ -195,9 +195,9 @@ class QuadTree {
      * exceeds the capacity, it will split and add all
      * objects to their corresponding subnodes.
      * @name insert
-     * @memberOf me.QuadTree
+     * @memberof me.QuadTree
      * @function
-     * @param {Object} item object to be added
+     * @param {object} item object to be added
      */
     insert(item) {
         var index = -1;
@@ -240,11 +240,11 @@ class QuadTree {
     /**
      * Return all objects that could collide with the given object
      * @name retrieve
-     * @memberOf me.QuadTree
+     * @memberof me.QuadTree
      * @function
-     * @param {Object} object object to be checked against
-     * @param {Object} [function] a sorting function for the returned array
-     * @return {Object[]} array with all detected objects
+     * @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;
@@ -276,10 +276,10 @@ class QuadTree {
      * Remove the given item from the quadtree.
      * (this function won't recalculate the impacted node)
      * @name remove
-     * @memberOf me.QuadTree
+     * @memberof me.QuadTree
      * @function
-     * @param {Object} object object to be removed
-     * @return true if the item was found and removed.
+     * @param {object} item object to be removed
+     * @returns {boolean} true if the item was found and removed.
      */
      remove(item) {
         var found = false;
@@ -317,9 +317,9 @@ class QuadTree {
     /**
      * return true if the node is prunable
      * @name isPrunable
-     * @memberOf me.QuadTree
+     * @memberof me.QuadTree
      * @function
-     * @return true if the node is prunable
+     * @returns {boolean} true if the node is prunable
      */
     isPrunable() {
         return !(this.hasChildren() || (this.objects.length > 0));
@@ -328,9 +328,9 @@ class QuadTree {
     /**
      * return true if the node has any children
      * @name hasChildren
-     * @memberOf me.QuadTree
+     * @memberof me.QuadTree
      * @function
-     * @return true if the node has any children
+     * @returns {boolean} true if the node has any children
      */
     hasChildren() {
         for (var i = 0; i < this.nodes.length; i = i + 1) {
@@ -345,8 +345,9 @@ class QuadTree {
     /**
      * clear the quadtree
      * @name clear
-     * @memberOf me.QuadTree
+     * @memberof me.QuadTree
      * @function
+     * @param {me.Bounds} [bounds=this.bounds] the bounds to be cleared
      */
     clear(bounds) {
         this.objects.length = 0;