melonjs 14.3.0 → 14.4.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/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}

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

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

@@ -8,168 +8,108 @@ export default class TMXObject {
     constructor(map: any, settings: any, z: any);
     /**
      * point list in JSON format
-     * @public
      * @type {object[]}
-     * @name points
-     * @memberof TMXObject
      */
-    public points: object[];
+    points: object[];
     /**
      * object name
-     * @public
      * @type {string}
-     * @name name
-     * @memberof TMXObject
      */
-    public name: string;
+    name: string;
     /**
      * object x position
-     * @public
      * @type {number}
-     * @name x
-     * @memberof TMXObject
      */
-    public x: number;
+    x: number;
     /**
      * object y position
-     * @public
      * @type {number}
-     * @name y
-     * @memberof TMXObject
      */
-    public y: number;
+    y: number;
     /**
      * object z order
-     * @public
      * @type {number}
-     * @name z
-     * @memberof TMXObject
      */
-    public z: number;
+    z: number;
     /**
      * object width
-     * @public
      * @type {number}
-     * @name width
-     * @memberof TMXObject
      */
-    public width: number;
+    width: number;
     /**
      * object height
-     * @public
      * @type {number}
-     * @name height
-     * @memberof TMXObject
      */
-    public height: number;
+    height: number;
     /**
      * object gid value
      * when defined the object is a tiled object
-     * @public
      * @type {number}
-     * @name gid
-     * @memberof TMXObject
      */
-    public gid: number;
+    gid: number;
     /**
      * tint color
-     * @public
      * @type {string}
-     * @name tintcolor
-     * @memberof TMXObject
      */
-    public tintcolor: string;
+    tintcolor: string;
     /**
      * object type
-     * @public
      * @type {string}
      * @deprecated since Tiled 1.9
      * @see https://docs.mapeditor.org/en/stable/reference/tmx-changelog/#tiled-1-9
-     * @name type
-     * @memberof TMXObject
      */
-    public type: string;
+    type: string;
     /**
      * the object class
-     * @public
      * @type {string}
-     * @name class
-     * @memberof TMXObject
      */
-    public class: string;
+    class: string;
     /**
      * object text
-     * @public
      * @type {object}
      * @see http://docs.mapeditor.org/en/stable/reference/tmx-map-format/#text
-     * @name text
-     * @memberof TMXObject
      */
-    public text: object;
+    text: object;
     /**
      * The rotation of the object in radians clockwise (defaults to 0)
-     * @public
      * @type {number}
-     * @name rotation
-     * @memberof TMXObject
      */
-    public rotation: number;
+    rotation: number;
     /**
      * object unique identifier per level (Tiled 0.11.x+)
-     * @public
      * @type {number}
-     * @name id
-     * @memberof TMXObject
      */
-    public id: number;
+    id: number;
     /**
      * object orientation (orthogonal or isometric)
-     * @public
      * @type {string}
-     * @name orientation
-     * @memberof TMXObject
      */
-    public orientation: string;
+    orientation: string;
     /**
      * the collision shapes defined for this object
-     * @public
      * @type {object[]}
-     * @name shapes
-     * @memberof TMXObject
      */
-    public shapes: object[];
+    shapes: object[];
     /**
      * if true, the object is an Ellipse
-     * @public
      * @type {boolean}
-     * @name isEllipse
-     * @memberof TMXObject
      */
-    public isEllipse: boolean;
+    isEllipse: boolean;
     /**
      * if true, the object is a Point
-     * @public
      * @type {boolean}
-     * @name isPoint
-     * @memberof TMXObject
      */
-    public isPoint: boolean;
+    isPoint: boolean;
     /**
      * if true, the object is a Polygon
-     * @public
      * @type {boolean}
-     * @name isPolygon
-     * @memberof TMXObject
      */
-    public isPolygon: boolean;
+    isPolygon: boolean;
     /**
      * if true, the object is a PolyLine
-     * @public
      * @type {boolean}
-     * @name isPolyLine
-     * @memberof TMXObject
      */
-    public isPolyLine: boolean;
+    isPolyLine: boolean;
     /**
      * set the object image (for Tiled Object)
      * @ignore
@@ -180,8 +120,6 @@ export default class TMXObject {
     tile: Tile | undefined;
     /**
      * parses the TMX shape definition and returns a corresponding array of me.Shape object
-     * @name parseTMXShapes
-     * @memberof TMXObject
      * @private
      * @returns {Polygon[]|Line[]|Ellipse[]} an array of shape objects
      */

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

@@ -13,11 +13,9 @@ export default class Tile extends Bounds {
     constructor(x: number, y: number, gid: number, tileset: TMXTileset);
     /**
      * tileset
-     * @public
      * @type {TMXTileset}
-     * @name Tile#tileset
      */
-    public tileset: TMXTileset;
+    tileset: TMXTileset;
     /**
      * the tile transformation matrix (if defined)
      * @ignore
@@ -27,39 +25,29 @@ export default class Tile extends Bounds {
     row: number;
     /**
      * tileId
-     * @public
      * @type {number}
-     * @name Tile#tileId
      */
-    public tileId: number;
+    tileId: number;
     /**
-     * True if the tile is flipped horizontally<br>
-     * @public
+     * True if the tile is flipped horizontally
      * @type {boolean}
-     * @name Tile#flipX
      */
-    public flippedX: boolean;
+    flippedX: boolean;
     /**
-     * True if the tile is flipped vertically<br>
-     * @public
+     * True if the tile is flipped vertically
      * @type {boolean}
-     * @name Tile#flippedY
      */
-    public flippedY: boolean;
+    flippedY: boolean;
     /**
-     * True if the tile is flipped anti-diagonally<br>
-     * @public
+     * True if the tile is flipped anti-diagonally
      * @type {boolean}
-     * @name Tile#flippedAD
      */
-    public flippedAD: boolean;
+    flippedAD: boolean;
     /**
-     * Global flag that indicates if the tile is flipped<br>
-     * @public
+     * Global flag that indicates if the tile is flipped
      * @type {boolean}
-     * @name Tile#flipped
      */
-    public flipped: boolean;
+    flipped: boolean;
     /**
      * set the transformation matrix for this tile
      * @ignore
@@ -67,12 +55,10 @@ export default class Tile extends Bounds {
     setTileTransform(transform: any): void;
     /**
      * return a renderable object for this Tile object
-     * @name Tile#getRenderable
-     * @public
      * @param {object} [settings] - see {@link Sprite}
      * @returns {Renderable} a me.Sprite object
      */
-    public getRenderable(settings?: object | undefined): Renderable;
+    getRenderable(settings?: object | undefined): Renderable;
 }
 import Bounds from "./../../physics/bounds.js";
 import Matrix2d from "./../../math/matrix2.js";