melonjs 14.1.2 → 14.3.0

package/dist/types/system/event.d.ts

@@ -0,0 +1,473 @@
+/**
+ * calls each of the listeners registered for a given event.
+ * @function event.emit
+ * @param {string|symbol} eventName - The event name.
+ * @param {object} [...arguments] - arguments to be passed to all listeners
+ * @returns {boolean} true if the event had listeners, false otherwise.
+ * @example
+ * me.event.emit("event-name", a, b, c);
+ */
+export function emit(eventName: string | symbol, ...args: any[]): boolean;
+/**
+ * Add a listener for a given event.
+ * @function event.on
+ * @param {string|symbol} eventName - The event name.
+ * @param {Function} listener - The listener function.
+ * @param {*} [context=this] - The context to invoke the listener with.
+ * @returns {EventEmitter} `this`.
+ * @public
+ * @example
+ * me.event.on("event-name", myFunction, this);
+ */
+export function on(eventName: string | symbol, listener: Function, context?: any): EventEmitter;
+/**
+ * Add a one-time listener for a given event.
+ * @function event.once
+ * @param {string|symbol} eventName - The event name.
+ * @param {Function} listener - The listener function.
+ * @param {*} [context=this] - The context to invoke the listener with.
+ * @returns {EventEmitter} `this`.
+ * @public
+ * @example
+ * me.event.once("event-name", myFunction, this);
+ */
+export function once(eventName: string | symbol, listener: Function, context?: any): EventEmitter;
+/**
+ * remove the given listener for a given event.
+ * @function event.off
+ * @param {string|symbol} eventName - The event name.
+ * @param {Function} listener - The listener function.
+ * @returns {EventEmitter} `this`.
+ * @public
+ * @example
+ * me.event.off("event-name", myFunction);
+ */
+export function off(eventName: string | symbol, listener: Function): EventEmitter;
+/**
+ * event when the DOM is Ready is booting
+ * @public
+ * @constant
+ * @type {string}
+ * @name DOM_READY
+ * @memberof event
+ * @see event.on
+ */
+export const DOM_READY: string;
+/**
+ * event when the system is booting
+ * @public
+ * @constant
+ * @type {string}
+ * @name BOOT
+ * @memberof event
+ * @see event.on
+ */
+export const BOOT: string;
+/**
+ * event when the game is paused <br>
+ * Data passed : none <br>
+ * @public
+ * @constant
+ * @type {string}
+ * @name STATE_PAUSE
+ * @memberof event
+ * @see event.on
+ */
+export const STATE_PAUSE: string;
+/**
+ * event for when the game is resumed <br>
+ * Data passed : {number} time in ms the game was paused
+ * @public
+ * @constant
+ * @type {string}
+ * @name STATE_RESUME
+ * @memberof event
+ * @see event.on
+ */
+export const STATE_RESUME: string;
+/**
+ * event when the game is stopped <br>
+ * Data passed : none <br>
+ * @public
+ * @constant
+ * @type {string}
+ * @name STATE_STOP
+ * @memberof event
+ * @see event.on
+ */
+export const STATE_STOP: string;
+/**
+ * event for when the game is restarted <br>
+ * Data passed : {number} time in ms the game was stopped
+ * @public
+ * @constant
+ * @type {string}
+ * @name STATE_RESTART
+ * @memberof event
+ * @see event.on
+ */
+export const STATE_RESTART: string;
+/**
+ * event for when the changing to a different stage
+ * @public
+ * @constant
+ * @type {string}
+ * @name STATE_CHANGE
+ * @memberof event
+ * @see event.on
+ */
+export const STATE_CHANGE: string;
+/**
+ * event for when the video is initialized<br>
+ * Data passed : none <br>
+ * @public
+ * @constant
+ * @type {string}
+ * @name VIDEO_INIT
+ * @memberof event
+ * @see video.init
+ * @see event.on
+ */
+export const VIDEO_INIT: string;
+/**
+ * event for when the game manager is initialized <br>
+ * Data passed : none <br>
+ * @public
+ * @constant
+ * @type {string}
+ * @name GAME_INIT
+ * @memberof event
+ * @see event.on
+ */
+export const GAME_INIT: string;
+/**
+ * event for when the game manager is resetted <br>
+ * Data passed : none <br>
+ * @public
+ * @constant
+ * @type {string}
+ * @name GAME_RESET
+ * @memberof event
+ * @see event.on
+ */
+export const GAME_RESET: string;
+/**
+ * event for when the engine is about to start a new game loop
+ * Data passed : {number} time the current time stamp
+ * @public
+ * @constant
+ * @type {string}
+ * @name GAME_BEFORE_UPDATE
+ * @memberof event
+ * @see event.on
+ */
+export const GAME_BEFORE_UPDATE: string;
+/**
+ * event for the end of the update loop
+ * Data passed : {number} time the current time stamp
+ * @public
+ * @constant
+ * @type {string}
+ * @name GAME_AFTER_UPDATE
+ * @memberof event
+ * @see event.on
+ */
+export const GAME_AFTER_UPDATE: string;
+/**
+ * Event for when the game is updated (will be impacted by frame skip, frame interpolation and pause/resume state) <br>
+ * Data passed : {number} time the current time stamp
+ * @public
+ * @constant
+ * @type {string}
+ * @name GAME_UPDATE
+ * @memberof event
+ * @see event.on
+ */
+export const GAME_UPDATE: string;
+/**
+ * Event for the end of the draw loop
+ * Data passed : {number} time the current time stamp
+ * @public
+ * @constant
+ * @type {string}
+ * @name GAME_BEFORE_DRAW
+ * @memberof event
+ * @see event.on
+ */
+export const GAME_BEFORE_DRAW: string;
+/**
+ * Event for the start of the draw loop
+ * Data passed : {number} time the current time stamp
+ * @public
+ * @constant
+ * @type {string}
+ * @name GAME_AFTER_DRAW
+ * @memberof event
+ * @see event.on
+ */
+export const GAME_AFTER_DRAW: string;
+/**
+ * Event for when a level is loaded <br>
+ * Data passed : {string} Level Name
+ * @public
+ * @constant
+ * @type {string}
+ * @name LEVEL_LOADED
+ * @memberof event
+ * @see event.on
+ */
+export const LEVEL_LOADED: string;
+/**
+ * Event for when everything has loaded <br>
+ * Data passed : none <br>
+ * @public
+ * @constant
+ * @type {string}
+ * @name LOADER_COMPLETE
+ * @memberof event
+ * @see event.on
+ */
+export const LOADER_COMPLETE: string;
+/**
+ * Event for displaying a load progress indicator <br>
+ * Data passed : {number} [0 .. 1], {Resource} resource object<br>
+ * @public
+ * @constant
+ * @type {string}
+ * @name LOADER_PROGRESS
+ * @memberof event
+ * @see event.on
+ */
+export const LOADER_PROGRESS: string;
+/**
+ * Event for pressing a binded key <br>
+ * Data passed : {string} user-defined action, {number} keyCode,
+ * {boolean} edge state <br>
+ * Edge-state is for detecting "locked" key bindings. When a locked key
+ * is pressed and held, the first event will have the third argument
+ * set true. Subsequent events will continue firing with the third
+ * argument set false.
+ * @public
+ * @constant
+ * @type {string}
+ * @name KEYDOWN
+ * @memberof event
+ * @see event.on
+ * @example
+ * me.input.bindKey(me.input.KEY.X, "jump", true); // Edge-triggered
+ * me.input.bindKey(me.input.KEY.Z, "shoot"); // Level-triggered
+ * me.event.on(me.event.KEYDOWN, (action, keyCode, edge) => {
+ *   // Checking bound keys
+ *   if (action === "jump") {
+ *       if (edge) {
+ *           this.doJump();
+ *       }
+ *
+ *       // Make character fall slower when holding the jump key
+ *       this.vel.y = this.body.gravity;
+ *   }
+ * });
+ */
+export const KEYDOWN: string;
+/**
+ * Event for releasing a binded key <br>
+ * Data passed : {string} user-defined action, {number} keyCode
+ * @public
+ * @constant
+ * @type {string}
+ * @name KEYUP
+ * @memberof event
+ * @see event.on
+ * @example
+ * me.event.on(me.event.KEYUP, (action, keyCode) => {
+ *   // Checking unbound keys
+ *   if (keyCode == me.input.KEY.ESC) {
+ *       if (me.state.isPaused()) {
+ *           me.state.resume();
+ *       }
+ *       else {
+ *           me.state.pause();
+ *       }
+ *   }
+ * });
+ */
+export const KEYUP: string;
+/**
+ * Event for when a gamepad is connected <br>
+ * Data passed : {object} gamepad object
+ * @public
+ * @constant
+ * @type {string}
+ * @name GAMEPAD_CONNECTED
+ * @memberof event
+ * @see event.on
+ */
+export const GAMEPAD_CONNECTED: string;
+/**
+ * Event for when a gamepad is disconnected <br>
+ * Data passed : {object} gamepad object
+ * @public
+ * @constant
+ * @type {string}
+ * @name GAMEPAD_DISCONNECTED
+ * @memberof event
+ * @see event.on
+ */
+export const GAMEPAD_DISCONNECTED: string;
+/**
+ * Event for when gamepad button/axis state is updated <br>
+ * Data passed : {number} index <br>
+ * Data passed : {string} type : "axes" or "buttons" <br>
+ * Data passed : {number} button <br>
+ * Data passed : {number} current.value <br>
+ * Data passed : {boolean} current.pressed
+ * @public
+ * @constant
+ * @type {string}
+ * @name GAMEPAD_UPDATE
+ * @memberof event
+ * @see event.on
+ */
+export const GAMEPAD_UPDATE: string;
+/**
+ * Event for pointermove events on the screen area <br>
+ * Data passed : {me.Pointer} a Pointer object
+ * @public
+ * @constant
+ * @type {string}
+ * @name POINTERMOVE
+ * @memberof event
+ * @see event.on
+ */
+export const POINTERMOVE: string;
+/**
+ * Event for onPointerLockChange event <br>
+ * Data passed : {boolean} pointer lock status (true/false)
+ * @public
+ * @constant
+ * @type {string}
+ * @name POINTERLOCKCHANGE
+ * @memberof event
+ * @see event.on
+ */
+export const POINTERLOCKCHANGE: string;
+/**
+ * Event for dragstart events on a Draggable entity <br>
+ * Data passed:
+ * {object} the drag event <br>
+ * {object} the Draggable entity
+ * @public
+ * @constant
+ * @type {string}
+ * @name DRAGSTART
+ * @memberof event
+ * @see event.on
+ */
+export const DRAGSTART: string;
+/**
+ * Event for dragend events on a Draggable entity <br>
+ * Data passed:
+ * {object} the drag event <br>
+ * {object} the Draggable entity
+ * @public
+ * @constant
+ * @type {string}
+ * @name DRAGEND
+ * @memberof event
+ * @see event.on
+ */
+export const DRAGEND: string;
+/**
+ * Event for when the (browser) window is resized <br>
+ * Data passed : {Event} Event object
+ * @public
+ * @constant
+ * @type {string}
+ * @name WINDOW_ONRESIZE
+ * @memberof event
+ * @see event.on
+ */
+export const WINDOW_ONRESIZE: string;
+/**
+ * Event for when the canvas is resized <br>
+ * (this usually follows a WINDOW_ONRESIZE event).<br>
+ * Data passed : {number} canvas width <br>
+ * Data passed : {number} canvas height
+ * @public
+ * @constant
+ * @type {string}
+ * @name CANVAS_ONRESIZE
+ * @memberof event
+ * @see event.on
+ */
+export const CANVAS_ONRESIZE: string;
+/**
+ * Event for when the viewport is resized <br>
+ * (this usually follows a WINDOW_ONRESIZE event, when using the `flex` scaling mode is used and after the viewport was updated).<br>
+ * Data passed : {number} viewport width <br>
+ * Data passed : {number} viewport height <br>
+ * Data passed : {Camera2d} a reference to the camera viewport being resized
+ * @public
+ * @constant
+ * @type {string}
+ * @name VIEWPORT_ONRESIZE
+ * @memberof event
+ * @see event.on
+ */
+export const VIEWPORT_ONRESIZE: string;
+/**
+ * Event for when the device is rotated <br>
+ * Data passed : {Event} Event object <br>
+ * @public
+ * @constant
+ * @type {string}
+ * @name WINDOW_ONORIENTATION_CHANGE
+ * @memberof event
+ * @see event.on
+ */
+export const WINDOW_ONORIENTATION_CHANGE: string;
+/**
+ * Event for when the (browser) window is scrolled <br>
+ * Data passed : {Event} Event object
+ * @public
+ * @constant
+ * @type {string}
+ * @name WINDOW_ONSCROLL
+ * @memberof event
+ * @see event.on
+ */
+export const WINDOW_ONSCROLL: string;
+/**
+ * Event for when the viewport position is updated <br>
+ * Data passed : {me.Vector2d} viewport position vector
+ * @public
+ * @constant
+ * @type {string}
+ * @name VIEWPORT_ONCHANGE
+ * @memberof event
+ * @see event.on
+ */
+export const VIEWPORT_ONCHANGE: string;
+/**
+ * Event for when the current context is lost <br>
+ * Data passed : {me.Renderer} the current renderer instance
+ * @public
+ * @constant
+ * @type {string}
+ * @name WEBGL_ONCONTEXT_LOST
+ * @memberof event
+ * @see event.on
+ */
+export const ONCONTEXT_LOST: string;
+/**
+ * Event for when the current context is restored <br>
+ * Data passed : {me.Renderer} the current renderer instance`
+ * @public
+ * @constant
+ * @type {string}
+ * @name ONCONTEXT_RESTORED
+ * @memberof event
+ * @see event.on
+ */
+export const ONCONTEXT_RESTORED: string;
+import EventEmitter from "eventemitter3";

package/dist/types/system/platform.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The device platform type
+ * @namespace platform
+ * @memberof device
+ * @property {string} ua the user agent string for the current device
+ * @property {boolean} iOS `true` if the device is an iOS platform
+ * @property {boolean} android `true` if the device is an Android platform
+ * @property {boolean} android2 `true` if the device is an Android 2.x platform
+ * @property {boolean} linux `true` if the device is a Linux platform
+ * @property {boolean} chromeOS `true` if the device is running on ChromeOS.
+ * @property {boolean} wp `true` if the device is a Windows Phone platform
+ * @property {boolean} BlackBerry`true` if the device is a BlackBerry platform
+ * @property {boolean} Kindle`true` if the device is a Kindle platform
+ * @property {boolean} ejecta `true` if running under Ejecta
+ * @property {boolean} isWeixin `true` if running under Wechat
+ * @property {boolean} nodeJS `true` if running under node.js
+ * @property {boolean} isMobile `true` if a mobile device
+ */
+export const ua: string;
+export const iOS: boolean;
+export const android: boolean;
+export const android2: boolean;
+export const linux: boolean;
+export const chromeOS: boolean;
+export const wp: boolean;
+export const BlackBerry: boolean;
+export const Kindle: boolean;
+export const ejecta: boolean;
+export const isWeixin: boolean;
+export const nodeJS: boolean;
+export const isMobile: boolean;

package/dist/types/system/pooling.d.ts

@@ -0,0 +1,101 @@
+export default pool;
+declare var pool: ObjectPool;
+/**
+ * @classdesc
+ * Object pooling - a technique that might speed up your game if used properly.<br>
+ * If some of your classes will be instantiated and removed a lot at a time, it is a
+ * good idea to add the class to this object pool. A separate pool for that class
+ * will be created, which will reuse objects of the class. That way they won't be instantiated
+ * each time you need a new one (slowing your game), but stored into that pool and taking one
+ * already instantiated when you need it.<br><br>
+ * This technique is also used by the engine to instantiate objects defined in the map,
+ * which means, that on level loading the engine will try to instantiate every object
+ * found in the map, based on the user defined name in each Object Properties<br>
+ * <img src="images/object_properties.png"/><br>
+ * @see {@link pool} the default global instance of ObjectPool
+ */
+declare class ObjectPool {
+    objectClass: {};
+    instance_counter: number;
+    /**
+     * register an object to the pool. <br>
+     * Pooling must be set to true if more than one such objects will be created. <br>
+     * (Note: for an object to be poolable, it must implements a `onResetEvent` method)
+     * @param {string} className - as defined in the Name field of the Object Properties (in Tiled)
+     * @param {object} classObj - corresponding Class to be instantiated
+     * @param {boolean} [recycling=false] - enables object recycling for the specified class
+     * @example
+     * // implement CherryEntity
+     * class CherryEntity extends Spritesheet {
+     *    onResetEvent() {
+     *        // reset object mutable properties
+     *        this.lifeBar = 100;
+     *    }
+     * };
+     * // add our users defined entities in the object pool and enable object recycling
+     * me.pool.register("cherryentity", CherryEntity, true);
+     */
+    register(className: string, classObj: object, recycling?: boolean | undefined): void;
+    /**
+     * Pull a new instance of the requested object (if added into the object pool)
+     * @param {string} name - as used in {@link pool.register}
+     * @param {object} [...arguments] - arguments to be passed when instantiating/reinitializing the object
+     * @returns {object} the instance of the requested object
+     * @example
+     * me.pool.register("bullet", BulletEntity, true);
+     * me.pool.register("enemy", EnemyEntity, true);
+     * // ...
+     * // when we need to manually create a new bullet:
+     * var bullet = me.pool.pull("bullet", x, y, direction);
+     * // ...
+     * // params aren't a fixed number
+     * // when we need new enemy we can add more params, that the object construct requires:
+     * var enemy = me.pool.pull("enemy", x, y, direction, speed, power, life);
+     * // ...
+     * // when we want to destroy existing object, the remove
+     * // function will ensure the object can then be reallocated later
+     * me.game.world.removeChild(enemy);
+     * me.game.world.removeChild(bullet);
+     */
+    pull(name: string, ...args: any[]): object;
+    /**
+     * purge the object pool from any inactive object <br>
+     * Object pooling must be enabled for this function to work<br>
+     * note: this will trigger the garbage collector
+     */
+    purge(): void;
+    /**
+     * Push back an object instance into the object pool <br>
+     * Object pooling for the object class must be enabled,
+     * and object must have been instantiated using {@link pool#pull},
+     * otherwise this function won't work
+     * @throws will throw an error if the object cannot be recycled
+     * @param {object} obj - instance to be recycled
+     * @param {boolean} [throwOnError=true] - throw an exception if the object cannot be recycled
+     * @returns {boolean} true if the object was successfully recycled in the object pool
+     */
+    push(obj: object, throwOnError?: boolean | undefined): boolean;
+    /**
+     * Check if an object with the provided name is registered
+     * @param {string} name - of the registered object class
+     * @returns {boolean} true if the classname is registered
+     */
+    exists(name: string): boolean;
+    /**
+     * Check if an object is poolable
+     * (was properly registered with the recycling feature enable)
+     * @see register
+     * @param {object} obj - object to be checked
+     * @returns {boolean} true if the object is poolable
+     * @example
+     * if (!me.pool.poolable(myCherryEntity)) {
+     *     // object was not properly registered
+     * }
+     */
+    poolable(obj: object): boolean;
+    /**
+     * returns the amount of object instance currently in the pool
+     * @returns {number} amount of object instance
+     */
+    getInstanceCount(): number;
+}

package/dist/types/system/save.d.ts

@@ -0,0 +1,25 @@
+export default save;
+declare namespace save {
+    /**
+     * Add new keys to localStorage and set them to the given default values if they do not exist
+     * @name add
+     * @memberof save
+     * @param {object} props - key and corresponding values
+     * @example
+     * // Initialize "score" and "lives" with default values
+     * me.save.add({ score : 0, lives : 3 });
+     * // get or set the value through me.save
+     * me.save.score = 1000;
+     */
+    function add(props: object): void;
+    /**
+     * Remove a key from localStorage
+     * @name remove
+     * @memberof save
+     * @param {string} key - key to be removed
+     * @example
+     * // Remove the "score" key from localStorage
+     * me.save.remove("score");
+     */
+    function remove(key: string): void;
+}