melonjs 14.2.0 → 14.3.0

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

@@ -0,0 +1,205 @@
+/**
+ * enable keyboard event
+ * @ignore
+ */
+export function initKeyboardEvent(): void;
+/**
+ * return the key press status of the specified action
+ * @name isKeyPressed
+ * @memberof input
+ * @public
+ * @param {string} action - user defined corresponding action
+ * @returns {boolean} true if pressed
+ * @example
+ * if (me.input.isKeyPressed('left')) {
+ *    //do something
+ * }
+ * else if (me.input.isKeyPressed('right')) {
+ *    //do something else...
+ * }
+ */
+export function isKeyPressed(action: string): boolean;
+/**
+ * return the key status of the specified action
+ * @name keyStatus
+ * @memberof input
+ * @public
+ * @param {string} action - user defined corresponding action
+ * @returns {boolean} down (true) or up(false)
+ */
+export function keyStatus(action: string): boolean;
+/**
+ * trigger the specified key (simulated) event <br>
+ * @name triggerKeyEvent
+ * @memberof input
+ * @public
+ * @param {number} keycode - (See {@link input.KEY})
+ * @param {boolean} [status=false] - true to trigger a key down event, or false for key up event
+ * @param {number} [mouseButton] - the mouse button to trigger
+ * @example
+ * // trigger a key press
+ * me.input.triggerKeyEvent(me.input.KEY.LEFT, true);
+ */
+export function triggerKeyEvent(keycode: number, status?: boolean | undefined, mouseButton?: number | undefined): void;
+/**
+ * associate a user defined action to a keycode
+ * @name bindKey
+ * @memberof input
+ * @public
+ * @param {number} keycode - (See {@link input.KEY})
+ * @param {string} action - user defined corresponding action
+ * @param {boolean} [lock=false] - cancel the keypress event once read
+ * @param {boolean} [preventDefault=input.preventDefault] - prevent default browser action
+ * @example
+ * // enable the keyboard
+ * me.input.bindKey(me.input.KEY.LEFT,  "left");
+ * me.input.bindKey(me.input.KEY.RIGHT, "right");
+ * me.input.bindKey(me.input.KEY.X,     "jump", true);
+ * me.input.bindKey(me.input.KEY.F1,    "options", true, true);
+ */
+export function bindKey(keycode: number, action: string, lock?: boolean | undefined, preventDefault?: boolean | undefined): void;
+/**
+ * return the action associated with the given keycode
+ * @name getBindingKey
+ * @memberof input
+ * @public
+ * @param {number} keycode - (See {@link input.KEY})
+ * @returns {string} user defined associated action
+ */
+export function getBindingKey(keycode: number): string;
+/**
+ * unlock a key manually
+ * @name unlockKey
+ * @memberof input
+ * @public
+ * @param {string} action - user defined corresponding action
+ * @example
+ * // Unlock jump when touching the ground
+ * if (!this.falling && !this.jumping) {
+ *     me.input.unlockKey("jump");
+ * }
+ */
+export function unlockKey(action: string): void;
+/**
+ * unbind the defined keycode
+ * @name unbindKey
+ * @memberof input
+ * @public
+ * @param {number} keycode - (See {@link input.KEY})
+ * @example
+ * me.input.unbindKey(me.input.KEY.LEFT);
+ */
+export function unbindKey(keycode: number): void;
+/**
+ * the default target element for keyboard events (usually the window element in which the game is running)
+ * @public
+ * @type {EventTarget}
+ * @name keyBoardEventTarget
+ * @memberof input
+ */
+export const keyBoardEventTarget: EventTarget;
+/**
+ * *
+ */
+export type KEY = number;
+export namespace KEY {
+    const BACKSPACE: number;
+    const TAB: number;
+    const ENTER: number;
+    const SHIFT: number;
+    const CTRL: number;
+    const ALT: number;
+    const PAUSE: number;
+    const CAPS_LOCK: number;
+    const ESC: number;
+    const SPACE: number;
+    const PAGE_UP: number;
+    const PAGE_DOWN: number;
+    const END: number;
+    const HOME: number;
+    const LEFT: number;
+    const UP: number;
+    const RIGHT: number;
+    const DOWN: number;
+    const PRINT_SCREEN: number;
+    const INSERT: number;
+    const DELETE: number;
+    const NUM0: number;
+    const NUM1: number;
+    const NUM2: number;
+    const NUM3: number;
+    const NUM4: number;
+    const NUM5: number;
+    const NUM6: number;
+    const NUM7: number;
+    const NUM8: number;
+    const NUM9: number;
+    const A: number;
+    const B: number;
+    const C: number;
+    const D: number;
+    const E: number;
+    const F: number;
+    const G: number;
+    const H: number;
+    const I: number;
+    const J: number;
+    const K: number;
+    const L: number;
+    const M: number;
+    const N: number;
+    const O: number;
+    const P: number;
+    const Q: number;
+    const R: number;
+    const S: number;
+    const T: number;
+    const U: number;
+    const V: number;
+    const W: number;
+    const X: number;
+    const Y: number;
+    const Z: number;
+    const WINDOW_KEY: number;
+    const NUMPAD0: number;
+    const NUMPAD1: number;
+    const NUMPAD2: number;
+    const NUMPAD3: number;
+    const NUMPAD4: number;
+    const NUMPAD5: number;
+    const NUMPAD6: number;
+    const NUMPAD7: number;
+    const NUMPAD8: number;
+    const NUMPAD9: number;
+    const MULTIPLY: number;
+    const ADD: number;
+    const SUBSTRACT: number;
+    const DECIMAL: number;
+    const DIVIDE: number;
+    const F1: number;
+    const F2: number;
+    const F3: number;
+    const F4: number;
+    const F5: number;
+    const F6: number;
+    const F7: number;
+    const F8: number;
+    const F9: number;
+    const F10: number;
+    const F11: number;
+    const F12: number;
+    const TILDE: number;
+    const NUM_LOCK: number;
+    const SCROLL_LOCK: number;
+    const SEMICOLON: number;
+    const PLUS: number;
+    const COMMA: number;
+    const MINUS: number;
+    const PERIOD: number;
+    const FORWAND_SLASH: number;
+    const GRAVE_ACCENT: number;
+    const OPEN_BRACKET: number;
+    const BACK_SLASH: number;
+    const CLOSE_BRACKET: number;
+    const SINGLE_QUOTE: number;
+}

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

@@ -0,0 +1,270 @@
+export default Pointer;
+/**
+ * @classdesc
+ * a pointer object, representing a single finger on a touch enabled device.
+ * @class Pointer
+ * @augments Bounds
+ */
+declare class Pointer extends Bounds {
+    /**
+     * @ignore
+     */
+    constructor(x?: number, y?: number, w?: number, h?: number);
+    /**
+     * constant for left button
+     * @public
+     * @type {number}
+     * @name LEFT
+     * @memberof Pointer
+     */
+    public LEFT: number;
+    /**
+     * constant for middle button
+     * @public
+     * @type {number}
+     * @name MIDDLE
+     * @memberof Pointer
+     */
+    public MIDDLE: number;
+    /**
+     * constant for right button
+     * @public
+     * @type {number}
+     * @name RIGHT
+     * @memberof Pointer
+     */
+    public RIGHT: number;
+    /**
+     * the originating Event Object
+     * @public
+     * @type {PointerEvent|TouchEvent|MouseEvent}
+     * @name event
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent
+     * @memberof Pointer
+     */
+    public event: PointerEvent | TouchEvent | MouseEvent;
+    /**
+     * a string containing the event's type.
+     * @public
+     * @type {string}
+     * @name type
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Event/type
+     * @memberof Pointer
+     */
+    public type: string;
+    /**
+     * the button property indicates which button was pressed on the mouse to trigger the event.
+     * @public
+     * @type {number}
+     * @name button
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
+     * @memberof Pointer
+     */
+    public button: number;
+    /**
+     * indicates whether or not the pointer device that created the event is the primary pointer.
+     * @public
+     * @type {boolean}
+     * @name isPrimary
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/isPrimary
+     * @memberof Pointer
+     */
+    public isPrimary: boolean;
+    /**
+     * the horizontal coordinate at which the event occurred, relative to the left edge of the entire document.
+     * @public
+     * @type {number}
+     * @name pageX
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/pageX
+     * @memberof Pointer
+     */
+    public pageX: number;
+    /**
+     * the vertical coordinate at which the event occurred, relative to the left edge of the entire document.
+     * @public
+     * @type {number}
+     * @name pageY
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/pageY
+     * @memberof Pointer
+     */
+    public pageY: number;
+    /**
+     * the horizontal coordinate within the application's client area at which the event occurred
+     * @public
+     * @type {number}
+     * @name clientX
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/clientX
+     * @memberof Pointer
+     */
+    public clientX: number;
+    /**
+     * the vertical coordinate within the application's client area at which the event occurred
+     * @public
+     * @type {number}
+     * @name clientY
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/clientY
+     * @memberof Pointer
+     */
+    public clientY: number;
+    /**
+     * the difference in the X coordinate of the pointer since the previous move event
+     * @public
+     * @type {number}
+     * @name movementX
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/movementX
+     * @memberof Pointer
+     */
+    public movementX: number;
+    /**
+     * the difference in the Y coordinate of the pointer since the previous move event
+     * @public
+     * @type {number}
+     * @name movementY
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/movementY
+     * @memberof Pointer
+     */
+    public movementY: number;
+    /**
+     * an unsigned long representing the unit of the delta values scroll amount
+     * @public
+     * @type {number}
+     * @name deltaMode
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaMode
+     * @memberof Pointer
+     */
+    public deltaMode: number;
+    /**
+     * a double representing the horizontal scroll amount in the Wheel Event deltaMode unit.
+     * @public
+     * @type {number}
+     * @name deltaX
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaX
+     * @memberof Pointer
+     */
+    public deltaX: number;
+    /**
+     * a double representing the vertical scroll amount in the Wheel Event deltaMode unit.
+     * @public
+     * @type {number}
+     * @name deltaY
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaY
+     * @memberof Pointer
+     */
+    public deltaY: number;
+    /**
+     * a double representing the scroll amount in the z-axis, in the Wheel Event deltaMode unit.
+     * @public
+     * @type {number}
+     * @name deltaZ
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaZ
+     * @memberof Pointer
+     */
+    public deltaZ: number;
+    /**
+     * Event normalized X coordinate within the game canvas itself<br>
+     * <img src="images/event_coord.png"/>
+     * @public
+     * @type {number}
+     * @name gameX
+     * @memberof Pointer
+     */
+    public gameX: number;
+    /**
+     * Event normalized Y coordinate within the game canvas itself<br>
+     * <img src="images/event_coord.png"/>
+     * @public
+     * @type {number}
+     * @name gameY
+     * @memberof Pointer
+     */
+    public gameY: number;
+    /**
+     * Event X coordinate relative to the viewport
+     * @public
+     * @type {number}
+     * @name gameScreenX
+     * @memberof Pointer
+     */
+    public gameScreenX: number;
+    /**
+     * Event Y coordinate relative to the viewport
+     * @public
+     * @type {number}
+     * @name gameScreenY
+     * @memberof Pointer
+     */
+    public gameScreenY: number;
+    /**
+     * Event X coordinate relative to the map
+     * @public
+     * @type {number}
+     * @name gameWorldX
+     * @memberof Pointer
+     */
+    public gameWorldX: number;
+    /**
+     * Event Y coordinate relative to the map
+     * @public
+     * @type {number}
+     * @name gameWorldY
+     * @memberof Pointer
+     */
+    public gameWorldY: number;
+    /**
+     * Event X coordinate relative to the holding container
+     * @public
+     * @type {number}
+     * @name gameLocalX
+     * @memberof Pointer
+     */
+    public gameLocalX: number;
+    /**
+     * Event Y coordinate relative to the holding container
+     * @public
+     * @type {number}
+     * @name gameLocalY
+     * @memberof Pointer
+     */
+    public gameLocalY: number;
+    /**
+     * The unique identifier of the contact for a touch, mouse or pen
+     * @public
+     * @type {number}
+     * @name pointerId
+     * @memberof Pointer
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pointerId
+     */
+    public pointerId: number;
+    /**
+     * true if not originally a pointer event
+     * @public
+     * @type {boolean}
+     * @name isNormalized
+     * @memberof Pointer
+     */
+    public isNormalized: boolean;
+    /**
+     * true if the pointer is currently locked
+     * @public
+     * @type {boolean}
+     * @name locked
+     * @memberof Pointer
+     */
+    public locked: boolean;
+    bind: number[];
+    /**
+     * initialize the Pointer object using the given Event Object
+     * @name Pointer#set
+     * @private
+     * @param {Event} event - the original Event object
+     * @param {number} [pageX=0] - the horizontal coordinate at which the event occurred, relative to the left edge of the entire document
+     * @param {number} [pageY=0] - the vertical coordinate at which the event occurred, relative to the left edge of the entire document
+     * @param {number} [clientX=0] - the horizontal coordinate within the application's client area at which the event occurred
+     * @param {number} [clientY=0] - the vertical coordinate within the application's client area at which the event occurred
+     * @param {number} [pointerId=1] - the Pointer, Touch or Mouse event Id (1)
+     */
+    private setEvent;
+}
+import Bounds from "./../physics/bounds.js";

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/deprecated.d.ts

@@ -0,0 +1,53 @@
+/**
+ * display a deprecation warning in the console
+ * @ignore
+ * @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;
+/**
+ * @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);
+}