melonjs 14.1.2 → 14.3.0

package/dist/types/renderable/trigger.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @classdesc
+ * trigger an event when colliding with another object
+ * @augments Renderable
+ */
+export default class Trigger extends Renderable {
+    /**
+     * @param {number} x - the x coordinates of the trigger area
+     * @param {number} y - the y coordinates of the trigger area
+     * @param {number} [settings.width] - width of the trigger area
+     * @param {number} [settings.height] - height of the trigger area
+     * @param {Rect[]|Polygon[]|Line[]|Ellipse[]} [settings.shapes] - collision shape(s) that will trigger the event
+     * @param {string} [settings.duration] - Fade duration (in ms)
+     * @param {string|Color} [settings.color] - Fade color
+     * @param {string} [settings.event="level"] - the type of event to trigger (only "level" supported for now)
+     * @param {string} [settings.to] - level to load if level trigger
+     * @param {string|Container} [settings.container] - Target container. See {@link level.load}
+     * @param {Function} [settings.onLoaded] - Level loaded callback. See {@link level.load}
+     * @param {boolean} [settings.flatten] - Flatten all objects into the target container. See {@link level.load}
+     * @param {boolean} [settings.setViewportBounds] - Resize the viewport to match the level. See {@link level.load}
+     * @example
+     * me.game.world.addChild(new me.Trigger(
+     *     x, y, {
+     *         shapes: [new me.Rect(0, 0, 100, 100)],
+     *         "duration" : 250,
+     *         "color" : "#000",
+     *         "to" : "mymap2"
+     *     }
+     * ));
+     */
+    constructor(x: number, y: number, settings: any);
+    fade: any;
+    duration: any;
+    fading: boolean;
+    type: any;
+    id: any;
+    gotolevel: any;
+    triggerSettings: {
+        event: string;
+    };
+    body: Body;
+    /**
+     * @ignore
+     */
+    getTriggerSettings(): {
+        event: string;
+    };
+    /**
+     * @ignore
+     */
+    onFadeComplete(): void;
+    /**
+     * trigger this event
+     * @name triggerEvent
+     * @memberof Trigger
+     * @protected
+     */
+    protected triggerEvent(): void;
+}
+import Renderable from "./renderable.js";
+import Body from "./../physics/body.js";

package/dist/types/renderable/ui/uibaseelement.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @classdesc
+ * This is a basic clickable container which you can use in your game UI.
+ * Use this for example if you want to display a button which contains
+ * text and images.
+ * @augments Container
+ */
+export default class UIBaseElement extends Container {
+    /**
+     *
+     * @param {number} x - The x position of the container
+     * @param {number} y - The y position of the container
+     * @param {number} w - width of the container (default: viewport width)
+     * @param {number} h - height of the container (default: viewport height)
+     */
+    constructor(x: number, y: number, w: number, h: number);
+    /**
+     * object can be clicked or not
+     * @type {boolean}
+     */
+    isClickable: boolean;
+    /**
+     * Tap and hold threshold timeout in ms
+     * @type {number}
+     * @default 250
+     */
+    holdThreshold: number;
+    /**
+     * object can be tap and hold
+     * @type {boolean}
+     * @default false
+     */
+    isHoldable: boolean;
+    /**
+     * true if the pointer is over the object
+     * @type {boolean}
+     * @default false
+     */
+    hover: boolean;
+    holdTimeout: number | null;
+    released: boolean;
+    /**
+     * function callback for the pointerdown event
+     * @ignore
+     */
+    clicked(event: any): boolean | undefined;
+    dirty: boolean | undefined;
+    /**
+     * function called when the object is pressed (to be extended)
+     * @param {Pointer} event - the event object
+     * @returns {boolean} return false if we need to stop propagating the event
+     */
+    onClick(event: Pointer): boolean;
+    /**
+     * function callback for the pointerEnter event
+     * @ignore
+     */
+    enter(event: any): void;
+    /**
+     * function called when the pointer is over the object
+     * @param {Pointer} event - the event object
+     */
+    onOver(event: Pointer): void;
+    /**
+     * function callback for the pointerLeave event
+     * @ignore
+     */
+    leave(event: any): void;
+    /**
+     * function called when the pointer is leaving the object area
+     * @param {Pointer} event - the event object
+     */
+    onOut(event: Pointer): void;
+    /**
+     * function callback for the pointerup event
+     * @ignore
+     */
+    release(event: any): boolean | undefined;
+    /**
+     * function called when the object is pressed and released (to be extended)
+     * @returns {boolean} return false if we need to stop propagating the event
+     */
+    onRelease(): boolean;
+    /**
+     * function callback for the tap and hold timer event
+     * @ignore
+     */
+    hold(): void;
+    /**
+     * function called when the object is pressed and held<br>
+     * to be extended <br>
+     */
+    onHold(): void;
+}
+import Container from "../container.js";

package/dist/types/renderable/ui/uispriteelement.d.ts

@@ -0,0 +1,127 @@
+/**
+ * @classdesc
+ *  This is a basic sprite based button which you can use in your Game UI.
+ * @augments Sprite
+ */
+export default class UISpriteElement extends Sprite {
+    /**
+     * @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}
+     * @example
+     * // create a basic GUI Object
+     * class myButton extends UISpriteElement {
+     *    constructor(x, y) {
+     *       var settings = {}
+     *       settings.image = "button";
+     *       settings.framewidth = 100;
+     *       settings.frameheight = 50;
+     *       // super constructor
+     *       super(x, y, settings);
+     *       // define the object z order
+     *       this.pos.z = 4;
+     *    }
+     *
+     *    // output something in the console
+     *    // when the object is clicked
+     *    onClick:function (event) {
+     *       console.log("clicked!");
+     *       // don't propagate the event
+     *       return false;
+     *    }
+     * });
+     *
+     * // add the object at pos (10,10)
+     * me.game.world.addChild(new myButton(10,10));
+     */
+    constructor(x: number, y: number, settings: object);
+    /**
+     * object can be clicked or not
+     * @type {boolean}
+     * @default true
+     */
+    isClickable: boolean;
+    /**
+     * Tap and hold threshold timeout in ms
+     * @type {number}
+     * @default 250
+     */
+    holdThreshold: number;
+    /**
+     * object can be tap and hold
+     * @type {boolean}
+     * @default false
+     */
+    isHoldable: boolean;
+    /**
+     * true if the pointer is over the object
+     * @type {boolean}
+     * @default false
+     */
+    hover: boolean;
+    holdTimeout: number | null;
+    released: boolean;
+    /**
+     * function callback for the pointerdown event
+     * @ignore
+     */
+    clicked(event: any): boolean | undefined;
+    dirty: boolean | undefined;
+    /**
+     * function called when the object is pressed (to be extended)
+     * @param {Pointer} event - the event object
+     * @returns {boolean} return false if we need to stop propagating the event
+     */
+    onClick(event: Pointer): boolean;
+    /**
+     * function callback for the pointerEnter event
+     * @ignore
+     */
+    enter(event: any): void;
+    /**
+     * function called when the pointer is over the object
+     * @param {Pointer} event - the event object
+     */
+    onOver(event: Pointer): void;
+    /**
+     * function callback for the pointerLeave event
+     * @ignore
+     */
+    leave(event: any): void;
+    /**
+     * function called when the pointer is leaving the object area
+     * @param {Pointer} event - the event object
+     */
+    onOut(event: Pointer): void;
+    /**
+     * function callback for the pointerup event
+     * @ignore
+     */
+    release(event: any): boolean | undefined;
+    /**
+     * function called when the object is pressed and released (to be extended)
+     * @returns {boolean} return false if we need to stop propagating the event
+     */
+    onRelease(): boolean;
+    /**
+     * function callback for the tap and hold timer event
+     * @ignore
+     */
+    hold(): void;
+    /**
+     * function called when the object is pressed and held<br>
+     * to be extended <br>
+     */
+    onHold(): void;
+    /**
+     * function called when added to the game world or a container
+     * @ignore
+     */
+    onActivateEvent(): void;
+    /**
+     * function called when removed from the game world or a container
+     * @ignore
+     */
+    onDeactivateEvent(): void;
+}
+import Sprite from "./../sprite.js";

package/dist/types/renderable/ui/uitextbutton.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @classdesc
+ * This is a basic base text button which you can use in your Game UI.
+ * @augments UIBaseElement
+ */
+export default class UITextButton extends UIBaseElement {
+    /**
+     * A Text Button with an outlined background border, filled with background color.
+     * It uses a RoundRect as background and changes the background color on hovering over.
+     * The background will be drawn with 0.5 opacity, so that the background of the button is
+     * slightly shining through.
+     * @param {number} x - x pos of the button
+     * @param {number} y - y pos of the button
+     * @param {string} [settings.font] - The name of the BitmapText font to use
+     * @param {number} [settings.size] - The scale factor of the font (default: 1)
+     * @param {string} [settings.text] - The text to display (default: 'click me')
+     * @param {string} [settings.bindKey] - The key to bind the action to (default: none)
+     * @param {string} [settings.backgroundColor] - The css value of a background color
+     * @param {string} [settings.hoverColor] - The css value of a color to be used if the pointer hovers over the button
+     * @param {string} [settings.borderStrokeColor] - The css value of a color to be used to draw the border
+     * @param {boolean} [settings.offScreenCanvas] - Weather to use an offScreen canvas or not
+     * @param {string} [settings.fillStyle] - The css value of a tint color to be used to tint the text
+     * @param {number} [settings.borderWidth] - Width of the button
+     * @param {number} [settings.borderHeight] - Height of the button
+     * @example
+     * // Create a new Button
+     * class PlayButton extends BaseTextButton {
+     *      constructor(x,y) {
+     *          super(x,y, {
+     *              font: 'my-font',
+     *              text: 'Play',
+     *              // if you omit the next two, size is calculated by the size of the text
+     *              borderWidth: 200,
+     *              borderHeight: 20,
+     *          });
+     *      }
+     *
+     *      onClick(){
+     *          state.change(state.PLAY);
+     *      }
+     * }
+     *
+     * game.world.addChild(new PlayButton(15,200));
+     */
+    constructor(x: number, y: number, settings: any);
+    font: BitmapText;
+    dimensions: import("../../text/textmetrics.js").default;
+    border: RoundRect;
+    settings: any;
+    draw(renderer: any): void;
+}
+import UIBaseElement from "./uibaseelement.js";
+import BitmapText from "../../text/bitmaptext.js";
+import RoundRect from "../../geometries/roundrect.js";

package/dist/types/state/stage.d.ts

@@ -0,0 +1,116 @@
+/**
+ * @classdesc
+ * a default "Stage" object.
+ * every "stage" object (title screen, credits, ingame, etc...) to be managed
+ * through the state manager must inherit from this base class.
+ * @see state
+ */
+export default class Stage {
+    /**
+     * @param {object} [settings] - The stage` parameters
+     * @param {Camera2d[]} [settings.cameras=[new me.Camera2d()]] - a list of cameras (experimental)
+     * @param {Function} [settings.onResetEvent] - called by the state manager when reseting the object
+     * @param {Function} [settings.onDestroyEvent] - called by the state manager before switching to another state
+     */
+    constructor(settings?: {
+        cameras?: Camera2d[] | undefined;
+        onResetEvent?: Function | undefined;
+        onDestroyEvent?: Function | undefined;
+    } | undefined);
+    /**
+     * The list of active cameras in this stage.
+     * Cameras will be renderered based on this order defined in this list.
+     * Only the "default" camera will be resized when the window or canvas is resized.
+     * @public
+     * @type {Map<Camera2d>}
+     * @name cameras
+     * @memberof Stage
+     */
+    public cameras: Map<Camera2d, any>;
+    /**
+     * The list of active lights in this stage.
+     * (Note: Canvas Renderering mode will only properly support one light per stage)
+     * @public
+     * @type {Map<Light2d>}
+     * @name lights
+     * @memberof Stage
+     * @see Light2d
+     * @see Stage.ambientLight
+     * @example
+     * // create a white spot light
+     * var whiteLight = new me.Light2d(0, 0, 140, "#fff", 0.7);
+     * // and add the light to this current stage
+     * this.lights.set("whiteLight", whiteLight);
+     * // set a dark ambient light
+     * this.ambientLight.parseCSS("#1117");
+     * // make the light follow the mouse
+     * me.input.registerPointerEvent("pointermove", me.game.viewport, (event) => {
+     *    whiteLight.centerOn(event.gameX, event.gameY);
+     * });
+     */
+    public lights: Map<Light2d, any>;
+    /**
+     * an ambient light that will be added to the stage rendering
+     * @public
+     * @type {Color}
+     * @name ambientLight
+     * @memberof Stage
+     * @default "#000000"
+     * @see Light2d
+     */
+    public ambientLight: Color;
+    /**
+     * The given constructor options
+     * @public
+     * @name settings
+     * @memberof Stage
+     * @type {object}
+     */
+    public settings: object;
+    /**
+     * Object reset function
+     * @ignore
+     */
+    reset(...args: any[]): void;
+    /**
+     * update function
+     * @name update
+     * @memberof Stage
+     * @ignore
+     * @param {number} dt - time since the last update in milliseconds.
+     * @returns {boolean}
+     */
+    update(dt: number): boolean;
+    /**
+     * draw the current stage
+     * @name draw
+     * @memberof Stage
+     * @ignore
+     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
+     */
+    draw(renderer: CanvasRenderer | WebGLRenderer): void;
+    /**
+     * destroy function
+     * @ignore
+     */
+    destroy(...args: any[]): void;
+    /**
+     * onResetEvent function<br>
+     * called by the state manager when reseting the object
+     * this is typically where you will load a level, add renderables, etc...
+     * @name onResetEvent
+     * @memberof Stage
+     * @param {object} [...arguments] - optional arguments passed when switching state
+     * @see state#change
+     */
+    onResetEvent(...args: any[]): void;
+    /**
+     * onDestroyEvent function<br>
+     * called by the state manager before switching to another state
+     * @name onDestroyEvent
+     * @memberof Stage
+     */
+    onDestroyEvent(...args: any[]): void;
+}
+import Camera2d from "./../camera/camera2d.js";
+import Color from "./../math/color.js";

package/dist/types/state/state.d.ts

@@ -0,0 +1,170 @@
+export default state;
+declare namespace state {
+    const LOADING: number;
+    const MENU: number;
+    const READY: number;
+    const PLAY: number;
+    const GAMEOVER: number;
+    const GAME_END: number;
+    const SCORE: number;
+    const CREDITS: number;
+    const SETTINGS: number;
+    const DEFAULT: number;
+    const USER: number;
+    /**
+     * Stop the current stage.
+     * @name stop
+     * @memberof state
+     * @public
+     * @param {boolean} [pauseTrack=false] - pause current track on screen stop.
+     */
+    function stop(pauseTrack?: boolean | undefined): void;
+    /**
+     * pause the current stage
+     * @name pause
+     * @memberof state
+     * @public
+     * @param {boolean} [music=false] - pause current music track on screen pause
+     */
+    function pause(music?: boolean | undefined): void;
+    /**
+     * Restart the current stage from a full stop.
+     * @name restart
+     * @memberof state
+     * @public
+     * @param {boolean} [music=false] - resume current music track on screen resume
+     */
+    function restart(music?: boolean | undefined): void;
+    /**
+     * resume the current stage
+     * @name resume
+     * @memberof state
+     * @public
+     * @param {boolean} [music=false] - resume current music track on screen resume
+     */
+    function resume(music?: boolean | undefined): void;
+    /**
+     * return the running state of the state manager
+     * @name isRunning
+     * @memberof state
+     * @public
+     * @returns {boolean} true if a "process is running"
+     */
+    function isRunning(): boolean;
+    /**
+     * Return the pause state of the state manager
+     * @name isPaused
+     * @memberof state
+     * @public
+     * @returns {boolean} true if the game is paused
+     */
+    function isPaused(): boolean;
+    /**
+     * associate the specified state with a Stage
+     * @name set
+     * @memberof state
+     * @public
+     * @param {number} state - State ID (see constants)
+     * @param {Stage} stage - Instantiated Stage to associate with state ID
+     * @param {boolean} [start = false] - if true the state will be changed immediately after adding it.
+     * @example
+     * class MenuButton extends me.GUI_Object {
+     *     onClick() {
+     *         // Change to the PLAY state when the button is clicked
+     *         me.state.change(me.state.PLAY);
+     *         return true;
+     *     }
+     * };
+     *
+     * class MenuScreen extends me.Stage {
+     *     onResetEvent() {
+     *         // Load background image
+     *         me.game.world.addChild(
+     *             new me.ImageLayer(0, 0, {
+     *                 image : "bg",
+     *                 z: 0 // z-index
+     *             }
+     *         );
+     *
+     *         // Add a button
+     *         me.game.world.addChild(
+     *             new MenuButton(350, 200, { "image" : "start" }),
+     *             1 // z-index
+     *         );
+     *
+     *         // Play music
+     *         me.audio.playTrack("menu");
+     *     }
+     *
+     *     onDestroyEvent() {
+     *         // Stop music
+     *         me.audio.stopTrack();
+     *     }
+     * };
+     *
+     * me.state.set(me.state.MENU, new MenuScreen());
+     */
+    function set(state: number, stage: Stage, start?: boolean | undefined): void;
+    /**
+     * returns the stage associated with the specified state
+     * (or the current one if none is specified)
+     * @name set
+     * @memberof state
+     * @public
+     * @param {number} [state] - State ID (see constants)
+     * @returns {Stage}
+     */
+    function get(state?: number | undefined): Stage;
+    /**
+     * return a reference to the current stage<br>
+     * useful to call a object specific method
+     * @name current
+     * @memberof state
+     * @public
+     * @returns {Stage}
+     */
+    function current(): Stage;
+    /**
+     * specify a global transition effect
+     * @name transition
+     * @memberof state
+     * @public
+     * @param {string} effect - (only "fade" is supported for now)
+     * @param {Color|string} color - a CSS color value
+     * @param {number} [duration=1000] - expressed in milliseconds
+     */
+    function transition(effect: string, color: any, duration?: number | undefined): void;
+    /**
+     * enable/disable transition for a specific state (by default enabled for all)
+     * @name setTransition
+     * @memberof state
+     * @public
+     * @param {number} state - State ID (see constants)
+     * @param {boolean} enable
+     */
+    function setTransition(state: number, enable: boolean): void;
+    /**
+     * change the game/app state
+     * @name change
+     * @memberof state
+     * @public
+     * @param {number} state - State ID (see constants)
+     * @param {boolean} forceChange - if true the state will be changed immediately
+     * @param {object} [...arguments] - extra arguments to be passed to the reset functions
+     * @example
+     * // The onResetEvent method on the play screen will receive two args:
+     * // "level_1" and the number 3
+     * me.state.change(me.state.PLAY, "level_1", 3);
+     */
+    function change(state: number, forceChange: boolean, ...args: any[]): void;
+    /**
+     * return true if the specified state is the current one
+     * @name isCurrent
+     * @memberof state
+     * @public
+     * @param {number} state - State ID (see constants)
+     * @returns {boolean} true if the specified state is the current one
+     */
+    function isCurrent(state: number): boolean;
+}
+import Stage from "./../state/stage.js";