melonjs 14.2.0 → 14.3.0

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

@@ -0,0 +1,180 @@
+/**
+ * @classdesc
+ * a TMX Tile Map Object
+ * Tiled QT +0.7.x format
+ */
+export default class TMXTileMap {
+    /**
+     * @param {string} levelId - name of TMX map
+     * @param {object} data - TMX map in JSON format
+     * @example
+     * // create a new level object based on the TMX JSON object
+     * var level = new me.TMXTileMap(levelId, me.loader.getTMX(levelId));
+     * // add the level to the game world container
+     * level.addTo(me.game.world, true);
+     */
+    constructor(levelId: string, data: object);
+    /**
+     * the level data (JSON)
+     * @ignore
+     */
+    data: object;
+    /**
+     * name of the tilemap
+     * @public
+     * @type {string}
+     * @name TMXTileMap#name
+     */
+    public name: string;
+    /**
+     * width of the tilemap in tiles
+     * @public
+     * @type {number}
+     * @name TMXTileMap#cols
+     */
+    public cols: number;
+    /**
+     * height of the tilemap in tiles
+     * @public
+     * @type {number}
+     * @name TMXTileMap#rows
+     */
+    public rows: number;
+    /**
+     * Tile width
+     * @public
+     * @type {number}
+     * @name TMXTileMap#tilewidth
+     */
+    public tilewidth: number;
+    /**
+     * Tile height
+     * @public
+     * @type {number}
+     * @name TMXTileMap#tileheight
+     */
+    public tileheight: number;
+    /**
+     * is the map an infinite map
+     * @public
+     * @type {number}
+     * @default 0
+     * @name TMXTileMap#infinite
+     */
+    public infinite: number;
+    /**
+     * the map orientation type. melonJS supports “orthogonal”, “isometric”, “staggered” and “hexagonal”.
+     * @public
+     * @type {string}
+     * @default "orthogonal"
+     * @name TMXTileMap#orientation
+     */
+    public 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;
+    /**
+     * the TMX format version
+     * @public
+     * @type {string}
+     * @name TMXTileMap#version
+     */
+    public version: string;
+    /**
+     * The Tiled version used to save the file (since Tiled 1.0.1).
+     * @public
+     * @type {string}
+     * @name TMXTileMap#tiledversion
+     */
+    public tiledversion: string;
+    /**
+     * The map class.
+     * @public
+     * @type {string}
+     * @name TMXTileMap#class
+     */
+    public class: string;
+    tilesets: TMXTilesetGroup | null | undefined;
+    layers: any[];
+    objectGroups: any[];
+    isEditor: boolean;
+    nextobjectid: number | undefined;
+    hexsidelength: number;
+    staggeraxis: any;
+    staggerindex: any;
+    bounds: any;
+    width: any;
+    height: any;
+    backgroundcolor: any;
+    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;
+    /**
+     * return the map bounding rect
+     * @name TMXRenderer#getBounds
+     * @public
+     * @returns {Bounds}
+     */
+    public getBounds(): Bounds;
+    /**
+     * parse the map
+     * @ignore
+     */
+    readMapObjects(data: any): void;
+    /**
+     * 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.
+     * @example
+     * // create a new level object based on the TMX JSON object
+     * var level = new me.TMXTileMap(levelId, me.loader.getTMX(levelId));
+     * // 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;
+    /**
+     * 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[];
+    /**
+     * return all the existing layers
+     * @name TMXTileMap#getLayers
+     * @public
+     * @returns {TMXLayer[]} Array of Layers
+     */
+    public getLayers(): TMXLayer[];
+    /**
+     * destroy function, clean all allocated objects
+     * @name TMXTileMap#destroy
+     * @public
+     */
+    public 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

@@ -0,0 +1,94 @@
+/**
+ * @classdesc
+ * a TMX Tile Set Object
+ */
+export default class TMXTileset {
+    /**
+     *  @param {object} tileset - tileset data in JSON format ({@link http://docs.mapeditor.org/en/stable/reference/tmx-map-format/#tileset})
+     */
+    constructor(tileset: object);
+    TileProperties: any[];
+    imageCollection: HTMLImageElement[];
+    firstgid: number;
+    lastgid: number;
+    name: any;
+    tilewidth: number;
+    tileheight: number;
+    spacing: number;
+    margin: number;
+    tileoffset: Vector2d;
+    /**
+     * Tileset contains animated tiles
+     * @public
+     * @type {boolean}
+     * @name TMXTileset#isAnimated
+     */
+    public isAnimated: boolean;
+    /**
+     * true if the tileset is a "Collection of Image" Tileset
+     * @public
+     * @type {boolean}
+     * @name TMXTileset#isCollection
+     */
+    public isCollection: boolean;
+    /**
+     * the tileset class
+     * @public
+     * @type {boolean}
+     * @name TMXTileset#class
+     */
+    public class: boolean;
+    /**
+     * Tileset animations
+     * @private
+     */
+    private animations;
+    /**
+     * Remember the last update timestamp to prevent too many animation updates
+     * @private
+     */
+    private _lastUpdate;
+    image: HTMLImageElement | undefined;
+    texture: any;
+    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;
+    /**
+     * set the tile properties
+     * @ignore
+     */
+    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;
+    /**
+     * 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;
+    /**
+     * return the properties of the specified tile
+     * @name TMXTileset#getTileProperties
+     * @public
+     * @param {number} tileId
+     * @returns {object}
+     */
+    public getTileProperties(tileId: number): object;
+    update(dt: any): boolean;
+    drawTile(renderer: any, dx: any, dy: any, tmxTile: any): void;
+}
+import Vector2d from "./../../math/vector2.js";

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

@@ -0,0 +1,32 @@
+/**
+ * @classdesc
+ * an object containing all tileset
+ */
+export default class TMXTilesetGroup {
+    tilesets: any[];
+    length: number;
+    /**
+     * add a tileset to the tileset group
+     * @name TMXTilesetGroup#add
+     * @public
+     * @param {TMXTileset} tileset
+     */
+    public 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;
+    /**
+     * 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;
+}

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

@@ -0,0 +1,47 @@
+/**
+ * decompress zlib/gzip data (NOT IMPLEMENTED)
+ * @ignore
+ * @name decompress
+ * @param  {number[]} data- -  Array of bytes
+ * @param  {string} format- -  compressed data format ("gzip","zlib")
+ */
+export function decompress(): void;
+/**
+ * Decode a CSV encoded array into a binary array
+ * @ignore
+ * @name decodeCSV
+ * @param  {string} input- -  CSV formatted data (only numbers, everything else will be converted to NaN)
+ * @returns {number[]} Decoded data
+ */
+export function decodeCSV(input: any): number[];
+/**
+ * Decode a base64 encoded string into a byte array
+ * @ignore
+ * @name decodeBase64AsArray
+ * @param {string} input - Base64 encoded data
+ * @param {number} [bytes] - number of bytes per array entry
+ * @returns {Uint32Array} Decoded data
+ */
+export function decodeBase64AsArray(input: string, bytes?: number | undefined): Uint32Array;
+/**
+ * Decode the given data
+ * @ignore
+ */
+export function decode(data: any, encoding: any, compression: any): any;
+/**
+ * Normalize TMX format to Tiled JSON format
+ * @ignore
+ */
+export function normalize(obj: any, item: any): void;
+/**
+ * Parse a XML TMX object and returns the corresponding javascript object
+ * @ignore
+ */
+export function parse(xml: any): {
+    text: string;
+};
+/**
+ * Apply TMX Properties to the given object
+ * @ignore
+ */
+export function applyTMXProperties(obj: any, data: any): void;

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

@@ -0,0 +1,87 @@
+/**
+ * @classdesc
+ * an Hexagonal Map Renderder
+ * @augments TMXRenderer
+ */
+export default class TMXHexagonalRenderer extends TMXRenderer {
+    /**
+     * @param {TMXTileMap} map - the TMX map
+     */
+    constructor(map: TMXTileMap);
+    hexsidelength: any;
+    staggerX: boolean;
+    staggerEven: boolean;
+    sidelengthx: any;
+    sidelengthy: any;
+    sideoffsetx: number;
+    sideoffsety: number;
+    columnwidth: any;
+    rowheight: any;
+    centers: Vector2d[];
+    /**
+     * return true if the renderer can render the specified layer
+     * @ignore
+     */
+    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}
+     */
+    public getBounds(layer?: TMXLayer | undefined): Bounds;
+    /**
+     * @ignore
+     */
+    doStaggerX(x: any): number | false;
+    /**
+     * @ignore
+     */
+    doStaggerY(y: any): number | false;
+    /**
+     * @ignore
+     */
+    topLeft(x: any, y: any, v: any): any;
+    /**
+     * @ignore
+     */
+    topRight(x: any, y: any, v: any): any;
+    /**
+     * @ignore
+     */
+    bottomLeft(x: any, y: any, v: any): any;
+    /**
+     * @ignore
+     */
+    bottomRight(x: any, y: any, v: any): any;
+    /**
+     * return the tile position corresponding to the specified pixel
+     * @ignore
+     */
+    pixelToTileCoords(x: any, y: any, v: any): any;
+    /**
+     * return the pixel position corresponding of the specified tile
+     * @ignore
+     */
+    tileToPixelCoords(x: any, y: any, v: any): any;
+    /**
+     * fix the position of Objects to match
+     * the way Tiled places them
+     * @ignore
+     */
+    adjustPosition(obj: any): void;
+    /**
+     * draw the tile map
+     * @ignore
+     */
+    drawTile(renderer: any, x: any, y: any, tmxTile: any): void;
+    /**
+     * draw the tile map
+     * @ignore
+     */
+    drawTileLayer(renderer: any, layer: any, rect: any): void;
+}
+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

@@ -0,0 +1,55 @@
+/**
+ * @classdesc
+ * an Isometric Map Renderder
+ * @augments TMXRenderer
+ */
+export default class TMXIsometricRenderer extends TMXRenderer {
+    /**
+     * @param {TMXTileMap} map - the TMX map
+     */
+    constructor(map: TMXTileMap);
+    hTilewidth: number;
+    hTileheight: number;
+    originX: number;
+    /**
+     * return true if the renderer can render the specified layer
+     * @ignore
+     */
+    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}
+     */
+    public getBounds(layer?: TMXLayer | undefined): Bounds;
+    /**
+     * return the tile position corresponding to the specified pixel
+     * @ignore
+     */
+    pixelToTileCoords(x: any, y: any, v: any): any;
+    /**
+     * return the pixel position corresponding of the specified tile
+     * @ignore
+     */
+    tileToPixelCoords(x: any, y: any, v: any): any;
+    /**
+     * fix the position of Objects to match
+     * the way Tiled places them
+     * @ignore
+     */
+    adjustPosition(obj: any): void;
+    /**
+     * draw the tile map
+     * @ignore
+     */
+    drawTile(renderer: any, x: any, y: any, tmxTile: any): void;
+    /**
+     * draw the tile map
+     * @ignore
+     */
+    drawTileLayer(renderer: any, layer: any, rect: any): void;
+}
+import TMXRenderer from "./TMXRenderer.js";
+import TMXLayer from "./../TMXLayer.js";

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

@@ -0,0 +1,43 @@
+/**
+ * @classdesc
+ * an Orthogonal Map Renderder
+ * @augments TMXRenderer
+ */
+export default class TMXOrthogonalRenderer extends TMXRenderer {
+    /**
+     * @param {TMXTileMap} map - the TMX map
+     */
+    constructor(map: TMXTileMap);
+    /**
+     * return true if the renderer can render the specified layer
+     * @ignore
+     */
+    canRender(layer: any): boolean;
+    /**
+     * return the tile position corresponding to the specified pixel
+     * @ignore
+     */
+    pixelToTileCoords(x: any, y: any, v: any): any;
+    /**
+     * return the pixel position corresponding of the specified tile
+     * @ignore
+     */
+    tileToPixelCoords(x: any, y: any, v: any): any;
+    /**
+     * fix the position of Objects to match
+     * the way Tiled places them
+     * @ignore
+     */
+    adjustPosition(obj: any): void;
+    /**
+     * draw the tile map
+     * @ignore
+     */
+    drawTile(renderer: any, x: any, y: any, tmxTile: any): void;
+    /**
+     * draw the tile map
+     * @ignore
+     */
+    drawTileLayer(renderer: any, layer: any, rect: any): void;
+}
+import TMXRenderer from "./TMXRenderer.js";

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

@@ -0,0 +1,75 @@
+/**
+ * @classdesc
+ * The map renderer base class
+ */
+export default class TMXRenderer {
+    /**
+     * @param {number} cols - width of the tilemap in tiles
+     * @param {number} rows - height of the tilemap in tiles
+     * @param {number} tilewidth - width of each tile in pixels
+     * @param {number} tileheight - height of each tile in pixels
+     */
+    constructor(cols: number, rows: number, tilewidth: number, tileheight: number);
+    cols: number;
+    rows: number;
+    tilewidth: number;
+    tileheight: number;
+    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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+}
+import Bounds from "./../../../physics/bounds.js";
+import TMXLayer from "./../TMXLayer.js";

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

@@ -0,0 +1,8 @@
+/**
+ * @classdesc
+ * a Staggered Map Renderder
+ * @augments TMXHexagonalRenderer
+ */
+export default class TMXStaggeredRenderer extends TMXHexagonalRenderer {
+}
+import TMXHexagonalRenderer from "./TMXHexagonalRenderer.js";