melonjs 14.2.0 → 14.4.0

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

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

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

@@ -0,0 +1,64 @@
+/**
+ * @classdesc
+ * a basic tile object
+ * @augments Bounds
+ */
+export default class Tile extends Bounds {
+    /**
+     * @param {number} x - x index of the Tile in the map
+     * @param {number} y - y index of the Tile in the map
+     * @param {number} gid - tile gid
+     * @param {TMXTileset} tileset - the corresponding tileset object
+     */
+    constructor(x: number, y: number, gid: number, tileset: TMXTileset);
+    /**
+     * tileset
+     * @type {TMXTileset}
+     */
+    tileset: TMXTileset;
+    /**
+     * the tile transformation matrix (if defined)
+     * @ignore
+     */
+    currentTransform: Matrix2d | null;
+    col: number;
+    row: number;
+    /**
+     * tileId
+     * @type {number}
+     */
+    tileId: number;
+    /**
+     * True if the tile is flipped horizontally
+     * @type {boolean}
+     */
+    flippedX: boolean;
+    /**
+     * True if the tile is flipped vertically
+     * @type {boolean}
+     */
+    flippedY: boolean;
+    /**
+     * True if the tile is flipped anti-diagonally
+     * @type {boolean}
+     */
+    flippedAD: boolean;
+    /**
+     * Global flag that indicates if the tile is flipped
+     * @type {boolean}
+     */
+    flipped: boolean;
+    /**
+     * set the transformation matrix for this tile
+     * @ignore
+     */
+    setTileTransform(transform: any): void;
+    /**
+     * return a renderable object for this Tile object
+     * @param {object} [settings] - see {@link Sprite}
+     * @returns {Renderable} a me.Sprite object
+     */
+    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

@@ -0,0 +1,142 @@
+/**
+ * @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
+     * @type {string}
+     */
+    name: string;
+    /**
+     * width of the tilemap in tiles
+     * @type {number}
+     */
+    cols: number;
+    /**
+     * height of the tilemap in tiles
+     * @type {number}
+     */
+    rows: number;
+    /**
+     * Tile width
+     * @type {number}
+     */
+    tilewidth: number;
+    /**
+     * Tile height
+     * @type {number}
+     */
+    tileheight: number;
+    /**
+     * is the map an infinite map
+     * @type {number}
+     * @default 0
+     */
+    infinite: number;
+    /**
+     * the map orientation type. melonJS supports “orthogonal”, “isometric”, “staggered” and “hexagonal”.
+     * @type {string}
+     * @default "orthogonal"
+     */
+    orientation: string;
+    /**
+     * the order in which tiles on orthogonal tile layers are rendered.
+     * (valid values are "left-down", "left-up", "right-down", "right-up")
+     * @type {string}
+     * @default "right-down"
+     */
+    renderorder: string;
+    /**
+     * the TMX format version
+     * @type {string}
+     */
+    version: string;
+    /**
+     * The Tiled version used to save the file (since Tiled 1.0.1).
+     * @type {string}
+     */
+    tiledversion: string;
+    /**
+     * The map class.
+     * @type {string}
+     */
+    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
+     * @returns {TMXRenderer} a TMX renderer
+     */
+    getRenderer(): TMXRenderer;
+    renderer: import("./renderer/TMXOrthogonalRenderer.js").default | import("./renderer/TMXIsometricRenderer.js").default | import("./renderer/TMXHexagonalRenderer.js").default | undefined;
+    /**
+     * return the map bounding rect
+     * @returns {Bounds}
+     */
+    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
+     * @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);
+     */
+    addTo(container: Container, flatten?: boolean | undefined, setViewportBounds?: boolean | undefined): void;
+    /**
+     * return an Array of instantiated objects, based on the map object definition
+     * @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
+     */
+    getObjects(flatten?: boolean | undefined): Renderable[];
+    /**
+     * return all the existing layers
+     * @returns {TMXLayer[]} Array of Layers
+     */
+    getLayers(): TMXLayer[];
+    /**
+     * destroy function, clean all allocated objects
+     */
+    destroy(): void;
+}
+import TMXTilesetGroup from "./TMXTilesetGroup.js";
+import Container from "../../renderable/container.js";
+import TMXLayer from "./TMXLayer.js";

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

@@ -0,0 +1,80 @@
+/**
+ * @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
+     * @type {boolean}
+     */
+    isAnimated: boolean;
+    /**
+     * true if the tileset is a "Collection of Image" Tileset
+     * @type {boolean}
+     */
+    isCollection: boolean;
+    /**
+     * the tileset class
+     * @type {boolean}
+     */
+    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
+     * @param {number} gid
+     * @returns {Image} corresponding image or undefined
+     */
+    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
+     * @param {number} gid
+     * @returns {boolean}
+     */
+    contains(gid: number): boolean;
+    /**
+     * Get the view (local) tile ID from a GID, with animations applied
+     * @param {number} gid - Global tile ID
+     * @returns {number} View tile ID
+     */
+    getViewTileId(gid: number): number;
+    /**
+     * return the properties of the specified tile
+     * @param {number} tileId
+     * @returns {object}
+     */
+    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,26 @@
+/**
+ * @classdesc
+ * an object containing all tileset
+ */
+export default class TMXTilesetGroup {
+    tilesets: any[];
+    length: number;
+    /**
+     * add a tileset to the tileset group
+     * @param {TMXTileset} tileset
+     */
+    add(tileset: TMXTileset): void;
+    /**
+     * return the tileset at the specified index
+     * @param {number} i
+     * @returns {TMXTileset} corresponding tileset
+     */
+    getTilesetByIndex(i: number): TMXTileset;
+    /**
+     * return the tileset corresponding to the specified id <br>
+     * will throw an exception if no matching tileset is found
+     * @param {number} gid
+     * @returns {TMXTileset} corresponding tileset
+     */
+    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/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

@@ -0,0 +1,83 @@
+/**
+ * @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
+     * @ignore
+     */
+    getBounds(layer: any): object;
+    /**
+     * @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";

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

@@ -0,0 +1,51 @@
+/**
+ * @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
+     * @ignore
+     */
+    getBounds(layer: any): object;
+    /**
+     * 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/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";