melonjs 15.2.1 → 15.4.0

package/src/camera/camera2d.js

@@ -23,7 +23,7 @@ let targetV = new Vector2d();
  * a 2D orthographic camera
  * @augments Renderable
  */
- export default class Camera2d extends Renderable {
+export default class Camera2d extends Renderable {
     /**
      * @param {number} minX - start x offset
      * @param {number} minY - start y offset
@@ -207,8 +207,8 @@ let targetV = new Vector2d();
      * reset the camera position to specified coordinates
      * @name reset
      * @memberof Camera2d
-     * @param {number} [x=0]
-     * @param {number} [y=0]
+     * @param {number} [x=0] - initial position of the camera on the x axis
+     * @param {number} [y=0] - initial position of the camera on the y axis
      */
     reset(x = 0, y = 0) {
         // reset the initial camera position to 0,0
@@ -365,8 +365,8 @@ let targetV = new Vector2d();
      * @name move
      * @memberof Camera2d
      * @see Camera2d.focusOn
-     * @param {number} x
-     * @param {number} y
+     * @param {number} x - horizontal offset
+     * @param {number} y - vertical offset
      * @example
      * // Move the camera up by four pixels
      * me.game.viewport.move(0, -4);
@@ -590,7 +590,7 @@ let targetV = new Vector2d();
      * @memberof Camera2d
      * @param {Renderable|Entity|Sprite|NineSliceSprite} obj - to be checked against
      * @param {boolean} [floating = obj.floating] - if visibility check should be done against screen coordinates
-     * @returns {boolean}
+     * @returns {boolean} true if within the viewport
      */
     isVisible(obj, floating = obj.floating) {
         if (floating === true || obj.floating === true) {
@@ -606,10 +606,9 @@ let targetV = new Vector2d();
      * convert the given "local" (screen) coordinates into world coordinates
      * @name localToWorld
      * @memberof Camera2d
-     * @param {number} x
-     * @param {number} y
-     * @param {number} [v] - an optional vector object where to set the
-     * converted value
+     * @param {number} x - the x coordinate of the local point to be converted
+     * @param {number} y - the y coordinate of the local point to be converted
+     * @param {number} [v] - an optional vector object where to set the converted value
      * @returns {Vector2d}
      */
     localToWorld(x, y, v) {
@@ -628,9 +627,8 @@ let targetV = new Vector2d();
      * @memberof Camera2d
      * @param {number} x
      * @param {number} y
-     * @param {number} [v] - an optional vector object where to set the
-     * converted value
-     * @returns {Vector2d}
+     * @param {number} [v] - an optional vector object where to set the converted value
+     * @returns {Vector2d} a vector with the converted local coordinates
      */
     worldToLocal(x, y, v) {
         // TODO memoization for one set of coords (multitouch)

package/src/entity/entity.js

@@ -10,7 +10,7 @@ import Body from "./../physics/body.js";
  * @augments Renderable
  * @see Renderable
  */
- export default class Entity extends Renderable {
+export default class Entity extends Renderable {
     /**
      * @param {number} x - the x coordinates of the entity object
      * @param {number} y - the y coordinates of the entity object
@@ -180,7 +180,7 @@ import Body from "./../physics/body.js";
         }
 
         if (absolute === true) {
-            var absPos = this.getAbsolutePosition();
+            let absPos = this.getAbsolutePosition();
             bounds.centerOn(absPos.x + bounds.x + bounds.width / 2,  absPos.y + bounds.y + bounds.height / 2);
         }
 
@@ -192,7 +192,6 @@ import Body from "./../physics/body.js";
      * @ignore
      * @name onBodyUpdate
      * @memberof Entity
-     * @param {Body} body - the body whose bounds to update
      */
     onBodyUpdate() {
         this.updateBounds();

package/src/geometries/ellipse.js

@@ -4,7 +4,7 @@ import pool from "./../system/pooling.js";
  * @classdesc
  * an ellipse Object
  */
- export default class Ellipse {
+export default class Ellipse {
     /**
      * @param {number} x - the center x coordinate of the ellipse
      * @param {number} y - the center y coordinate of the ellipse
@@ -16,8 +16,6 @@ import pool from "./../system/pooling.js";
          * the center coordinates of the ellipse
          * @public
          * @type {Vector2d}
-         * @name pos
-         * @memberof Ellipse
          */
         this.pos = pool.pull("Vector2d");
 
@@ -31,8 +29,6 @@ import pool from "./../system/pooling.js";
          * Maximum radius of the ellipse
          * @public
          * @type {number}
-         * @name radius
-         * @memberof Ellipse
          */
         this.radius = NaN;
 
@@ -40,8 +36,6 @@ import pool from "./../system/pooling.js";
          * Pre-scaled radius vector for ellipse
          * @public
          * @type {Vector2d}
-         * @name radiusV
-         * @memberof Ellipse
          */
         this.radiusV = pool.pull("Vector2d");
 
@@ -49,8 +43,6 @@ import pool from "./../system/pooling.js";
          * Radius squared, for pythagorean theorom
          * @public
          * @type {Vector2d}
-         * @name radiusSq
-         * @memberof Ellipse
          */
         this.radiusSq = pool.pull("Vector2d");
 
@@ -58,8 +50,6 @@ import pool from "./../system/pooling.js";
          * x/y scaling ratio for ellipse
          * @public
          * @type {Vector2d}
-         * @name ratio
-         * @memberof Ellipse
          */
         this.ratio = pool.pull("Vector2d");
 
@@ -75,8 +65,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * set new value to the Ellipse shape
-     * @name setShape
-     * @memberof Ellipse
      * @param {number} x - the center x coordinate of the ellipse
      * @param {number} y - the center y coordinate of the ellipse
      * @param {number} w - width (diameter) of the ellipse
@@ -104,8 +92,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * Rotate this Ellipse (counter-clockwise) by the specified angle (in radians).
-     * @name rotate
-     * @memberof Ellipse
      * @param {number} angle - The angle to rotate (in radians)
      * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around
      * @returns {Ellipse} Reference to this object for method chaining
@@ -120,10 +106,8 @@ import pool from "./../system/pooling.js";
 
     /**
      * Scale this Ellipse by the specified scalar.
-     * @name scale
-     * @memberof Ellipse
-     * @param {number} x
-     * @param {number} [y=x]
+     * @param {number} x - the scale factor along the x-axis
+     * @param {number} [y=x] - the scale factor along the y-axis
      * @returns {Ellipse} Reference to this object for method chaining
      */
     scale(x, y = x) {
@@ -137,8 +121,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * Scale this Ellipse by the specified vector.
-     * @name scale
-     * @memberof Ellipse
      * @param {Vector2d} v
      * @returns {Ellipse} Reference to this object for method chaining
      */
@@ -148,8 +130,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * apply the given transformation matrix to this ellipse
-     * @name transform
-     * @memberof Ellipse
      * @param {Matrix2d} matrix - the transformation matrix
      * @returns {Polygon} Reference to this object for method chaining
      */
@@ -160,19 +140,13 @@ import pool from "./../system/pooling.js";
 
     /**
      * translate the circle/ellipse by the specified offset
-     * @name translate
-     * @memberof Ellipse
-     * @method
-     * @param {number} x - x offset
-     * @param {number} y - y offset
-     * @returns {Ellipse} this ellipse
-     */
-    /**
-     * translate the circle/ellipse by the specified vector
-     * @name translate
-     * @memberof Ellipse
-     * @param {Vector2d} v - vector offset
+     * @param {number|Vector2d} x -  x coordinate or a vector point to translate by
+     * @param {number} [y] - y offset
      * @returns {Ellipse} this ellipse
+     * @example
+     * ellipse.translate(10, 10);
+     * // or
+     * ellipse.translate(myVector2d);
      */
     translate() {
         let _x, _y;
@@ -196,32 +170,29 @@ import pool from "./../system/pooling.js";
 
     /**
      * check if this circle/ellipse contains the specified point
-     * @name contains
-     * @method
-     * @memberof Ellipse
-     * @param {Vector2d} point
-     * @returns {boolean} true if contains
-     */
-
-    /**
-     * check if this circle/ellipse contains the specified point
-     * @name contains
-     * @memberof Ellipse
-     * @param  {number} x -  x coordinate
-     * @param  {number} y -  y coordinate
+     * @param {number|Vector2d} x -  x coordinate or a vector point to check
+     * @param {number} [y] -  y coordinate
      * @returns {boolean} true if contains
+     * @example
+     * if (circle.contains(10, 10)) {
+     *   // do something
+     * }
+     * // or
+     * if (circle.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;
         }
 
         // Make position relative to object center point.
@@ -236,8 +207,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 Ellipse
      * @returns {Bounds} this shape bounding box Rectangle object
      */
     getBounds() {
@@ -249,8 +218,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * clone this Ellipse
-     * @name clone
-     * @memberof Ellipse
      * @returns {Ellipse} new Ellipse
      */
     clone() {

package/src/geometries/line.js

@@ -10,36 +10,33 @@ import Polygon from "./poly.js";
  * @param {Vector2d[]} points - array of vectors defining the Line
  */
 
- export default class Line extends Polygon {
+export default class Line extends Polygon {
 
     /**
      * Returns true if the Line contains the given point
-     * @name contains
-     * @memberof Line
-     * @method
-     * @param {Vector2d} point
-     * @returns {boolean} true if contains
-     */
-
-    /**
-     * Returns true if the Line contains the given point
-     * @name contains
-     * @memberof Line
-     * @param  {number} x -  x coordinate
-     * @param  {number} y -  y coordinate
+     * @param {number|Vector2d} x -  x coordinate or a vector point to check
+     * @param {number} [y] -  y coordinate
      * @returns {boolean} true if contains
+     * @example
+     * if (line.contains(10, 10)) {
+     *   // do something
+     * }
+     * // or
+     * if (line.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;
         }
 
         // translate the given coordinates,
@@ -56,8 +53,6 @@ import Polygon from "./poly.js";
     /**
      * Computes the calculated collision edges and normals.
      * This **must** be called if the `points` array, `angle`, or `offset` is modified manually.
-     * @name recalc
-     * @memberof Line
      * @returns {Line} this instance for objecf chaining
      */
     recalc() {
@@ -91,8 +86,6 @@ import Polygon from "./poly.js";
 
     /**
      * clone this line segment
-     * @name clone
-     * @memberof Line
      * @returns {Line} new Line
      */
     clone() {

package/src/geometries/path2d.js

@@ -6,7 +6,7 @@ import earcut from "earcut";
  * @classdesc
  * a simplified path2d implementation, supporting only one path
  */
- export default class Path2D {
+export default class Path2D {
     constructor() {
         /**
          * the points defining the current path
@@ -43,34 +43,35 @@ import earcut from "earcut";
      */
     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;
         }
@@ -84,7 +85,7 @@ import earcut from "earcut";
      * @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));
     }
 
     /**
@@ -135,11 +136,12 @@ import earcut from "earcut";
         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)));
     }
@@ -230,6 +232,7 @@ import earcut from "earcut";
         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);
@@ -240,7 +243,7 @@ import earcut from "earcut";
             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;
         }
     }
 
@@ -270,7 +273,7 @@ import earcut from "earcut";
      * @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/src/geometries/point.js

@@ -2,18 +2,18 @@
  * @classdesc
  * represents a point in a 2d space
  */
- export default class Point {
+export default 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;
@@ -37,20 +37,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