melonjs 14.2.0 → 14.4.0

package/dist/types/input/pointerevent.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Translate the specified x and y values from the global (absolute)
+ * coordinate to local (viewport) relative coordinate.
+ * @name globalToLocal
+ * @memberof input
+ * @public
+ * @param {number} x - the global x coordinate to be translated.
+ * @param {number} y - the global y coordinate to be translated.
+ * @param {Vector2d} [v] - an optional vector object where to set the translated coordinates
+ * @returns {Vector2d} A vector object with the corresponding translated coordinates
+ * @example
+ * onMouseEvent : function (pointer) {
+ *    // convert the given into local (viewport) relative coordinates
+ *    var pos = me.input.globalToLocal(pointer.clientX, pointer.clientY);
+ *    // do something with pos !
+ * };
+ */
+export function globalToLocal(x: number, y: number, v?: any): Vector2d;
+/**
+ * enable/disable all gestures on the given element.<br>
+ * by default melonJS will disable browser handling of all panning and zooming gestures.
+ * @name setTouchAction
+ * @memberof input
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/touch-action
+ * @public
+ * @param {HTMLCanvasElement} element
+ * @param {string} [value="none"]
+ */
+export function setTouchAction(element: HTMLCanvasElement, value?: string | undefined): void;
+/**
+ * Associate a pointer event to a keycode<br>
+ * Left button – 0
+ * Middle button – 1
+ * Right button – 2
+ * @name bindPointer
+ * @memberof input
+ * @public
+ * @param {number} [button=input.pointer.LEFT] - (accordingly to W3C values : 0,1,2 for left, middle and right buttons)
+ * @param {input.KEY} keyCode
+ * @example
+ * // enable the keyboard
+ * me.input.bindKey(me.input.KEY.X, "shoot");
+ * // map the left button click on the X key (default if the button is not specified)
+ * me.input.bindPointer(me.input.KEY.X);
+ * // map the right button click on the X key
+ * me.input.bindPointer(me.input.pointer.RIGHT, me.input.KEY.X);
+ */
+export function bindPointer(...args: any[]): void;
+/**
+ * unbind the defined keycode
+ * @name unbindPointer
+ * @memberof input
+ * @public
+ * @param {number} [button=input.pointer.LEFT] - (accordingly to W3C values : 0,1,2 for left, middle and right buttons)
+ * @example
+ * me.input.unbindPointer(me.input.pointer.LEFT);
+ */
+export function unbindPointer(button?: number | undefined): void;
+/**
+ * allows registration of event listeners on the object target. <br>
+ * melonJS will pass a me.Pointer object to the defined callback.
+ * @see Pointer
+ * @see {@link http://www.w3.org/TR/pointerevents/#list-of-pointer-events|W3C Pointer Event list}
+ * @name registerPointerEvent
+ * @memberof input
+ * @public
+ * @param {string} eventType - The event type for which the object is registering <br>
+ * melonJS currently supports: <br>
+ * <ul>
+ *   <li><code>"pointermove"</code></li>
+ *   <li><code>"pointerdown"</code></li>
+ *   <li><code>"pointerup"</code></li>
+ *   <li><code>"pointerenter"</code></li>
+ *   <li><code>"pointerover"</code></li>
+ *   <li><code>"pointerleave"</code></li>
+ *   <li><code>"pointercancel"</code></li>
+ *   <li><code>"wheel"</code></li>
+ * </ul>
+ * @param {Rect|Polygon|Line|Ellipse} region - a shape representing the region to register on
+ * @param {Function} callback - methods to be called when the event occurs.
+ * Returning `false` from the defined callback will prevent the event to be propagated to other objects
+ * @example
+ *  // onActivate function
+ *  onActivateEvent: function () {
+ *     // register on the 'pointerdown' event
+ *     me.input.registerPointerEvent('pointerdown', this, this.pointerDown.bind(this));
+ *  },
+ *
+ *  // pointerDown event callback
+ *  pointerDown: function (pointer) {
+ *    // do something
+ *    ....
+ *    // don"t propagate the event to other objects
+ *    return false;
+ *  },
+ */
+export function registerPointerEvent(eventType: string, region: Rect | Polygon | Line | Ellipse, callback: Function): void;
+/**
+ * allows the removal of event listeners from the object target.
+ * @see {@link http://www.w3.org/TR/pointerevents/#list-of-pointer-events|W3C Pointer Event list}
+ * @name releasePointerEvent
+ * @memberof input
+ * @public
+ * @param {string} eventType - The event type for which the object was registered. See {@link input.registerPointerEvent}
+ * @param {Rect|Polygon|Line|Ellipse} region - the registered region to release for this event
+ * @param {Function} [callback="all"] - if specified unregister the event only for the specific callback
+ * @example
+ * // release the registered region on the 'pointerdown' event
+ * me.input.releasePointerEvent('pointerdown', this);
+ */
+export function releasePointerEvent(eventType: string, region: Rect | Polygon | Line | Ellipse, callback?: Function | undefined): void;
+/**
+ * allows the removal of all registered event listeners from the object target.
+ * @name releaseAllPointerEvents
+ * @memberof input
+ * @public
+ * @param {Rect|Polygon|Line|Ellipse} region - the registered region to release event from
+ * @example
+ * // release all registered event on the
+ * me.input.releaseAllPointerEvents(this);
+ */
+export function releaseAllPointerEvents(region: Rect | Polygon | Line | Ellipse): void;
+/**
+ * request for the pointer to be locked on the parent DOM element.
+ * (Must be called in a click event or an event that requires user interaction)
+ * @name requestPointerLock
+ * @memberof input
+ * @public
+ * @returns {boolean} return true if the request was successfully submitted
+ * @example
+ * // register on the pointer lock change event
+ * event.on(event.POINTERLOCKCHANGE, (locked)=> {
+ *     console.log("pointer lock: " + locked);
+ * });
+ * // request for pointer lock
+ * me.input.requestPointerLock();
+ */
+export function requestPointerLock(): boolean;
+/**
+ * Initiates an exit from pointer lock state
+ * @name exitPointerLock
+ * @memberof input
+ * @public
+ * @returns {boolean} return true if the request was successfully submitted
+ */
+export function exitPointerLock(): boolean;
+/**
+ * the default target element for pointer events (usually the canvas element in which the game is rendered)
+ * @public
+ * @type {EventTarget}
+ * @name pointerEventTarget
+ * @memberof input
+ */
+export const pointerEventTarget: EventTarget;
+/**
+ * Pointer information (current position and size)
+ * @public
+ * @type {Rect}
+ * @name pointer
+ * @memberof input
+ */
+export const pointer: Rect;
+/**
+ * indicates if the pointer is currently locked
+ * @public
+ * @type {boolean}
+ * @name locked
+ * @memberof input
+ */
+export const locked: boolean;
+/**
+ * time interval for event throttling in milliseconds<br>
+ * default value : "1000/me.timer.maxfps" ms<br>
+ * set to 0 ms to disable the feature
+ * @public
+ * @type {number}
+ * @name throttlingInterval
+ * @memberof input
+ */
+export const throttlingInterval: number;
+import Rect from "./../geometries/rectangle.js";

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

@@ -0,0 +1,45 @@
+/**
+ * @classdesc
+ * Used to make a game entity draggable
+ * @augments Entity
+ * @deprecated since 10.5.0
+ * @see Draggable
+ */
+export class DraggableEntity {
+    /**
+     * @param {number} x - the x coordinates of the draggable object
+     * @param {number} y - the y coordinates of the draggable object
+     * @param {object} settings - Entity properties (see {@link Entity})
+     */
+    constructor(x: number, y: number, settings: object);
+}
+/**
+ * @classdesc
+ * Used to make a game entity a droptarget
+ * @augments Entity
+ * @deprecated since 10.5.0
+ * @see DropTarget
+ */
+export class DroptargetEntity {
+    /**
+     * @param {number} x - the x coordinates of the draggable object
+     * @param {number} y - the y coordinates of the draggable object
+     * @param {object} settings - Entity properties (see {@link Entity})
+     */
+    constructor(x: number, y: number, settings: object);
+}
+/**
+ * @classdesc
+ * A very basic object to manage GUI elements
+ * @augments Sprite
+ * @deprecated since 14.0.0
+ * @see UISpriteElement
+ */
+export class GUI_Object {
+    /**
+     * @param {number} x - the x coordinate of the GUI Object
+     * @param {number} y - the y coordinate of the GUI Object
+     * @param {object} settings - See {@link Sprite}
+     */
+    constructor(x: number, y: number, settings: object);
+}

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,61 @@
+/**
+ * @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
+     * @type {string}
+     */
+    name: string;
+    /**
+     * group width
+     * @type {number}
+     */
+    width: number;
+    /**
+     * group height
+     * @type {number}
+     */
+    height: number;
+    /**
+     * tint color
+     * @type {string}
+     */
+    tintcolor: string;
+    /**
+     * the group class
+     * @type {string}
+     */
+    class: string;
+    /**
+     * group z order
+     * @type {number}
+     */
+    z: number;
+    /**
+     * group objects list definition
+     * @see TMXObject
+     * @type {object[]}
+     */
+    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,158 @@
+/**
+ * @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;
+    /**
+     * 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
+     * @type {TMXTilesetGroup}
+     */
+    tilesets: TMXTilesetGroup;
+    tileset: any;
+    maxTileSize: {
+        width: number;
+        height: number;
+    };
+    /**
+     * All animated tilesets in this layer
+     * @type {TMXTileset[]}
+     */
+    animatedTilesets: TMXTileset[];
+    /**
+     * Layer contains tileset animations
+     * @type {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")
+     * @type {string}
+     * @default "right-down"
+     */
+    renderorder: string;
+    /**
+     * the layer class
+     * @type {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
+     * @param {TMXRenderer} renderer
+     * @example
+     * // use the parent map default renderer
+     * var layer = new me.TMXLayer(...);
+     * layer.setRenderer(map.getRenderer());
+     */
+    setRenderer(renderer: TMXRenderer): void;
+    renderer: any;
+    /**
+     * Return the layer current renderer object
+     * @returns {TMXRenderer} renderer
+     */
+    getRenderer(): TMXRenderer;
+    /**
+     * Return the TileId of the Tile at the specified position
+     * @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
+     */
+    getTileId(x: number, y: number): number;
+    /**
+     * Return the Tile object at the specified position
+     * @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);
+     */
+    getTile(x: number, y: number): Tile;
+    /**
+     * assign the given Tile object to the specified position
+     * @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
+     */
+    setTile(tile: Tile, x: number, y: number): Tile;
+    /**
+     * return a new the Tile object corresponding to the given tile id
+     * @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
+     */
+    getTileById(tileId: number, x: number, y: number): Tile;
+    /**
+     * Return the Tile object at the specified tile coordinates
+     * @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);
+     */
+    cellAt(x: number, y: number, boundsCheck?: number | undefined): Tile;
+    /**
+     * clear the tile at the specified position
+     * @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);
+     * });
+     */
+    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";