melonjs 14.3.0 → 14.5.0

package/dist/types/application/application.d.ts

@@ -10,7 +10,7 @@ export default class Application {
      * @param {number} height - The height of the canvas viewport
      * @param {object} [options] - The optional video/renderer parameters.<br> (see Renderer(s) documentation for further specific options)
      * @param {string|HTMLElement} [options.parent=document.body] - the DOM parent element to hold the canvas in the HTML file
-     * @param {number|Renderer} [options.renderer=video.AUTO] - renderer to use (me.video.CANVAS, me.video.WEBGL, me.video.AUTO), or a custom renderer class
+     * @param {number|Renderer} [options.renderer=AUTO] - renderer to use (CANVAS, WEBGL, AUTO), or a custom renderer class
      * @param {number|string} [options.scale=1.0] - enable scaling of the canvas ('auto' for automatic scaling)
      * @param {string} [options.scaleMethod="fit"] - screen scaling modes ('fit','fill-min','fill-max','flex','flex-width','flex-height','stretch')
      * @param {boolean} [options.preferWebGL1=false] - if true the renderer will only use WebGL 1
@@ -19,6 +19,10 @@ export default class Application {
      * @param {boolean} [options.antiAlias=false] - whether to enable or not video scaling interpolation
      * @param {boolean} [options.consoleHeader=true] - whether to display melonJS version and basic device information in the console
      * @throws Will throw an exception if it fails to instantiate a renderer
+     * @example
+     * var my game = new Application(640, 480, {renderer: me.video.AUTO}) {
+     *     ....
+     * }
      */
     constructor(width: number, height: number, options?: {
         parent?: string | HTMLElement | undefined;

package/dist/types/application/resize.d.ts

@@ -1,5 +1,6 @@
 /**
  * callback for window resize event
+ * @private
  * @param {Application} game - the game application instance triggering the resize
  */
 export function onresize(game: Application): void;

package/dist/types/const.d.ts

@@ -0,0 +1,21 @@
+/**
+ * constant to select the HTML5 Canvas renderer
+ * @type {number}
+ * @static
+ * @see Application
+ */
+export const CANVAS: number;
+/**
+ * constant to select select the WebGL renderer
+ * @type {number}
+ * @static
+ * @see Application
+ */
+export const WEBGL: number;
+/**
+ * constant to auto-select the renderer (Attempt WebGL first, with fallback to Canvas)
+ * @static
+ * @type (number)
+ * @see Application
+ */
+export const AUTO: any;

package/dist/types/entity/entity.d.ts

@@ -78,13 +78,13 @@ export default class Entity extends Renderable {
     /** @ignore */
     update(dt: any): boolean;
     /**
-     * update the bounds position when the body is modified
+     * update the bounds when the body is modified
      * @ignore
      * @name onBodyUpdate
      * @memberof Entity
      * @param {Body} body - the body whose bounds to update
      */
-    onBodyUpdate(body: Body): void;
+    onBodyUpdate(): void;
     preDraw(renderer: any): void;
     /**
      * onDeactivateEvent Notification function<br>

package/dist/types/geometries/path2d.d.ts

@@ -5,55 +5,39 @@
 export default class Path2D {
     /**
      * the points defining the current path
-     * @public
-     * @type {Vector2d[]}
-     * @name points
-     * @memberof Path2D#
+     * @type {Point[]}
      */
-    public points: Vector2d[];
+    points: Point[];
     /**
      * space between interpolated points for quadratic and bezier curve approx. in pixels.
-     * @public
      * @type {number}
-     * @name arcResolution
      * @default 5
-     * @memberof Path2D#
      */
-    public arcResolution: number;
+    arcResolution: number;
     vertices: any[];
     /**
      * begin a new path
-     * @name beginPath
-     * @memberof Path2D
      */
     beginPath(): void;
     /**
      * causes the point of the pen to move back to the start of the current path.
      * It tries to draw a straight line from the current point to the start.
      * If the shape has already been closed or has only one point, this function does nothing.
-     * @name closePath
-     * @memberof Path2D
      */
     closePath(): void;
     /**
      * triangulate the shape defined by this path into an array of triangles
-     * @name triangulatePath
-     * @memberof Path2D
-     * @returns {Vector2d[]}
+     * @returns {Point[]}
      */
-    triangulatePath(): Vector2d[];
+    triangulatePath(): Point[];
     /**
      * moves the starting point of the current path to the (x, y) coordinates.
-     * @name moveTo
-     * @memberof Path2D
      * @param {number} x - the x-axis (horizontal) coordinate of the point.
      * @param {number} y - the y-axis (vertical) coordinate of the point.
      */
     moveTo(x: number, y: number): void;
     /**
      * connects the last point in the current patch to the (x, y) coordinates with a straight line.
-     * @name lineTo
-     * @memberof Path2D
      * @param {number} x - the x-axis coordinate of the line's end point.
      * @param {number} y - the y-axis coordinate of the line's end point.
      */
@@ -61,8 +45,6 @@ export default class Path2D {
     /**
      * adds an arc to the current path which is centered at (x, y) position with the given radius,
      * starting at startAngle and ending at endAngle going in the given direction by counterclockwise (defaulting to clockwise).
-     * @name arc
-     * @memberof Path2D
      * @param {number} x - the horizontal coordinate of the arc's center.
      * @param {number} y - the vertical coordinate of the arc's center.
      * @param {number} radius - the arc's radius. Must be positive.
@@ -73,8 +55,6 @@ export default class Path2D {
     arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean | undefined): void;
     /**
      * adds a circular arc to the path with the given control points and radius, connected to the previous point by a straight line.
-     * @name arcTo
-     * @memberof Path2D
      * @param {number} x1 - the x-axis coordinate of the first control point.
      * @param {number} y1 - the y-axis coordinate of the first control point.
      * @param {number} x2 - the x-axis coordinate of the second control point.
@@ -85,8 +65,6 @@ export default class Path2D {
     /**
      * adds an elliptical arc to the path which is centered at (x, y) position with the radii radiusX and radiusY
      * starting at startAngle and ending at endAngle going in the given direction by counterclockwise.
-     * @name ellipse
-     * @memberof Path2D
      * @param {number} x - the x-axis (horizontal) coordinate of the ellipse's center.
      * @param {number} y - the  y-axis (vertical) coordinate of the ellipse's center.
      * @param {number} radiusX - the ellipse's major-axis radius. Must be non-negative.
@@ -99,8 +77,6 @@ export default class Path2D {
     ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean | undefined): void;
     /**
      * creates a path for a rectangle at position (x, y) with a size that is determined by width and height.
-     * @name rect
-     * @memberof Path2D
      * @param {number} x - the x-axis coordinate of the rectangle's starting point.
      * @param {number} y - the y-axis coordinate of the rectangle's starting point.
      * @param {number} width - the rectangle's width. Positive values are to the right, and negative to the left.
@@ -109,8 +85,6 @@ export default class Path2D {
     rect(x: number, y: number, width: number, height: number): void;
     /**
      * adds an rounded rectangle to the current path.
-     * @name roundRect
-     * @memberof Path2D
      * @param {number} x - the x-axis coordinate of the rectangle's starting point.
      * @param {number} y - the y-axis coordinate of the rectangle's starting point.
      * @param {number} width - the rectangle's width. Positive values are to the right, and negative to the left.

package/dist/types/geometries/point.d.ts

@@ -6,18 +6,16 @@ export default class Point {
     constructor(x?: number, y?: number);
     /**
      * the position of the point on the horizontal axis
-     * @public
      * @type {Number}
      * @default 0
      */
-    public x: number;
+    x: number;
     /**
      * the position of the point on the vertical axis
-     * @public
      * @type {Number}
      * @default 0
      */
-    public y: number;
+    y: number;
     /** @ignore */
     onResetEvent(x?: number, y?: number): void;
     /**
@@ -37,8 +35,6 @@ export default class Point {
      */
     /**
      * return true if this point is equal to the given values
-     * @name equals
-     * @memberof Point
      * @param {number} x
      * @param {number} y
      * @returns {boolean}
@@ -46,7 +42,6 @@ export default class Point {
     equals(...args: any[]): boolean;
     /**
      * clone this Point
-     * @name clone
      * @returns {Point} new Point
      */
     clone(): Point;

package/dist/types/geometries/poly.d.ts

@@ -205,7 +205,6 @@ export default class Polygon {
     _bounds: object | undefined;
     /**
      * update the bounding box for this shape.
-     * @ignore
      * @name updateBounds
      * @memberof Polygon
      * @returns {Bounds} this shape bounding box Rectangle object

package/dist/types/index.d.ts

@@ -16,6 +16,7 @@ export function boot(): void;
  */
 export const version: string;
 export * from "./lang/deprecated.js";
+export * from "./const.js";
 /**
  * a flag indicating that melonJS is fully initialized
  * @type {boolean}
@@ -35,7 +36,7 @@ import * as audio from "./audio/audio.js";
 import collision from "./physics/collision.js";
 import * as device from "./system/device.js";
 import * as event from "./system/event.js";
-import loader from "./loader/loader.js";
+import * as loader from "./loader/loader.js";
 import level from "./level/level.js";
 import * as input from "./input/input.js";
 import * as Math from "./math/math.js";
@@ -63,7 +64,7 @@ import RoundRect from "./geometries/roundrect.js";
 import Tween from "./tweens/tween.js";
 import QuadTree from "./physics/quadtree.js";
 import GLShader from "./video/webgl/glshader.js";
-import WebGLCompositor from "./video/webgl/webgl_compositor.js";
+import WebGLCompositor from "./video/webgl/compositors/webgl_compositor.js";
 import Renderer from "./video/renderer.js";
 import WebGLRenderer from "./video/webgl/webgl_renderer.js";
 import CanvasRenderer from "./video/canvas/canvas_renderer.js";

package/dist/types/lang/console.d.ts

@@ -0,0 +1,7 @@
+/**
+ * display a deprecation warning in the console
+ * @param {string} deprecated - deprecated class,function or property name
+ * @param {string} replacement - the replacement class, function, or property name
+ * @param {string} version - the version since when the lass,function or property is deprecated
+ */
+export function warning(deprecated: string, replacement: string, version: string): void;

package/dist/types/lang/deprecated.d.ts

@@ -1,11 +1,3 @@
-/**
- * display a deprecation warning in the console
- * @ignore
- * @param {string} deprecated - deprecated class,function or property name
- * @param {string} replacement - the replacement class, function, or property name
- * @param {string} version - the version since when the lass,function or property is deprecated
- */
-export function warning(deprecated: string, replacement: string, version: string): void;
 /**
  * @classdesc
  * Used to make a game entity draggable

package/dist/types/level/tiled/TMXGroup.d.ts

@@ -8,61 +8,40 @@ export default class TMXGroup {
     constructor(map: any, data: any, z: any);
     /**
      * group name
-     * @public
      * @type {string}
-     * @name name
-     * @memberof TMXGroup
      */
-    public name: string;
+    name: string;
     /**
      * group width
-     * @public
      * @type {number}
-     * @name width
-     * @memberof TMXGroup
      */
-    public width: number;
+    width: number;
     /**
      * group height
-     * @public
      * @type {number}
-     * @name height
-     * @memberof TMXGroup
      */
-    public height: number;
+    height: number;
     /**
      * tint color
-     * @public
      * @type {string}
-     * @name tintcolor
-     * @memberof TMXGroup
      */
-    public tintcolor: string;
+    tintcolor: string;
     /**
      * the group class
-     * @public
      * @type {string}
-     * @name class
-     * @memberof TMXGroup
      */
-    public class: string;
+    class: string;
     /**
      * group z order
-     * @public
      * @type {number}
-     * @name z
-     * @memberof TMXGroup
      */
-    public z: number;
+    z: number;
     /**
      * group objects list definition
      * @see TMXObject
-     * @public
      * @type {object[]}
-     * @name name
-     * @memberof TMXGroup
      */
-    public objects: object[];
+    objects: object[];
     opacity: number;
     /**
      * reset function

package/dist/types/level/tiled/TMXLayer.d.ts

@@ -18,13 +18,23 @@ export default class TMXLayer extends Renderable {
     tilewidth: any;
     tileheight: any;
     orientation: string;
+    /**
+     * Horizontal layer offset in tiles
+     * @default 0
+     * @type {number}
+     */
+    x: number;
+    /**
+     * Vertical layer offset in tiles
+     * @default 0
+     * @type {number}
+     */
+    y: number;
     /**
      * The Layer corresponding Tilesets
-     * @public
      * @type {TMXTilesetGroup}
-     * @name TMXLayer#tilesets
      */
-    public tilesets: TMXTilesetGroup;
+    tilesets: TMXTilesetGroup;
     tileset: any;
     maxTileSize: {
         width: number;
@@ -32,78 +42,58 @@ export default class TMXLayer extends Renderable {
     };
     /**
      * All animated tilesets in this layer
-     * @ignore
      * @type {TMXTileset[]}
-     * @name TMXLayer#animatedTilesets
      */
     animatedTilesets: TMXTileset[];
     /**
      * Layer contains tileset animations
-     * @public
      * @type {boolean}
-     * @name TMXLayer#isAnimated
      */
-    public isAnimated: boolean;
+    isAnimated: boolean;
     /**
      * the order in which tiles on orthogonal tile layers are rendered.
      * (valid values are "left-down", "left-up", "right-down", "right-up")
-     * @public
      * @type {string}
      * @default "right-down"
-     * @name TMXLayer#renderorder
      */
-    public renderorder: string;
+    renderorder: string;
     /**
      * the layer class
-     * @public
      * @type {string}
-     * @name class
-     * @name TMXLayer#class
      */
-    public class: string;
+    class: string;
     name: any;
     cols: number;
     rows: number;
     preRender: boolean;
+    layerData: any[];
     onActivateEvent(): void;
     canvasRenderer: CanvasRenderer | undefined;
     onDeactivateEvent(): void;
     /**
      * Set the TMX renderer for this layer object
-     * @name setRenderer
-     * @memberof TMXLayer
-     * @public
      * @param {TMXRenderer} renderer
      * @example
      * // use the parent map default renderer
      * var layer = new me.TMXLayer(...);
      * layer.setRenderer(map.getRenderer());
      */
-    public setRenderer(renderer: TMXRenderer): void;
+    setRenderer(renderer: TMXRenderer): void;
     renderer: any;
     /**
      * Return the layer current renderer object
-     * @name getRenderer
-     * @memberof TMXLayer
-     * @public
      * @returns {TMXRenderer} renderer
      */
-    public getRenderer(): TMXRenderer;
+    getRenderer(): TMXRenderer;
     /**
      * Return the TileId of the Tile at the specified position
-     * @name getTileId
-     * @memberof TMXLayer
-     * @public
      * @param {number} x - X coordinate (in world/pixels coordinates)
      * @param {number} y - Y coordinate (in world/pixels coordinates)
      * @returns {number} TileId or null if there is no Tile at the given position
      */
-    public getTileId(x: number, y: number): number;
+    getTileId(x: number, y: number): number;
     /**
      * Return the Tile object at the specified position
-     * @name getTile
-     * @memberof TMXLayer
-     * @public
      * @param {number} x - X coordinate (in world/pixels coordinates)
      * @param {number} y - Y coordinate (in world/pixels coordinates)
      * @returns {Tile} corresponding tile or null if there is no defined tile at the coordinate or if outside of the layer bounds
@@ -113,34 +103,25 @@ export default class TMXLayer extends Renderable {
      * // get the tile object corresponding to the latest pointer position
      * var tile = layer.getTile(me.input.pointer.x, me.input.pointer.y);
      */
-    public getTile(x: number, y: number): Tile;
+    getTile(x: number, y: number): Tile;
     /**
      * assign the given Tile object to the specified position
-     * @name getTile
-     * @memberof TMXLayer
-     * @public
      * @param {Tile} tile - the tile object to be assigned
      * @param {number} x - x coordinate (in world/pixels coordinates)
      * @param {number} y - y coordinate (in world/pixels coordinates)
      * @returns {Tile} the tile object
      */
-    public setTile(tile: Tile, x: number, y: number): Tile;
+    setTile(tile: Tile, x: number, y: number): Tile;
     /**
      * return a new the Tile object corresponding to the given tile id
-     * @name setTile
-     * @memberof TMXLayer
-     * @public
      * @param {number} tileId - tileId
      * @param {number} x - X coordinate (in world/pixels coordinates)
      * @param {number} y - Y coordinate (in world/pixels coordinates)
      * @returns {Tile} the tile object
      */
-    public getTileById(tileId: number, x: number, y: number): Tile;
+    getTileById(tileId: number, x: number, y: number): Tile;
     /**
      * Return the Tile object at the specified tile coordinates
-     * @name cellAt
-     * @memberof TMXLayer
-     * @public
      * @param {number} x - x position of the tile (in Tile unit)
      * @param {number} y - x position of the tile (in Tile unit)
      * @param {number} [boundsCheck=true] - check first if within the layer bounds
@@ -149,12 +130,9 @@ export default class TMXLayer extends Renderable {
      * // return the first tile at offset 0, 0
      * var tile = layer.cellAt(0, 0);
      */
-    public cellAt(x: number, y: number, boundsCheck?: number | undefined): Tile;
+    cellAt(x: number, y: number, boundsCheck?: number | undefined): Tile;
     /**
      * clear the tile at the specified position
-     * @name clearTile
-     * @memberof TMXLayer
-     * @public
      * @param {number} x - X coordinate (in map coordinates: row/column)
      * @param {number} y - Y coordinate (in map coordinates: row/column)
      * @example
@@ -163,7 +141,7 @@ export default class TMXLayer extends Renderable {
      *     layer.clearTile(x, y);
      * });
      */
-    public clearTile(x: number, y: number): void;
+    clearTile(x: number, y: number): void;
     /**
      * update animations in a tileset layer
      * @ignore