melonjs 14.2.0 → 14.4.0

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

@@ -0,0 +1,95 @@
+/**
+ * Associate a gamepad event to a keycode
+ * @name bindGamepad
+ * @memberof input
+ * @public
+ * @param {number} index - Gamepad index
+ * @param {object} button - Button/Axis definition
+ * @param {string} button.type - "buttons" or "axes"
+ * @param {number} button.code - button or axis code id (See {@link input.GAMEPAD.BUTTONS}, {@link input.GAMEPAD.AXES})
+ * @param {number} [button.threshold=1] - value indicating when the axis should trigger the keycode (e.g. -0.5 or 0.5)
+ * @param {number} keyCode - (See {@link input.KEY})
+ * @example
+ * // enable the keyboard
+ * me.input.bindKey(me.input.KEY.X, "shoot");
+ * ...
+ * // map the lower face button on the first gamepad to the X key
+ * me.input.bindGamepad(0, {type:"buttons", code: me.input.GAMEPAD.BUTTONS.FACE_1}, me.input.KEY.X);
+ * // map the left axis value on the first gamepad to the LEFT key
+ * me.input.bindGamepad(0, {type:"axes", code: me.input.GAMEPAD.AXES.LX, threshold: -0.5}, me.input.KEY.LEFT);
+ */
+export function bindGamepad(index: number, button: {
+    type: string;
+    code: number;
+    threshold?: number | undefined;
+}, keyCode: number): void;
+/**
+ * unbind the defined keycode
+ * @name unbindGamepad
+ * @memberof input
+ * @public
+ * @param {number} index - Gamepad index
+ * @param {number} button - (See {@link input.GAMEPAD.BUTTONS})
+ * @example
+ * me.input.unbindGamepad(0, me.input.GAMEPAD.BUTTONS.FACE_1);
+ */
+export function unbindGamepad(index: number, button: number): void;
+/**
+ * Set deadzone for analog gamepad inputs<br>
+ * The default deadzone is 0.1 (10%) Analog values less than this will be ignored
+ * @name setGamepadDeadzone
+ * @memberof input
+ * @public
+ * @param {number} value - Deadzone value
+ */
+export function setGamepadDeadzone(value: number): void;
+export namespace GAMEPAD {
+    namespace AXES {
+        const LX: number;
+        const LY: number;
+        const RX: number;
+        const RY: number;
+        const EXTRA_1: number;
+        const EXTRA_2: number;
+        const EXTRA_3: number;
+        const EXTRA_4: number;
+    }
+    namespace BUTTONS {
+        export const FACE_1: number;
+        export const FACE_2: number;
+        export const FACE_3: number;
+        export const FACE_4: number;
+        export const L1: number;
+        export const R1: number;
+        export const L2: number;
+        export const R2: number;
+        export const SELECT: number;
+        export const BACK: number;
+        export const START: number;
+        export const FORWARD: number;
+        export const L3: number;
+        export const R3: number;
+        export const UP: number;
+        export const DOWN: number;
+        export const LEFT: number;
+        export const RIGHT: number;
+        export const HOME: number;
+        const EXTRA_1_1: number;
+        export { EXTRA_1_1 as EXTRA_1 };
+        const EXTRA_2_1: number;
+        export { EXTRA_2_1 as EXTRA_2 };
+        const EXTRA_3_1: number;
+        export { EXTRA_3_1 as EXTRA_3 };
+        const EXTRA_4_1: number;
+        export { EXTRA_4_1 as EXTRA_4 };
+    }
+}
+/**
+ * Firefox reports different ids for gamepads depending on the platform:
+ * - Windows: vendor and product codes contain leading zeroes
+ * - Mac: vendor and product codes are sparse (no leading zeroes)
+ *
+ * This function normalizes the id to support both formats
+ * @ignore
+ */
+export function setGamepadMapping(id: any, mapping: any): void;

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

@@ -0,0 +1,15 @@
+/**
+ * @namespace input
+ */
+/**
+ * specify if melonJS should prevent all default browser action on registered events.
+ * @public
+ * @type {boolean}
+ * @default true
+ * @name preventDefault
+ * @memberof input
+ */
+export const preventDefault: boolean;
+export * from "./pointerevent.js";
+export * from "./keyboard.js";
+export * from "./gamepad.js";

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";