melonjs 15.3.0 → 15.4.1

package/dist/melonjs.mjs/geometries/path2d.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v15.3.0
+ * melonJS Game Engine - v15.4.1
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -13,7 +13,7 @@ import earcut from '../node_modules/earcut/src/earcut.js';
  * @classdesc
  * a simplified path2d implementation, supporting only one path
  */
- class Path2D {
+class Path2D {
     constructor() {
         /**
          * the points defining the current path
@@ -50,34 +50,35 @@ import earcut from '../node_modules/earcut/src/earcut.js';
      */
     closePath() {
         let points = this.points;
-        if (points.length > 1 && !points[points.length-1].equals(points[0])) {
-            points.push(pool.pull("Point", points[0].x, points[0].y));
+        let firstPoint = points[0];
+        if (points.length > 1 && !points[points.length-1].equals(firstPoint)) {
+            points.push(pool.pull("Point", firstPoint.x, firstPoint.y));
         }
     }
 
     /**
      * triangulate the shape defined by this path into an array of triangles
-     * @returns {Point[]}
+     * @returns {Point[]} an array of vertices representing the triangulated path or shape
      */
     triangulatePath() {
-        let i = 0;
         let points = this.points;
         let vertices = this.vertices;
         let indices = earcut(points.flatMap(p => [p.x, p.y]));
+        let indicesLength = indices.length;
 
         // pre-allocate vertices if necessary
-        while (vertices.length < indices.length) {
+        while (vertices.length < indicesLength) {
             vertices.push(pool.pull("Point"));
         }
 
         // calculate all vertices
-        for (i = 0; i < indices.length; i++ ) {
+        for (let i = 0; i < indicesLength; i++ ) {
             let point = points[indices[i]];
             vertices[i].set(point.x, point.y);
         }
 
         // recycle overhead from a previous triangulation
-        while (vertices.length > indices.length) {
+        while (vertices.length > indicesLength) {
             pool.push(vertices[vertices.length-1]);
             vertices.length -= 1;
         }
@@ -91,7 +92,7 @@ import earcut from '../node_modules/earcut/src/earcut.js';
      * @param {number} y - the y-axis (vertical) coordinate of the point.
      */
     moveTo(x, y) {
-      this.points.push(pool.pull("Point", x, y));
+        this.points.push(pool.pull("Point", x, y));
     }
 
     /**
@@ -142,11 +143,12 @@ import earcut from '../node_modules/earcut/src/earcut.js';
         const length = diff * radius;
         const nr_of_interpolation_points = length / this.arcResolution;
         const dangle = diff / nr_of_interpolation_points;
+        const angleStep = dangle * direction;
 
         let angle = startAngle;
         for (let j = 0; j < nr_of_interpolation_points; j++) {
             points.push(pool.pull("Point", x + radius * Math.cos(angle), y + radius * Math.sin(angle)));
-            angle += direction * dangle;
+            angle += angleStep;
         }
         points.push(pool.pull("Point", x + radius * Math.cos(endAngle), y + radius * Math.sin(endAngle)));
     }
@@ -237,6 +239,7 @@ import earcut from '../node_modules/earcut/src/earcut.js';
         const length = (diff * radiusX + diff * radiusY) / 2;
         const nr_of_interpolation_points = length / this.arcResolution;
         const dangle = diff / nr_of_interpolation_points;
+        const angleStep = dangle * direction;
 
         let angle = startAngle;
         const cos_rotation = Math.cos(rotation);
@@ -247,7 +250,7 @@ import earcut from '../node_modules/earcut/src/earcut.js';
             const _x2 = x + _x1 * cos_rotation - _y1 * sin_rotation;
             const _y2 = y + _x1 * sin_rotation + _y1 * cos_rotation;
             points.push(pool.pull("Point", _x2, _y2));
-            angle += direction * dangle;
+            angle += angleStep;
         }
     }
 
@@ -277,7 +280,7 @@ import earcut from '../node_modules/earcut/src/earcut.js';
      * @param {number} height - the rectangle's height. Positive values are down, and negative are up.
      * @param {number} radius - the arc's radius to draw the borders. Must be positive.
      */
-     roundRect(x, y, width, height, radius) {
+    roundRect(x, y, width, height, radius) {
         this.moveTo(x + radius, y);
         this.lineTo(x + width - radius, y);
         this.arcTo(x + width, y, x + width, y + radius, radius);

package/dist/melonjs.mjs/geometries/point.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v15.3.0
+ * melonJS Game Engine - v15.4.1
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -9,18 +9,18 @@
  * @classdesc
  * represents a point in a 2d space
  */
- class Point {
+class Point {
     constructor(x = 0, y = 0) {
         /**
          * the position of the point on the horizontal axis
-         * @type {Number}
+         * @type {number}
          * @default 0
          */
         this.x = x;
 
         /**
          * the position of the point on the vertical axis
-         * @type {Number}
+         * @type {number}
          * @default 0
          */
         this.y = y;
@@ -44,20 +44,12 @@
     }
 
     /**
-     * return true if the two points are the same
-     * @name equals
-     * @memberof Point
-     * @method
-     * @param {Point} point
+     * return true if this point is equal to the given point
+     * @param {number|Point|Vector2d} x
+     * @param {number} [y]
      * @returns {boolean}
      */
-    /**
-     * return true if this point is equal to the given values
-     * @param {number} x
-     * @param {number} y
-     * @returns {boolean}
-     */
-     equals() {
+    equals() {
         let _x, _y;
         if (arguments.length === 2) {
             // x, y

package/dist/melonjs.mjs/geometries/poly.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v15.3.0
+ * melonJS Game Engine - v15.4.1
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -19,7 +19,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.
  */
- class Polygon {
+class Polygon {
     /**
      * @param {number} x - origin point of the Polygon
      * @param {number} y - origin point of the Polygon
@@ -28,10 +28,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");
 
@@ -39,18 +36,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 = [];
 
@@ -88,8 +80,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
@@ -103,8 +93,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
      */
@@ -121,7 +109,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 {
@@ -142,8 +130,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
      */
@@ -160,8 +146,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() {
@@ -169,9 +153,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() {
@@ -180,8 +162,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
@@ -201,8 +181,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
@@ -220,8 +198,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
      */
@@ -232,12 +208,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;
@@ -251,7 +224,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");
             }
@@ -275,8 +248,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() {
@@ -288,8 +259,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() {
@@ -298,20 +267,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) {
@@ -334,19 +299,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;
@@ -370,17 +329,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;
@@ -398,38 +352,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;
@@ -440,7 +389,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;
             }
@@ -450,8 +399,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() {
@@ -463,8 +410,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() {
@@ -478,8 +423,6 @@ import pool from '../system/pooling.js';
 
     /**
      * clone this Polygon
-     * @name clone
-     * @memberof Polygon
      * @returns {Polygon} new Polygon
      */
     clone() {