melonjs 14.2.0 → 14.3.0

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

@@ -0,0 +1,134 @@
+export default level;
+declare namespace level {
+    /**
+     * add a level into the game manager (usually called by the preloader)
+     * @name add
+     * @memberof level
+     * @public
+     * @param {string} format - level format (only "tmx" supported)
+     * @param {string} levelId - the level id (or name)
+     * @param {Function} [callback] - a function to be called once the level is loaded
+     * @returns {boolean} true if the level was loaded
+     */
+    function add(format: string, levelId: string, callback?: Function | undefined): boolean;
+    /**
+     * load a level into the game manager<br>
+     * (will also create all level defined entities, etc..)
+     * @name load
+     * @memberof level
+     * @public
+     * @param {string} levelId - level id
+     * @param {object} [options] - additional optional parameters
+     * @param {Container} [options.container=game.world] - container in which to load the specified level
+     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
+     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
+     * @param {boolean} [options.setViewportBounds=true] - if true, set the viewport bounds to the map size
+     * @returns {boolean} true if the level was successfully loaded
+     * @example
+     * // the game assets to be be preloaded
+     * // TMX maps
+     * var resources = [
+     *     {name: "a4_level1",   type: "tmx",   src: "data/level/a4_level1.tmx"},
+     *     {name: "a4_level2",   type: "tmx",   src: "data/level/a4_level2.tmx"},
+     *     {name: "a4_level3",   type: "tmx",   src: "data/level/a4_level3.tmx"},
+     *     // ...
+     * ];
+     *
+     * // ...
+     *
+     * // load a level into the game world
+     * me.level.load("a4_level1");
+     * ...
+     * ...
+     * // load a level into a specific container
+     * var levelContainer = new me.Container();
+     * me.level.load("a4_level2", {container:levelContainer});
+     * // add a simple transformation
+     * levelContainer.currentTransform.translate(levelContainer.width / 2, levelContainer.height / 2 );
+     * levelContainer.currentTransform.rotate(0.05);
+     * levelContainer.currentTransform.translate(-levelContainer.width / 2, -levelContainer.height / 2 );
+     * // add it to the game world
+     * me.game.world.addChild(levelContainer);
+     */
+    function load(levelId: string, options?: {
+        container?: any;
+        onLoaded?: Function | undefined;
+        flatten?: boolean | undefined;
+        setViewportBounds?: boolean | undefined;
+    } | undefined): boolean;
+    /**
+     * return the current level id<br>
+     * @name getCurrentLevelId
+     * @memberof level
+     * @public
+     * @returns {string}
+     */
+    function getCurrentLevelId(): string;
+    /**
+     * return the current level definition.
+     * for a reference to the live instantiated level,
+     * rather use the container in which it was loaded (e.g. me.game.world)
+     * @name getCurrentLevel
+     * @memberof level
+     * @public
+     * @returns {TMXTileMap}
+     */
+    function getCurrentLevel(): TMXTileMap;
+    /**
+     * reload the current level
+     * @name reload
+     * @memberof level
+     * @public
+     * @param {object} [options] - additional optional parameters
+     * @param {Container} [options.container=game.world] - container in which to load the specified level
+     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
+     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
+     * @returns {object} the current level
+     */
+    function reload(options?: {
+        container?: any;
+        onLoaded?: Function | undefined;
+        flatten?: boolean | undefined;
+    } | undefined): object;
+    /**
+     * load the next level
+     * @name next
+     * @memberof level
+     * @public
+     * @param {object} [options] - additional optional parameters
+     * @param {Container} [options.container=game.world] - container in which to load the specified level
+     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
+     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
+     * @returns {boolean} true if the next level was successfully loaded
+     */
+    function next(options?: {
+        container?: any;
+        onLoaded?: Function | undefined;
+        flatten?: boolean | undefined;
+    } | undefined): boolean;
+    /**
+     * load the previous level<br>
+     * @name previous
+     * @memberof level
+     * @public
+     * @param {object} [options] - additional optional parameters
+     * @param {Container} [options.container=game.world] - container in which to load the specified level
+     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
+     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
+     * @returns {boolean} true if the previous level was successfully loaded
+     */
+    function previous(options?: {
+        container?: any;
+        onLoaded?: Function | undefined;
+        flatten?: boolean | undefined;
+    } | undefined): boolean;
+    /**
+     * return the amount of level preloaded
+     * @name levelCount
+     * @memberof level
+     * @public
+     * @returns {number} the amount of level preloaded
+     */
+    function levelCount(): number;
+}
+import TMXTileMap from "./tiled/TMXTileMap.js";

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

@@ -0,0 +1,82 @@
+/**
+ * @classdesc
+ * object group definition as defined in Tiled.
+ * (group definition is translated into the virtual `me.game.world` using `me.Container`)
+ * @ignore
+ */
+export default class TMXGroup {
+    constructor(map: any, data: any, z: any);
+    /**
+     * group name
+     * @public
+     * @type {string}
+     * @name name
+     * @memberof TMXGroup
+     */
+    public name: string;
+    /**
+     * group width
+     * @public
+     * @type {number}
+     * @name width
+     * @memberof TMXGroup
+     */
+    public width: number;
+    /**
+     * group height
+     * @public
+     * @type {number}
+     * @name height
+     * @memberof TMXGroup
+     */
+    public height: number;
+    /**
+     * tint color
+     * @public
+     * @type {string}
+     * @name tintcolor
+     * @memberof TMXGroup
+     */
+    public tintcolor: string;
+    /**
+     * the group class
+     * @public
+     * @type {string}
+     * @name class
+     * @memberof TMXGroup
+     */
+    public class: string;
+    /**
+     * group z order
+     * @public
+     * @type {number}
+     * @name z
+     * @memberof TMXGroup
+     */
+    public z: number;
+    /**
+     * group objects list definition
+     * @see TMXObject
+     * @public
+     * @type {object[]}
+     * @name name
+     * @memberof TMXGroup
+     */
+    public objects: object[];
+    opacity: number;
+    /**
+     * reset function
+     * @ignore
+     */
+    destroy(): void;
+    /**
+     * return the object count
+     * @ignore
+     */
+    getObjectCount(): number;
+    /**
+     * returns the object at the specified index
+     * @ignore
+     */
+    getObjectByIndex(idx: any): object;
+}

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

@@ -0,0 +1,180 @@
+/**
+ * @classdesc
+ * a TMX Tile Layer Object
+ * Tiled QT 0.7.x format
+ * @augments Renderable
+ */
+export default class TMXLayer extends Renderable {
+    /**
+     * @param {object} map - layer data in JSON format ({@link http://docs.mapeditor.org/en/stable/reference/tmx-map-format/#layer})
+     * @param {object} data - layer data in JSON format ({@link http://docs.mapeditor.org/en/stable/reference/tmx-map-format/#layer})
+     * @param {number} tilewidth - width of each tile in pixels
+     * @param {number} tileheight - height of each tile in pixels
+     * @param {string} orientation - "isometric" or "orthogonal"
+     * @param {TMXTilesetGroup} tilesets - tileset as defined in Tiled
+     * @param {number} z - z-index position
+     */
+    constructor(map: object, data: object, tilewidth: number, tileheight: number, orientation: string, tilesets: TMXTilesetGroup, z: number);
+    tilewidth: any;
+    tileheight: any;
+    orientation: string;
+    /**
+     * The Layer corresponding Tilesets
+     * @public
+     * @type {TMXTilesetGroup}
+     * @name TMXLayer#tilesets
+     */
+    public tilesets: TMXTilesetGroup;
+    tileset: any;
+    maxTileSize: {
+        width: number;
+        height: number;
+    };
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * the layer class
+     * @public
+     * @type {string}
+     * @name class
+     * @name TMXLayer#class
+     */
+    public class: string;
+    name: any;
+    cols: number;
+    rows: number;
+    preRender: boolean;
+    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;
+    renderer: any;
+    /**
+     * Return the layer current renderer object
+     * @name getRenderer
+     * @memberof TMXLayer
+     * @public
+     * @returns {TMXRenderer} renderer
+     */
+    public 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;
+    /**
+     * 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
+     * @example
+     * // get the TMX Map Layer called "Front layer"
+     * var layer = me.game.world.getChildByName("Front Layer")[0];
+     * // 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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
+     * @returns {Tile} corresponding tile or null if there is no defined tile at the position or if outside of the layer bounds
+     * @example
+     * // return the first tile at offset 0, 0
+     * var tile = layer.cellAt(0, 0);
+     */
+    public 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
+     * me.game.world.getChildByType(me.TMXLayer).forEach(function(layer) {
+     *     // clear all tiles at the given x,y coordinates
+     *     layer.clearTile(x, y);
+     * });
+     */
+    public clearTile(x: number, y: number): void;
+    /**
+     * update animations in a tileset layer
+     * @ignore
+     */
+    update(dt: any): boolean;
+    /**
+     * draw a tileset layer
+     * @ignore
+     */
+    draw(renderer: any, rect: any): void;
+}
+import Renderable from "./../../renderable/renderable.js";
+import CanvasRenderer from "./../../video/canvas/canvas_renderer";
+import Tile from "./TMXTile.js";

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

@@ -0,0 +1,195 @@
+/**
+ * @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
+     * @public
+     * @type {object[]}
+     * @name points
+     * @memberof TMXObject
+     */
+    public points: object[];
+    /**
+     * object name
+     * @public
+     * @type {string}
+     * @name name
+     * @memberof TMXObject
+     */
+    public name: string;
+    /**
+     * object x position
+     * @public
+     * @type {number}
+     * @name x
+     * @memberof TMXObject
+     */
+    public x: number;
+    /**
+     * object y position
+     * @public
+     * @type {number}
+     * @name y
+     * @memberof TMXObject
+     */
+    public y: number;
+    /**
+     * object z order
+     * @public
+     * @type {number}
+     * @name z
+     * @memberof TMXObject
+     */
+    public z: number;
+    /**
+     * object width
+     * @public
+     * @type {number}
+     * @name width
+     * @memberof TMXObject
+     */
+    public width: number;
+    /**
+     * object height
+     * @public
+     * @type {number}
+     * @name height
+     * @memberof TMXObject
+     */
+    public height: number;
+    /**
+     * object gid value
+     * when defined the object is a tiled object
+     * @public
+     * @type {number}
+     * @name gid
+     * @memberof TMXObject
+     */
+    public gid: number;
+    /**
+     * tint color
+     * @public
+     * @type {string}
+     * @name tintcolor
+     * @memberof TMXObject
+     */
+    public 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;
+    /**
+     * the object class
+     * @public
+     * @type {string}
+     * @name class
+     * @memberof TMXObject
+     */
+    public 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;
+    /**
+     * The rotation of the object in radians clockwise (defaults to 0)
+     * @public
+     * @type {number}
+     * @name rotation
+     * @memberof TMXObject
+     */
+    public rotation: number;
+    /**
+     * object unique identifier per level (Tiled 0.11.x+)
+     * @public
+     * @type {number}
+     * @name id
+     * @memberof TMXObject
+     */
+    public id: number;
+    /**
+     * object orientation (orthogonal or isometric)
+     * @public
+     * @type {string}
+     * @name orientation
+     * @memberof TMXObject
+     */
+    public orientation: string;
+    /**
+     * the collision shapes defined for this object
+     * @public
+     * @type {object[]}
+     * @name shapes
+     * @memberof TMXObject
+     */
+    public shapes: object[];
+    /**
+     * if true, the object is an Ellipse
+     * @public
+     * @type {boolean}
+     * @name isEllipse
+     * @memberof TMXObject
+     */
+    public isEllipse: boolean;
+    /**
+     * if true, the object is a Point
+     * @public
+     * @type {boolean}
+     * @name isPoint
+     * @memberof TMXObject
+     */
+    public isPoint: boolean;
+    /**
+     * if true, the object is a Polygon
+     * @public
+     * @type {boolean}
+     * @name isPolygon
+     * @memberof TMXObject
+     */
+    public isPolygon: boolean;
+    /**
+     * if true, the object is a PolyLine
+     * @public
+     * @type {boolean}
+     * @name isPolyLine
+     * @memberof TMXObject
+     */
+    public 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
+     * @name parseTMXShapes
+     * @memberof TMXObject
+     * @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,78 @@
+/**
+ * @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
+     * @public
+     * @type {TMXTileset}
+     * @name Tile#tileset
+     */
+    public tileset: TMXTileset;
+    /**
+     * the tile transformation matrix (if defined)
+     * @ignore
+     */
+    currentTransform: Matrix2d | null;
+    col: number;
+    row: number;
+    /**
+     * tileId
+     * @public
+     * @type {number}
+     * @name Tile#tileId
+     */
+    public tileId: number;
+    /**
+     * True if the tile is flipped horizontally<br>
+     * @public
+     * @type {boolean}
+     * @name Tile#flipX
+     */
+    public flippedX: boolean;
+    /**
+     * True if the tile is flipped vertically<br>
+     * @public
+     * @type {boolean}
+     * @name Tile#flippedY
+     */
+    public flippedY: boolean;
+    /**
+     * True if the tile is flipped anti-diagonally<br>
+     * @public
+     * @type {boolean}
+     * @name Tile#flippedAD
+     */
+    public flippedAD: boolean;
+    /**
+     * Global flag that indicates if the tile is flipped<br>
+     * @public
+     * @type {boolean}
+     * @name Tile#flipped
+     */
+    public flipped: boolean;
+    /**
+     * set the transformation matrix for this tile
+     * @ignore
+     */
+    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;
+}
+import Bounds from "./../../physics/bounds.js";
+import Matrix2d from "./../../math/matrix2.js";