melonjs 14.3.0 → 14.5.0

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";

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

@@ -21,85 +21,63 @@ export default class TMXTileMap {
     data: object;
     /**
      * name of the tilemap
-     * @public
      * @type {string}
-     * @name TMXTileMap#name
      */
-    public name: string;
+    name: string;
     /**
      * width of the tilemap in tiles
-     * @public
      * @type {number}
-     * @name TMXTileMap#cols
      */
-    public cols: number;
+    cols: number;
     /**
      * height of the tilemap in tiles
-     * @public
      * @type {number}
-     * @name TMXTileMap#rows
      */
-    public rows: number;
+    rows: number;
     /**
      * Tile width
-     * @public
      * @type {number}
-     * @name TMXTileMap#tilewidth
      */
-    public tilewidth: number;
+    tilewidth: number;
     /**
      * Tile height
-     * @public
      * @type {number}
-     * @name TMXTileMap#tileheight
      */
-    public tileheight: number;
+    tileheight: number;
     /**
      * is the map an infinite map
-     * @public
      * @type {number}
      * @default 0
-     * @name TMXTileMap#infinite
      */
-    public infinite: number;
+    infinite: number;
     /**
      * the map orientation type. melonJS supports “orthogonal”, “isometric”, “staggered” and “hexagonal”.
-     * @public
      * @type {string}
      * @default "orthogonal"
-     * @name TMXTileMap#orientation
      */
-    public orientation: string;
+    orientation: string;
     /**
      * 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 TMXTileMap#renderorder
      */
-    public renderorder: string;
+    renderorder: string;
     /**
      * the TMX format version
-     * @public
      * @type {string}
-     * @name TMXTileMap#version
      */
-    public version: string;
+    version: string;
     /**
      * The Tiled version used to save the file (since Tiled 1.0.1).
-     * @public
      * @type {string}
-     * @name TMXTileMap#tiledversion
      */
-    public tiledversion: string;
+    tiledversion: string;
     /**
      * The map class.
-     * @public
      * @type {string}
-     * @name TMXTileMap#class
      */
-    public class: string;
+    class: string;
     tilesets: TMXTilesetGroup | null | undefined;
     layers: any[];
     objectGroups: any[];
@@ -115,20 +93,15 @@ export default class TMXTileMap {
     initialized: boolean;
     /**
      * Return the map default renderer
-     * @name getRenderer
-     * @memberof TMXTileMap
-     * @public
      * @returns {TMXRenderer} a TMX renderer
      */
-    public getRenderer(): TMXRenderer;
-    renderer: TMXOrthogonalRenderer | TMXIsometricRenderer | TMXHexagonalRenderer | undefined;
+    getRenderer(): TMXRenderer;
+    renderer: import("./renderer/TMXOrthogonalRenderer.js").default | import("./renderer/TMXIsometricRenderer.js").default | import("./renderer/TMXHexagonalRenderer.js").default | undefined;
     /**
      * return the map bounding rect
-     * @name TMXRenderer#getBounds
-     * @public
      * @returns {Bounds}
      */
-    public getBounds(): Bounds;
+    getBounds(): Bounds;
     /**
      * parse the map
      * @ignore
@@ -137,8 +110,6 @@ export default class TMXTileMap {
     /**
      * add all the map layers and objects to the given container.
      * note : this will not automatically update the camera viewport
-     * @name TMXTileMap#addTo
-     * @public
      * @param {Container} container - target container
      * @param {boolean} [flatten=true] - if true, flatten all objects into the given container, else a `me.Container` object will be created for each corresponding groups
      * @param {boolean} [setViewportBounds=false] - if true, set the viewport bounds to the map size, this should be set to true especially if adding a level to the game world container.
@@ -148,33 +119,24 @@ export default class TMXTileMap {
      * // add the level to the game world container
      * level.addTo(me.game.world, true, true);
      */
-    public addTo(container: Container, flatten?: boolean | undefined, setViewportBounds?: boolean | undefined): void;
+    addTo(container: Container, flatten?: boolean | undefined, setViewportBounds?: boolean | undefined): void;
     /**
      * return an Array of instantiated objects, based on the map object definition
-     * @name TMXTileMap#getObjects
-     * @public
      * @param {boolean} [flatten=true] - if true, flatten all objects into the returned array.
      * when false, a `me.Container` object will be created for each corresponding groups
      * @returns {Renderable[]} Array of Objects
      */
-    public getObjects(flatten?: boolean | undefined): Renderable[];
+    getObjects(flatten?: boolean | undefined): Renderable[];
     /**
      * return all the existing layers
-     * @name TMXTileMap#getLayers
-     * @public
      * @returns {TMXLayer[]} Array of Layers
      */
-    public getLayers(): TMXLayer[];
+    getLayers(): TMXLayer[];
     /**
      * destroy function, clean all allocated objects
-     * @name TMXTileMap#destroy
-     * @public
      */
-    public destroy(): void;
+    destroy(): void;
 }
 import TMXTilesetGroup from "./TMXTilesetGroup.js";
-import TMXOrthogonalRenderer from "./renderer/TMXOrthogonalRenderer.js";
-import TMXIsometricRenderer from "./renderer/TMXIsometricRenderer.js";
-import TMXHexagonalRenderer from "./renderer/TMXHexagonalRenderer.js";
 import Container from "../../renderable/container.js";
 import TMXLayer from "./TMXLayer.js";

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

@@ -19,25 +19,19 @@ export default class TMXTileset {
     tileoffset: Vector2d;
     /**
      * Tileset contains animated tiles
-     * @public
      * @type {boolean}
-     * @name TMXTileset#isAnimated
      */
-    public isAnimated: boolean;
+    isAnimated: boolean;
     /**
      * true if the tileset is a "Collection of Image" Tileset
-     * @public
      * @type {boolean}
-     * @name TMXTileset#isCollection
      */
-    public isCollection: boolean;
+    isCollection: boolean;
     /**
      * the tileset class
-     * @public
      * @type {boolean}
-     * @name TMXTileset#class
      */
-    public class: boolean;
+    class: boolean;
     /**
      * Tileset animations
      * @private
@@ -53,12 +47,10 @@ export default class TMXTileset {
     atlas: any;
     /**
      * return the tile image from a "Collection of Image" tileset
-     * @name TMXTileset#getTileImage
-     * @public
      * @param {number} gid
      * @returns {Image} corresponding image or undefined
      */
-    public getTileImage(gid: number): new (width?: number | undefined, height?: number | undefined) => HTMLImageElement;
+    getTileImage(gid: number): new (width?: number | undefined, height?: number | undefined) => HTMLImageElement;
     /**
      * set the tile properties
      * @ignore
@@ -66,28 +58,22 @@ export default class TMXTileset {
     setTileProperty(gid: any, prop: any): void;
     /**
      * return true if the gid belongs to the tileset
-     * @name TMXTileset#contains
-     * @public
      * @param {number} gid
      * @returns {boolean}
      */
-    public contains(gid: number): boolean;
+    contains(gid: number): boolean;
     /**
      * Get the view (local) tile ID from a GID, with animations applied
-     * @name TMXTileset#getViewTileId
-     * @public
      * @param {number} gid - Global tile ID
      * @returns {number} View tile ID
      */
-    public getViewTileId(gid: number): number;
+    getViewTileId(gid: number): number;
     /**
      * return the properties of the specified tile
-     * @name TMXTileset#getTileProperties
-     * @public
      * @param {number} tileId
      * @returns {object}
      */
-    public getTileProperties(tileId: number): object;
+    getTileProperties(tileId: number): object;
     update(dt: any): boolean;
     drawTile(renderer: any, dx: any, dy: any, tmxTile: any): void;
 }

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

@@ -7,26 +7,20 @@ export default class TMXTilesetGroup {
     length: number;
     /**
      * add a tileset to the tileset group
-     * @name TMXTilesetGroup#add
-     * @public
      * @param {TMXTileset} tileset
      */
-    public add(tileset: TMXTileset): void;
+    add(tileset: TMXTileset): void;
     /**
      * return the tileset at the specified index
-     * @name TMXTilesetGroup#getTilesetByIndex
-     * @public
      * @param {number} i
      * @returns {TMXTileset} corresponding tileset
      */
-    public getTilesetByIndex(i: number): TMXTileset;
+    getTilesetByIndex(i: number): TMXTileset;
     /**
      * return the tileset corresponding to the specified id <br>
      * will throw an exception if no matching tileset is found
-     * @name TMXTilesetGroup#getTilesetByGid
-     * @public
      * @param {number} gid
      * @returns {TMXTileset} corresponding tileset
      */
-    public getTilesetByGid(gid: number): TMXTileset;
+    getTilesetByGid(gid: number): TMXTileset;
 }

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

@@ -0,0 +1,5 @@
+export const TMX_FLIP_H: 2147483648;
+export const TMX_FLIP_V: 1073741824;
+export const TMX_FLIP_AD: 536870912;
+export const TMX_CLEAR_BIT_MASK: number;
+export const COLLISION_GROUP: "collision";

package/dist/types/level/tiled/renderer/TMXHexagonalRenderer.d.ts

@@ -25,12 +25,9 @@ export default class TMXHexagonalRenderer extends TMXRenderer {
     canRender(layer: any): boolean;
     /**
      * return the bounding rect for this map renderer
-     * @name TMXHexagonalRenderer#getBounds
-     * @public
-     * @param {TMXLayer} [layer] - calculate the bounding rect for a specific layer (will return a new bounds object)
-     * @returns {Bounds}
+     * @ignore
      */
-    public getBounds(layer?: TMXLayer | undefined): Bounds;
+    getBounds(layer: any): object;
     /**
      * @ignore
      */
@@ -84,4 +81,3 @@ export default class TMXHexagonalRenderer extends TMXRenderer {
 }
 import TMXRenderer from "./TMXRenderer.js";
 import Vector2d from "./../../../math/vector2.js";
-import TMXLayer from "./../TMXLayer.js";

package/dist/types/level/tiled/renderer/TMXIsometricRenderer.d.ts

@@ -18,12 +18,9 @@ export default class TMXIsometricRenderer extends TMXRenderer {
     canRender(layer: any): boolean;
     /**
      * return the bounding rect for this map renderer
-     * @name TMXIsometricRenderer#getBounds
-     * @public
-     * @param {TMXLayer} [layer] - calculate the bounding rect for a specific layer (will return a new bounds object)
-     * @returns {Bounds}
+     * @ignore
      */
-    public getBounds(layer?: TMXLayer | undefined): Bounds;
+    getBounds(layer: any): object;
     /**
      * return the tile position corresponding to the specified pixel
      * @ignore
@@ -52,4 +49,3 @@ export default class TMXIsometricRenderer extends TMXRenderer {
     drawTileLayer(renderer: any, layer: any, rect: any): void;
 }
 import TMXRenderer from "./TMXRenderer.js";
-import TMXLayer from "./../TMXLayer.js";

package/dist/types/level/tiled/renderer/TMXRenderer.d.ts

@@ -17,59 +17,47 @@ export default class TMXRenderer {
     bounds: Bounds;
     /**
      * return true if the renderer can render the specified map or layer
-     * @name TMXRenderer#canRender
-     * @public
      * @param {TMXTileMap|TMXLayer} component - TMX Map or Layer
      * @returns {boolean}
      */
-    public canRender(component: TMXTileMap | TMXLayer): boolean;
+    canRender(component: TMXTileMap | TMXLayer): boolean;
     /**
      * return the bounding rect for this map renderer
-     * @name TMXRenderer#getBounds
-     * @public
      * @param {TMXLayer} [layer] - calculate the bounding rect for a specific layer (will return a new bounds object)
      * @returns {Bounds}
      */
-    public getBounds(layer?: TMXLayer | undefined): Bounds;
+    getBounds(layer?: TMXLayer | undefined): Bounds;
     /**
      * return the tile position corresponding to the specified pixel
-     * @name TMXRenderer#pixelToTileCoords
-     * @public
      * @param {number} x - X coordinate
      * @param {number} y - Y coordinate
      * @param {Vector2d} [v] - an optional vector object where to put the return values
      * @returns {Vector2d}
      */
-    public pixelToTileCoords(x: number, y: number, v?: any): Vector2d;
+    pixelToTileCoords(x: number, y: number, v?: any): Vector2d;
     /**
      * return the pixel position corresponding of the specified tile
-     * @name TMXRenderer#tileToPixelCoords
-     * @public
      * @param {number} col - tile horizontal position
      * @param {number} row - tile vertical position
      * @param {Vector2d} [v] - an optional vector object where to put the return values
      * @returns {Vector2d}
      */
-    public tileToPixelCoords(col: number, row: number, v?: any): Vector2d;
+    tileToPixelCoords(col: number, row: number, v?: any): Vector2d;
     /**
      * draw the given tile at the specified layer
-     * @name TMXRenderer#drawTile
-     * @public
      * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
      * @param {number} x - X coordinate where to draw the tile
      * @param {number} y - Y coordinate where to draw the tile
      * @param {Tile} tile - the tile object to draw
      */
-    public drawTile(renderer: CanvasRenderer | WebGLRenderer, x: number, y: number, tile: Tile): void;
+    drawTile(renderer: CanvasRenderer | WebGLRenderer, x: number, y: number, tile: Tile): void;
     /**
      * draw the given TMX Layer for the given area
-     * @name TMXRenderer#drawTileLayer
-     * @public
      * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
      * @param {TMXLayer} layer - a TMX Layer object
      * @param {Rect} rect - the area of the layer to draw
      */
-    public drawTileLayer(renderer: CanvasRenderer | WebGLRenderer, layer: TMXLayer, rect: Rect): void;
+    drawTileLayer(renderer: CanvasRenderer | WebGLRenderer, layer: TMXLayer, rect: Rect): void;
 }
 import Bounds from "./../../../physics/bounds.js";
 import TMXLayer from "./../TMXLayer.js";

package/dist/types/level/tiled/renderer/autodetect.d.ts

@@ -0,0 +1,9 @@
+/**
+ * return a compatible renderer object for the given map
+ * @param {TMXTileMap} map
+ * @ignore
+ */
+export function getNewTMXRenderer(map: TMXTileMap): TMXOrthogonalRenderer | TMXIsometricRenderer | TMXHexagonalRenderer;
+import TMXOrthogonalRenderer from "./TMXOrthogonalRenderer.js";
+import TMXIsometricRenderer from "./TMXIsometricRenderer.js";
+import TMXHexagonalRenderer from "./TMXHexagonalRenderer.js";

package/dist/types/loader/cache.d.ts

@@ -0,0 +1,7 @@
+/**
+ * where all preloaded content is cached
+ */
+export let imgList: {};
+export let tmxList: {};
+export let binList: {};
+export let jsonList: {};