melonjs 15.3.0 → 15.4.1

package/src/geometries/poly.js

@@ -12,7 +12,7 @@ import pool from "./../system/pooling.js";
  *
  * A polygon's `winding` is clockwise if its vertices (points) are declared turning to the right. The image above shows COUNTERCLOCKWISE winding.
  */
- export default class Polygon {
+export default class Polygon {
     /**
      * @param {number} x - origin point of the Polygon
      * @param {number} y - origin point of the Polygon
@@ -21,10 +21,7 @@ import pool from "./../system/pooling.js";
     constructor(x, y, points) {
         /**
          * origin point of the Polygon
-         * @public
          * @type {Vector2d}
-         * @name pos
-         * @memberof Polygon
          */
         this.pos = pool.pull("Vector2d");
 
@@ -32,18 +29,13 @@ import pool from "./../system/pooling.js";
          * The bounding rectangle for this shape
          * @ignore
          * @member {Bounds}
-         * @name _bounds
-         * @memberof Polygon
          */
         this._bounds;
 
         /**
          * Array of points defining the Polygon <br>
          * Note: If you manually change `points`, you **must** call `recalc`afterwards so that the changes get applied correctly.
-         * @public
          * @type {Vector2d[]}
-         * @name points
-         * @memberof Polygon
          */
         this.points = [];
 
@@ -81,8 +73,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * set new value to the Polygon
-     * @name setShape
-     * @memberof Polygon
      * @param {number} x - position of the Polygon
      * @param {number} y - position of the Polygon
      * @param {Vector2d[]|number[]} points - array of vector or vertice defining the Polygon
@@ -96,8 +86,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * set the vertices defining this Polygon
-     * @name setVertices
-     * @memberof Polygon
      * @param {Vector2d[]} vertices - array of vector or vertice defining the Polygon
      * @returns {Polygon} this instance for objecf chaining
      */
@@ -114,7 +102,7 @@ import pool from "./../system/pooling.js";
             if (typeof vertices[0] === "object") {
                 // array of {x,y} object
                 vertices.forEach((vertice) => {
-                   this.points.push(pool.pull("Vector2d", vertice.x, vertice.y));
+                    this.points.push(pool.pull("Vector2d", vertice.x, vertice.y));
                 });
 
             } else {
@@ -135,8 +123,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * apply the given transformation matrix to this Polygon
-     * @name transform
-     * @memberof Polygon
      * @param {Matrix2d} m - the transformation matrix
      * @returns {Polygon} Reference to this object for method chaining
      */
@@ -153,8 +139,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * apply an isometric projection to this shape
-     * @name toIso
-     * @memberof Polygon
      * @returns {Polygon} Reference to this object for method chaining
      */
     toIso() {
@@ -162,9 +146,7 @@ import pool from "./../system/pooling.js";
     }
 
     /**
-     * apply a 2d projection to this shape
-     * @name to2d
-     * @memberof Polygon
+     * apply a 2d projection to this shapen
      * @returns {Polygon} Reference to this object for method chaining
      */
     to2d() {
@@ -173,8 +155,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * Rotate this Polygon (counter-clockwise) by the specified angle (in radians).
-     * @name rotate
-     * @memberof Polygon
      * @param {number} angle - The angle to rotate (in radians)
      * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around
      * @returns {Polygon} Reference to this object for method chaining
@@ -194,8 +174,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * Scale this Polygon by the given scalar.
-     * @name scale
-     * @memberof Polygon
      * @param {number} x
      * @param {number} [y=x]
      * @returns {Polygon} Reference to this object for method chaining
@@ -213,8 +191,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * Scale this Polygon by the given vector
-     * @name scaleV
-     * @memberof Polygon
      * @param {Vector2d} v
      * @returns {Polygon} Reference to this object for method chaining
      */
@@ -225,12 +201,9 @@ import pool from "./../system/pooling.js";
     /**
      * Computes the calculated collision polygon.
      * This **must** be called if the `points` array, `angle`, or `offset` is modified manually.
-     * @name recalc
-     * @memberof Polygon
      * @returns {Polygon} Reference to this object for method chaining
      */
     recalc() {
-        let i;
         let edges = this.edges;
         let normals = this.normals;
         let indices = this.indices;
@@ -244,7 +217,7 @@ import pool from "./../system/pooling.js";
         }
 
         // Calculate the edges/normals
-        for (i = 0; i < len; i++) {
+        for (let i = 0; i < len; i++) {
             if (edges[i] === undefined) {
                 edges[i] = pool.pull("Vector2d");
             }
@@ -268,8 +241,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * returns a list of indices for all triangles defined in this polygon
-     * @name getIndices
-     * @memberof Polygon
      * @returns {Array} an array of vertex indices for all triangles forming this polygon.
      */
     getIndices() {
@@ -281,8 +252,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * Returns true if the vertices composing this polygon form a convex shape (vertices must be in clockwise order).
-     * @name isConvex
-     * @memberof Polygon
      * @returns {boolean} true if the vertices are convex, false if not, null if not computable
      */
     isConvex() {
@@ -291,20 +260,16 @@ import pool from "./../system/pooling.js";
 
         let flag = 0,
             vertices = this.points,
-            n = vertices.length,
-            i,
-            j,
-            k,
-            z;
+            n = vertices.length;
 
         if (n < 3) {
             return null;
         }
 
-        for (i = 0; i < n; i++) {
-            j = (i + 1) % n;
-            k = (i + 2) % n;
-            z = (vertices[j].x - vertices[i].x) * (vertices[k].y - vertices[j].y);
+        for (let i = 0; i < n; i++) {
+            let j = (i + 1) % n;
+            let k = (i + 2) % n;
+            let z = (vertices[j].x - vertices[i].x) * (vertices[k].y - vertices[j].y);
             z -= (vertices[j].y - vertices[i].y) * (vertices[k].x - vertices[j].x);
 
             if (z < 0) {
@@ -327,19 +292,13 @@ import pool from "./../system/pooling.js";
 
     /**
      * translate the Polygon by the specified offset
-     * @name translate
-     * @memberof Polygon
-     * @method
-     * @param {number} x - x offset
-     * @param {number} y - y offset
-     * @returns {Polygon} this Polygon
-     */
-    /**
-     * translate the Polygon by the specified vector
-     * @name translate
-     * @memberof Polygon
-     * @param {Vector2d} v - vector offset
+     * @param {number|Vector2d} x -  x offset or a vector point to translate by
+     * @param {number} [y] - y offset
      * @returns {Polygon} Reference to this object for method chaining
+     * @example
+     * polygon.translate(10, 10);
+     * // or
+     * polygon.translate(myVector2d);
      */
     translate() {
         let _x, _y;
@@ -363,17 +322,12 @@ import pool from "./../system/pooling.js";
 
     /**
      * Shifts the Polygon to the given position vector.
-     * @name shift
-     * @memberof Polygon
-     * @method
-     * @param {Vector2d} position
-     */
-    /**
-     * Shifts the Polygon to the given x, y position.
-     * @name shift
-     * @memberof Polygon
-     * @param {number} x
-     * @param {number} y
+     * @param {number|Vector2d} x -  x coordinate or a vector point to shift to
+     * @param {number} [y]
+     * @example
+     * polygon.shift(10, 10);
+     * // or
+     * polygon.shift(myVector2d);
      */
     shift() {
         let _x, _y;
@@ -391,38 +345,33 @@ import pool from "./../system/pooling.js";
         this.updateBounds();
     }
 
-    /**
-     * Returns true if the polygon contains the given point.
-     * (Note: it is highly recommended to first do a hit test on the corresponding <br>
-     *  bounding rect, as the function can be highly consuming with complex shapes)
-     * @name contains
-     * @memberof Polygon
-     * @method
-     * @param {Vector2d} point
-     * @returns {boolean} true if contains
-     */
-
     /**
      * Returns true if the polygon contains the given point. <br>
      * (Note: it is highly recommended to first do a hit test on the corresponding <br>
      *  bounding rect, as the function can be highly consuming with complex shapes)
-     * @name contains
-     * @memberof Polygon
-     * @param  {number} x -  x coordinate
-     * @param  {number} y -  y coordinate
-     * @returns {boolean} true if contains
+     * @param {number|Vector2d} x -  x coordinate or a vector point to check
+     * @param {number} [y] - y coordinate
+     * @returns {boolean} True if the polygon contain the point, otherwise false
+     * @example
+     * if (polygon.contains(10, 10)) {
+     *   // do something
+     * }
+     * // or
+     * if (polygon.contains(myVector2d)) {
+     *   // do something
+     * }
      */
     contains() {
         let _x, _y;
 
         if (arguments.length === 2) {
-          // x, y
-          _x = arguments[0];
-          _y = arguments[1];
+            // x, y
+            _x = arguments[0];
+            _y = arguments[1];
         } else {
-          // vector
-          _x = arguments[0].x;
-          _y = arguments[0].y;
+            // vector
+            _x = arguments[0].x;
+            _y = arguments[0].y;
         }
 
         let intersects = false;
@@ -433,7 +382,7 @@ import pool from "./../system/pooling.js";
         //http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
         for (let i = 0, j = len - 1; i < len; j = i++) {
             const iy = points[i].y + posy, ix = points[i].x + posx,
-                  jy = points[j].y + posy, jx = points[j].x + posx;
+                jy = points[j].y + posy, jx = points[j].x + posx;
             if (((iy > _y) !== (jy > _y)) && (_x < (jx - ix) * (_y - iy) / (jy - iy) + ix)) {
                 intersects = !intersects;
             }
@@ -443,8 +392,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * returns the bounding box for this shape, the smallest Rectangle object completely containing this shape.
-     * @name getBounds
-     * @memberof Polygon
      * @returns {Bounds} this shape bounding box Rectangle object
      */
     getBounds() {
@@ -456,8 +403,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * update the bounding box for this shape.
-     * @name updateBounds
-     * @memberof Polygon
      * @returns {Bounds} this shape bounding box Rectangle object
      */
     updateBounds() {
@@ -471,8 +416,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * clone this Polygon
-     * @name clone
-     * @memberof Polygon
      * @returns {Polygon} new Polygon
      */
     clone() {

package/src/geometries/rectangle.js

@@ -6,7 +6,7 @@ import Polygon from "./poly.js";
  * a rectangle Object
  * @augments Polygon
  */
- export default class Rect extends Polygon {
+export default class Rect extends Polygon {
     /**
      * @param {number} x - position of the Rectangle
      * @param {number} y - position of the Rectangle
@@ -31,8 +31,6 @@ import Polygon from "./poly.js";
 
     /**
      * set new value to the rectangle shape
-     * @name setShape
-     * @memberof Rect
      * @param {number} x - position of the Rectangle
      * @param {number} y - position of the Rectangle
      * @param {number|Vector2d[]} w - width of the rectangle, or an array of vector defining the rectangle
@@ -59,10 +57,7 @@ import Polygon from "./poly.js";
 
     /**
      * left coordinate of the Rectangle
-     * @public
      * @type {number}
-     * @name left
-     * @memberof Rect
      */
     get left() {
         return this.pos.x;
@@ -70,10 +65,7 @@ import Polygon from "./poly.js";
 
     /**
      * right coordinate of the Rectangle
-     * @public
      * @type {number}
-     * @name right
-     * @memberof Rect
      */
     get right() {
         let w = this.width;
@@ -82,10 +74,7 @@ import Polygon from "./poly.js";
 
     /**
      * top coordinate of the Rectangle
-     * @public
      * @type {number}
-     * @name top
-     * @memberof Rect
      */
     get top() {
         return this.pos.y;
@@ -93,10 +82,7 @@ import Polygon from "./poly.js";
 
     /**
      * bottom coordinate of the Rectangle
-     * @public
      * @type {number}
-     * @name bottom
-     * @memberof Rect
      */
     get bottom() {
         let h = this.height;
@@ -105,10 +91,7 @@ import Polygon from "./poly.js";
 
     /**
      * width of the Rectangle
-     * @public
      * @type {number}
-     * @name width
-     * @memberof Rect
      */
     get width() {
         return this.points[2].x;
@@ -121,10 +104,7 @@ import Polygon from "./poly.js";
 
     /**
      * height of the Rectangle
-     * @public
      * @type {number}
-     * @name height
-     * @memberof Rect
      */
     get height() {
         return this.points[2].y;
@@ -137,10 +117,7 @@ import Polygon from "./poly.js";
 
     /**
      * absolute center of this rectangle on the horizontal axis
-     * @public
      * @type {number}
-     * @name centerX
-     * @memberof Rect
      */
     get centerX() {
         if (isFinite(this.width)) {
@@ -157,10 +134,7 @@ import Polygon from "./poly.js";
 
     /**
      * absolute center of this rectangle on the vertical axis
-     * @public
      * @type {number}
-     * @name centerY
-     * @memberof Rect
      */
     get centerY() {
         if (isFinite(this.height)) {
@@ -177,8 +151,6 @@ import Polygon from "./poly.js";
 
     /**
      * center the rectangle position around the given coordinates
-     * @name centerOn
-     * @memberof Rect
      * @param {number} x - the x coordinate around which to center this rectangle
      * @param {number} y - the y coordinate around which to center this rectangle
      * @returns {Rect} this rectangle
@@ -191,8 +163,6 @@ import Polygon from "./poly.js";
 
     /**
      * resize the rectangle
-     * @name resize
-     * @memberof Rect
      * @param {number} w - new width of the rectangle
      * @param {number} h - new height of the rectangle
      * @returns {Rect} this rectangle
@@ -205,8 +175,6 @@ import Polygon from "./poly.js";
 
     /**
      * scale the rectangle
-     * @name scale
-     * @memberof Rect
      * @param {number} x - a number representing the abscissa of the scaling vector.
      * @param {number} [y=x] - a number representing the ordinate of the scaling vector.
      * @returns {Rect} this rectangle
@@ -219,8 +187,6 @@ import Polygon from "./poly.js";
 
     /**
      * clone this rectangle
-     * @name clone
-     * @memberof Rect
      * @returns {Rect} new rectangle
      */
     clone() {
@@ -229,8 +195,6 @@ import Polygon from "./poly.js";
 
     /**
      * copy the position and size of the given rectangle into this one
-     * @name copy
-     * @memberof Rect
      * @param {Rect} rect - Source rectangle
      * @returns {Rect} new rectangle
      */
@@ -240,8 +204,6 @@ import Polygon from "./poly.js";
 
     /**
      * merge this rectangle with another one
-     * @name union
-     * @memberof Rect
      * @param {Rect} rect - other rectangle to union with
      * @returns {Rect} the union(ed) rectangle
      */
@@ -261,8 +223,6 @@ import Polygon from "./poly.js";
 
     /**
      * check if this rectangle is intersecting with the specified one
-     * @name overlaps
-     * @memberof Rect
      * @param {Rect} rect
      * @returns {boolean} true if overlaps
      */
@@ -276,63 +236,53 @@ import Polygon from "./poly.js";
     }
 
     /**
-     * Returns true if the rectangle contains the given rectangle
-     * @name contains
-     * @memberof Rect
-     * @method
-     * @param {Rect} rect
-     * @returns {boolean} true if contains
-     */
-
-    /**
-     * Returns true if the rectangle contains the given point
-     * @name contains
-     * @memberof Rect
-     * @method
-     * @param  {number} x -  x coordinate
-     * @param  {number} y -  y coordinate
-     * @returns {boolean} true if contains
-     */
-
-    /**
-     * Returns true if the rectangle contains the given point
-     * @name contains
-     * @memberof Rect
-     * @param {Vector2d} point
-     * @returns {boolean} true if contains
+     * Returns true if the rectangle contains the given point or rectangle
+     * @param {number|Vector2d|Rect} x -  x coordinate or a vector point, or a rectangle to test
+     * @param {number} [y] - y coordinate
+     * @returns {boolean} True if the rectangle contain the given point or rectangle, otherwise false
+     * @example
+     * if (rect.contains(10, 10)) {
+     *   // do something
+     * }
+     * // or
+     * if (rect.contains(myVector2d)) {
+     *   // do something
+     * }
+     * if (rect.contains(myRect)) {
+     *   // do something
+     * }
      */
     contains() {
         let arg0 = arguments[0];
         let _x1, _x2, _y1, _y2;
         if (arguments.length === 2) {
-             // x, y
-             _x1 = _x2 = arg0;
-             _y1 = _y2 = arguments[1];
-         } else {
-             if (arg0 instanceof Rect) {
-                 // me.Rect
-                 _x1 = arg0.left;
-                 _x2 = arg0.right;
-                 _y1 = arg0.top;
-                 _y2 = arg0.bottom;
-             } else {
-                 // vector
-                 _x1 = _x2 = arg0.x;
-                 _y1 = _y2 = arg0.y;
-             }
-         }
-         return (
-             _x1 >= this.left &&
+            // x, y
+            _x1 = _x2 = arg0;
+            _y1 = _y2 = arguments[1];
+        } else {
+            // only Rect based objects define a top and bottom properties
+            if (typeof arg0.bottom === "number") {
+                // me.Rect
+                _x1 = arg0.left;
+                _x2 = arg0.right;
+                _y1 = arg0.top;
+                _y2 = arg0.bottom;
+            } else {
+                // vector
+                _x1 = _x2 = arg0.x;
+                _y1 = _y2 = arg0.y;
+            }
+        }
+        return (
+            _x1 >= this.left &&
              _x2 <= this.right &&
              _y1 >= this.top &&
              _y2 <= this.bottom
-         );
+        );
     }
 
     /**
      * check if this rectangle is identical to the specified one
-     * @name equals
-     * @memberof Rect
      * @param {Rect} rect
      * @returns {boolean} true if equals
      */
@@ -347,8 +297,6 @@ import Polygon from "./poly.js";
 
     /**
      * determines whether all coordinates of this rectangle are finite numbers.
-     * @name isFinite
-     * @memberof Rect
      * @returns {boolean} false if all coordinates are positive or negative Infinity or NaN; otherwise, true.
      */
     isFinite() {
@@ -357,8 +305,6 @@ import Polygon from "./poly.js";
 
     /**
      * Returns a polygon whose edges are the same as this box.
-     * @name toPolygon
-     * @memberof Rect
      * @returns {Polygon} a new Polygon that represents this rectangle.
      */
     toPolygon() {