melonjs 14.1.2 → 14.3.0

package/dist/types/geometries/point.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @classdesc
+ * represents a point in a 2d space
+ */
+export default class Point {
+    constructor(x?: number, y?: number);
+    /**
+     * the position of the point on the horizontal axis
+     * @public
+     * @type {Number}
+     * @default 0
+     */
+    public x: number;
+    /**
+     * the position of the point on the vertical axis
+     * @public
+     * @type {Number}
+     * @default 0
+     */
+    public y: number;
+    /** @ignore */
+    onResetEvent(x?: number, y?: number): void;
+    /**
+     * set the Point x and y properties to the given values
+     * @param {number} x
+     * @param {number} y
+     * @returns {Point} Reference to this object for method chaining
+     */
+    set(x?: number, y?: number): Point;
+    /**
+     * return true if the two points are the same
+     * @name equals
+     * @memberof Point
+     * @method
+     * @param {Point} point
+     * @returns {boolean}
+     */
+    /**
+     * return true if this point is equal to the given values
+     * @name equals
+     * @memberof Point
+     * @param {number} x
+     * @param {number} y
+     * @returns {boolean}
+     */
+    equals(...args: any[]): boolean;
+    /**
+     * clone this Point
+     * @name clone
+     * @returns {Point} new Point
+     */
+    clone(): Point;
+}

package/dist/types/geometries/poly.d.ts

@@ -0,0 +1,222 @@
+/**
+ * @classdesc
+ * a polygon Object.<br>
+ * Please do note that melonJS implements a simple Axis-Aligned Boxes collision algorithm, which requires all polygons used for collision to be convex with all vertices defined with clockwise winding.
+ * A polygon is convex when all line segments connecting two points in the interior do not cross any edge of the polygon
+ * (which means that all angles are less than 180 degrees), as described here below : <br>
+ * <center><img src="images/convex_polygon.png"/></center><br>
+ *
+ * A polygon's `winding` is clockwise if its vertices (points) are declared turning to the right. The image above shows COUNTERCLOCKWISE winding.
+ */
+export default class Polygon {
+    /**
+     * @param {number} x - origin point of the Polygon
+     * @param {number} y - origin point of the Polygon
+     * @param {Vector2d[]} points - array of vector defining the Polygon
+     */
+    constructor(x: number, y: number, points: Vector2d[]);
+    /**
+     * origin point of the Polygon
+     * @public
+     * @type {Vector2d}
+     * @name pos
+     * @memberof Polygon
+     */
+    public pos: Vector2d;
+    /**
+     * Array of points defining the Polygon <br>
+     * Note: If you manually change `points`, you **must** call `recalc`afterwards so that the changes get applied correctly.
+     * @public
+     * @type {Vector2d[]}
+     * @name points
+     * @memberof Polygon
+     */
+    public points: Vector2d[];
+    /**
+     * The edges here are the direction of the `n`th edge of the polygon, relative to
+     * the `n`th point. If you want to draw a given edge from the edge value, you must
+     * first translate to the position of the starting point.
+     * @ignore
+     */
+    edges: any[];
+    /**
+     * a list of indices for all vertices composing this polygon (@see earcut)
+     * @ignore
+     */
+    indices: any[];
+    /**
+     * The normals here are the direction of the normal for the `n`th edge of the polygon, relative
+     * to the position of the `n`th point. If you want to draw an edge normal, you must first
+     * translate to the position of the starting point.
+     * @ignore
+     */
+    normals: any[];
+    shapeType: string;
+    /** @ignore */
+    onResetEvent(x: any, y: any, points: any): void;
+    /**
+     * set new value to the Polygon
+     * @name setShape
+     * @memberof Polygon
+     * @param {number} x - position of the Polygon
+     * @param {number} y - position of the Polygon
+     * @param {Vector2d[]|number[]} points - array of vector or vertice defining the Polygon
+     * @returns {Polygon} this instance for objecf chaining
+     */
+    setShape(x: number, y: number, points: Vector2d[] | number[]): Polygon;
+    /**
+     * set the vertices defining this Polygon
+     * @name setVertices
+     * @memberof Polygon
+     * @param {Vector2d[]} vertices - array of vector or vertice defining the Polygon
+     * @returns {Polygon} this instance for objecf chaining
+     */
+    setVertices(vertices: Vector2d[]): Polygon;
+    /**
+     * apply the given transformation matrix to this Polygon
+     * @name transform
+     * @memberof Polygon
+     * @param {Matrix2d} m - the transformation matrix
+     * @returns {Polygon} Reference to this object for method chaining
+     */
+    transform(m: Matrix2d): Polygon;
+    /**
+     * apply an isometric projection to this shape
+     * @name toIso
+     * @memberof Polygon
+     * @returns {Polygon} Reference to this object for method chaining
+     */
+    toIso(): Polygon;
+    /**
+     * apply a 2d projection to this shape
+     * @name to2d
+     * @memberof Polygon
+     * @returns {Polygon} Reference to this object for method chaining
+     */
+    to2d(): Polygon;
+    /**
+     * Rotate this Polygon (counter-clockwise) by the specified angle (in radians).
+     * @name rotate
+     * @memberof Polygon
+     * @param {number} angle - The angle to rotate (in radians)
+     * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around
+     * @returns {Polygon} Reference to this object for method chaining
+     */
+    rotate(angle: number, v?: Vector2d | ObservableVector2d): Polygon;
+    /**
+     * Scale this Polygon by the given scalar.
+     * @name scale
+     * @memberof Polygon
+     * @param {number} x
+     * @param {number} [y=x]
+     * @returns {Polygon} Reference to this object for method chaining
+     */
+    scale(x: number, y?: number | undefined): Polygon;
+    /**
+     * Scale this Polygon by the given vector
+     * @name scaleV
+     * @memberof Polygon
+     * @param {Vector2d} v
+     * @returns {Polygon} Reference to this object for method chaining
+     */
+    scaleV(v: Vector2d): Polygon;
+    /**
+     * Computes the calculated collision polygon.
+     * This **must** be called if the `points` array, `angle`, or `offset` is modified manually.
+     * @name recalc
+     * @memberof Polygon
+     * @returns {Polygon} Reference to this object for method chaining
+     */
+    recalc(): Polygon;
+    /**
+     * returns a list of indices for all triangles defined in this polygon
+     * @name getIndices
+     * @memberof Polygon
+     * @returns {Array} an array of vertex indices for all triangles forming this polygon.
+     */
+    getIndices(): any[];
+    /**
+     * Returns true if the vertices composing this polygon form a convex shape (vertices must be in clockwise order).
+     * @name isConvex
+     * @memberof Polygon
+     * @returns {boolean} true if the vertices are convex, false if not, null if not computable
+     */
+    isConvex(): boolean;
+    /**
+     * translate the Polygon by the specified offset
+     * @name translate
+     * @memberof Polygon
+     * @method
+     * @param {number} x - x offset
+     * @param {number} y - y offset
+     * @returns {Polygon} this Polygon
+     */
+    /**
+     * translate the Polygon by the specified vector
+     * @name translate
+     * @memberof Polygon
+     * @param {Vector2d} v - vector offset
+     * @returns {Polygon} Reference to this object for method chaining
+     */
+    translate(...args: any[]): Polygon;
+    /**
+     * Shifts the Polygon to the given position vector.
+     * @name shift
+     * @memberof Polygon
+     * @method
+     * @param {Vector2d} position
+     */
+    /**
+     * Shifts the Polygon to the given x, y position.
+     * @name shift
+     * @memberof Polygon
+     * @param {number} x
+     * @param {number} y
+     */
+    shift(...args: any[]): void;
+    /**
+     * Returns true if the polygon contains the given point.
+     * (Note: it is highly recommended to first do a hit test on the corresponding <br>
+     *  bounding rect, as the function can be highly consuming with complex shapes)
+     * @name contains
+     * @memberof Polygon
+     * @method
+     * @param {Vector2d} point
+     * @returns {boolean} true if contains
+     */
+    /**
+     * Returns true if the polygon contains the given point. <br>
+     * (Note: it is highly recommended to first do a hit test on the corresponding <br>
+     *  bounding rect, as the function can be highly consuming with complex shapes)
+     * @name contains
+     * @memberof Polygon
+     * @param  {number} x -  x coordinate
+     * @param  {number} y -  y coordinate
+     * @returns {boolean} true if contains
+     */
+    contains(...args: any[]): boolean;
+    /**
+     * returns the bounding box for this shape, the smallest Rectangle object completely containing this shape.
+     * @name getBounds
+     * @memberof Polygon
+     * @returns {Bounds} this shape bounding box Rectangle object
+     */
+    getBounds(): Bounds;
+    _bounds: object | undefined;
+    /**
+     * update the bounding box for this shape.
+     * @ignore
+     * @name updateBounds
+     * @memberof Polygon
+     * @returns {Bounds} this shape bounding box Rectangle object
+     */
+    updateBounds(): Bounds;
+    /**
+     * clone this Polygon
+     * @name clone
+     * @memberof Polygon
+     * @returns {Polygon} new Polygon
+     */
+    clone(): Polygon;
+}
+import Vector2d from "./../math/vector2.js";

package/dist/types/geometries/rectangle.d.ts

@@ -0,0 +1,176 @@
+/**
+ * @classdesc
+ * a rectangle Object
+ * @augments Polygon
+ */
+export default class Rect extends Polygon {
+    /**
+     * @param {number} x - position of the Rectangle
+     * @param {number} y - position of the Rectangle
+     * @param {number} w - width of the rectangle
+     * @param {number} h - height of the rectangle
+     */
+    constructor(x: number, y: number, w: number, h: number);
+    /** @ignore */
+    onResetEvent(x: any, y: any, w: any, h: any): void;
+    /**
+     * set new value to the rectangle shape
+     * @name setShape
+     * @memberof Rect
+     * @param {number} x - position of the Rectangle
+     * @param {number} y - position of the Rectangle
+     * @param {number|Vector2d[]} w - width of the rectangle, or an array of vector defining the rectangle
+     * @param {number} [h] - height of the rectangle, if a numeral width parameter is specified
+     * @returns {Rect} this rectangle
+     */
+    setShape(x: number, y: number, w: number | Vector2d[], h?: number | undefined, ...args: any[]): Rect;
+    /**
+     * left coordinate of the Rectangle
+     * @public
+     * @type {number}
+     * @name left
+     * @memberof Rect
+     */
+    public get left(): number;
+    /**
+     * right coordinate of the Rectangle
+     * @public
+     * @type {number}
+     * @name right
+     * @memberof Rect
+     */
+    public get right(): number;
+    /**
+     * top coordinate of the Rectangle
+     * @public
+     * @type {number}
+     * @name top
+     * @memberof Rect
+     */
+    public get top(): number;
+    /**
+     * bottom coordinate of the Rectangle
+     * @public
+     * @type {number}
+     * @name bottom
+     * @memberof Rect
+     */
+    public get bottom(): number;
+    public set width(arg: number);
+    /**
+     * width of the Rectangle
+     * @public
+     * @type {number}
+     * @name width
+     * @memberof Rect
+     */
+    public get width(): number;
+    public set height(arg: number);
+    /**
+     * height of the Rectangle
+     * @public
+     * @type {number}
+     * @name height
+     * @memberof Rect
+     */
+    public get height(): number;
+    public set centerX(arg: number);
+    /**
+     * absolute center of this rectangle on the horizontal axis
+     * @public
+     * @type {number}
+     * @name centerX
+     * @memberof Rect
+     */
+    public get centerX(): number;
+    public set centerY(arg: number);
+    /**
+     * absolute center of this rectangle on the vertical axis
+     * @public
+     * @type {number}
+     * @name centerY
+     * @memberof Rect
+     */
+    public get centerY(): number;
+    /**
+     * center the rectangle position around the given coordinates
+     * @name centerOn
+     * @memberof Rect
+     * @param {number} x - the x coordinate around which to center this rectangle
+     * @param {number} y - the y coordinate around which to center this rectangle
+     * @returns {Rect} this rectangle
+     */
+    centerOn(x: number, y: number): Rect;
+    /**
+     * resize the rectangle
+     * @name resize
+     * @memberof Rect
+     * @param {number} w - new width of the rectangle
+     * @param {number} h - new height of the rectangle
+     * @returns {Rect} this rectangle
+     */
+    resize(w: number, h: number): Rect;
+    /**
+     * scale the rectangle
+     * @name scale
+     * @memberof Rect
+     * @param {number} x - a number representing the abscissa of the scaling vector.
+     * @param {number} [y=x] - a number representing the ordinate of the scaling vector.
+     * @returns {Rect} this rectangle
+     */
+    scale(x: number, y?: number | undefined): Rect;
+    /**
+     * clone this rectangle
+     * @name clone
+     * @memberof Rect
+     * @returns {Rect} new rectangle
+     */
+    clone(): Rect;
+    /**
+     * copy the position and size of the given rectangle into this one
+     * @name copy
+     * @memberof Rect
+     * @param {Rect} rect - Source rectangle
+     * @returns {Rect} new rectangle
+     */
+    copy(rect: Rect): Rect;
+    /**
+     * merge this rectangle with another one
+     * @name union
+     * @memberof Rect
+     * @param {Rect} rect - other rectangle to union with
+     * @returns {Rect} the union(ed) rectangle
+     */
+    union(rect: Rect): Rect;
+    /**
+     * check if this rectangle is intersecting with the specified one
+     * @name overlaps
+     * @memberof Rect
+     * @param {Rect} rect
+     * @returns {boolean} true if overlaps
+     */
+    overlaps(rect: Rect): boolean;
+    /**
+     * check if this rectangle is identical to the specified one
+     * @name equals
+     * @memberof Rect
+     * @param {Rect} rect
+     * @returns {boolean} true if equals
+     */
+    equals(rect: Rect): boolean;
+    /**
+     * determines whether all coordinates of this rectangle are finite numbers.
+     * @name isFinite
+     * @memberof Rect
+     * @returns {boolean} false if all coordinates are positive or negative Infinity or NaN; otherwise, true.
+     */
+    isFinite(): boolean;
+    /**
+     * Returns a polygon whose edges are the same as this box.
+     * @name toPolygon
+     * @memberof Rect
+     * @returns {Polygon} a new Polygon that represents this rectangle.
+     */
+    toPolygon(): Polygon;
+}
+import Polygon from "./poly.js";

package/dist/types/geometries/roundrect.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @classdesc
+ * a rectangle object with rounded corners
+ * @augments Rect
+ */
+export default class RoundRect extends Rect {
+    /**
+     * @param {number} x - position of the rounded rectangle
+     * @param {number} y - position of the rounded rectangle
+     * @param {number} width - the rectangle width
+     * @param {number} height - the rectangle height
+     * @param {number} [radius=20] - the radius of the rounded corner
+     */
+    constructor(x: number, y: number, width: number, height: number, radius?: number | undefined);
+    public set radius(arg: number);
+    /**
+     * the radius of the rounded corner
+     * @public
+     * @type {number}
+     * @default 20
+     * @name radius
+     * @memberof RoundRect
+     */
+    public get radius(): number;
+    /** @ignore */
+    onResetEvent(x: any, y: any, w: any, h: any, radius: any): void;
+    _radius: number | undefined;
+    /**
+     * copy the position, size and radius of the given rounded rectangle into this one
+     * @name copy
+     * @memberof RoundRect
+     * @param {RoundRect} rrect - source rounded rectangle
+     * @returns {RoundRect} new rectangle
+     */
+    copy(rrect: RoundRect): RoundRect;
+    /**
+     * check if this RoundRect is identical to the specified one
+     * @name equals
+     * @memberof RoundRect
+     * @param {RoundRect} rrect
+     * @returns {boolean} true if equals
+     */
+    equals(rrect: RoundRect): boolean;
+    /**
+     * clone this RoundRect
+     * @name clone
+     * @memberof RoundRect
+     * @returns {RoundRect} new RoundRect
+     */
+    clone(): RoundRect;
+}
+import Rect from "./rectangle.js";

package/dist/types/index.d.ts

@@ -30,11 +30,11 @@ export const initialized: boolean;
  * @see boot
  */
 export const skipAutoInit: boolean;
+export const game: Application;
 import * as audio from "./audio/audio.js";
 import collision from "./physics/collision.js";
 import * as device from "./system/device.js";
 import * as event from "./system/event.js";
-import game from "./game.js";
 import loader from "./loader/loader.js";
 import level from "./level/level.js";
 import * as input from "./input/input.js";
@@ -105,4 +105,5 @@ import ParticleEmitter from "./particles/emitter.js";
 import ParticleEmitterSettings from "./particles/settings.js";
 import Particle from "./particles/particle.js";
 import Entity from "./entity/entity.js";
-export { audio, collision, device, event, game, loader, level, input, Math, plugin, plugins, utils, save, timer, pool, state, video, Color, Vector2d, Vector3d, ObservableVector2d, ObservableVector3d, Matrix2d, Matrix3d, Polygon, Line, Ellipse, Point, Rect, RoundRect, Tween, QuadTree, GLShader, WebGLCompositor, Renderer, WebGLRenderer, CanvasRenderer, TextureAtlas, Renderable, Body, Bounds, Text, BitmapText, BitmapTextData, ColorLayer, ImageLayer, Sprite, NineSliceSprite, UIBaseElement, UITextButton, UISpriteElement, Collectable, Trigger, Light2d, Draggable, DropTarget, TMXRenderer, TMXOrthogonalRenderer, TMXIsometricRenderer, TMXHexagonalRenderer, TMXStaggeredRenderer, Tile, TMXTileset, TMXTilesetGroup, TMXTileMap, TMXLayer, Pointer, Stage, Camera2d, Container, World, ParticleEmitter, ParticleEmitterSettings, Particle, Entity };
+import Application from "./application/application.js";
+export { audio, collision, device, event, loader, level, input, Math, plugin, plugins, utils, save, timer, pool, state, video, Color, Vector2d, Vector3d, ObservableVector2d, ObservableVector3d, Matrix2d, Matrix3d, Polygon, Line, Ellipse, Point, Rect, RoundRect, Tween, QuadTree, GLShader, WebGLCompositor, Renderer, WebGLRenderer, CanvasRenderer, TextureAtlas, Renderable, Body, Bounds, Text, BitmapText, BitmapTextData, ColorLayer, ImageLayer, Sprite, NineSliceSprite, UIBaseElement, UITextButton, UISpriteElement, Collectable, Trigger, Light2d, Draggable, DropTarget, TMXRenderer, TMXOrthogonalRenderer, TMXIsometricRenderer, TMXHexagonalRenderer, TMXStaggeredRenderer, Tile, TMXTileset, TMXTilesetGroup, TMXTileMap, TMXLayer, Pointer, Stage, Camera2d, Container, World, ParticleEmitter, ParticleEmitterSettings, Particle, Entity, Application };

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