melonjs 14.2.0 → 14.4.0

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

@@ -0,0 +1,121 @@
+/**
+ * @classdesc
+ * a simplified path2d implementation, supporting only one path
+ */
+export default class Path2D {
+    /**
+     * the points defining the current path
+     * @public
+     * @type {Vector2d[]}
+     * @name points
+     * @memberof Path2D#
+     */
+    public points: Vector2d[];
+    /**
+     * space between interpolated points for quadratic and bezier curve approx. in pixels.
+     * @public
+     * @type {number}
+     * @name arcResolution
+     * @default 5
+     * @memberof Path2D#
+     */
+    public arcResolution: number;
+    vertices: any[];
+    /**
+     * begin a new path
+     * @name beginPath
+     * @memberof Path2D
+     */
+    beginPath(): void;
+    /**
+     * causes the point of the pen to move back to the start of the current path.
+     * It tries to draw a straight line from the current point to the start.
+     * If the shape has already been closed or has only one point, this function does nothing.
+     * @name closePath
+     * @memberof Path2D
+     */
+    closePath(): void;
+    /**
+     * triangulate the shape defined by this path into an array of triangles
+     * @name triangulatePath
+     * @memberof Path2D
+     * @returns {Vector2d[]}
+     */
+    triangulatePath(): Vector2d[];
+    /**
+     * moves the starting point of the current path to the (x, y) coordinates.
+     * @name moveTo
+     * @memberof Path2D
+     * @param {number} x - the x-axis (horizontal) coordinate of the point.
+     * @param {number} y - the y-axis (vertical) coordinate of the point.
+     */
+    moveTo(x: number, y: number): void;
+    /**
+     * connects the last point in the current patch to the (x, y) coordinates with a straight line.
+     * @name lineTo
+     * @memberof Path2D
+     * @param {number} x - the x-axis coordinate of the line's end point.
+     * @param {number} y - the y-axis coordinate of the line's end point.
+     */
+    lineTo(x: number, y: number): void;
+    /**
+     * adds an arc to the current path which is centered at (x, y) position with the given radius,
+     * starting at startAngle and ending at endAngle going in the given direction by counterclockwise (defaulting to clockwise).
+     * @name arc
+     * @memberof Path2D
+     * @param {number} x - the horizontal coordinate of the arc's center.
+     * @param {number} y - the vertical coordinate of the arc's center.
+     * @param {number} radius - the arc's radius. Must be positive.
+     * @param {number} startAngle - the angle at which the arc starts in radians, measured from the positive x-axis.
+     * @param {number} endAngle - the angle at which the arc ends in radians, measured from the positive x-axis.
+     * @param {boolean} [anticlockwise=false] - an optional boolean value. If true, draws the arc counter-clockwise between the start and end angles.
+     */
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean | undefined): void;
+    /**
+     * adds a circular arc to the path with the given control points and radius, connected to the previous point by a straight line.
+     * @name arcTo
+     * @memberof Path2D
+     * @param {number} x1 - the x-axis coordinate of the first control point.
+     * @param {number} y1 - the y-axis coordinate of the first control point.
+     * @param {number} x2 - the x-axis coordinate of the second control point.
+     * @param {number} y2 - the y-axis coordinate of the second control point.
+     * @param {number} radius - the arc's radius. Must be positive.
+     */
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+    /**
+     * adds an elliptical arc to the path which is centered at (x, y) position with the radii radiusX and radiusY
+     * starting at startAngle and ending at endAngle going in the given direction by counterclockwise.
+     * @name ellipse
+     * @memberof Path2D
+     * @param {number} x - the x-axis (horizontal) coordinate of the ellipse's center.
+     * @param {number} y - the  y-axis (vertical) coordinate of the ellipse's center.
+     * @param {number} radiusX - the ellipse's major-axis radius. Must be non-negative.
+     * @param {number} radiusY - the ellipse's minor-axis radius. Must be non-negative.
+     * @param {number} rotation - the rotation of the ellipse, expressed in radians.
+     * @param {number} startAngle - the angle at which the ellipse starts, measured clockwise from the positive x-axis and expressed in radians.
+     * @param {number} endAngle - the angle at which the ellipse ends, measured clockwise from the positive x-axis and expressed in radians.
+     * @param {boolean} [anticlockwise=false] - an optional boolean value which, if true, draws the ellipse counterclockwise (anticlockwise).
+     */
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean | undefined): void;
+    /**
+     * creates a path for a rectangle at position (x, y) with a size that is determined by width and height.
+     * @name rect
+     * @memberof Path2D
+     * @param {number} x - the x-axis coordinate of the rectangle's starting point.
+     * @param {number} y - the y-axis coordinate of the rectangle's starting point.
+     * @param {number} width - the rectangle's width. Positive values are to the right, and negative to the left.
+     * @param {number} height - the rectangle's height. Positive values are down, and negative are up.
+     */
+    rect(x: number, y: number, width: number, height: number): void;
+    /**
+     * adds an rounded rectangle to the current path.
+     * @name roundRect
+     * @memberof Path2D
+     * @param {number} x - the x-axis coordinate of the rectangle's starting point.
+     * @param {number} y - the y-axis coordinate of the rectangle's starting point.
+     * @param {number} width - the rectangle's width. Positive values are to the right, and negative to the left.
+     * @param {number} height - the rectangle's height. Positive values are down, and negative are up.
+     * @param {number} radius - the arc's radius to draw the borders. Must be positive.
+     */
+    roundRect(x: number, y: number, width: number, height: number, radius: number): void;
+}

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

@@ -16,6 +16,7 @@ export function boot(): void;
  */
 export const version: string;
 export * from "./lang/deprecated.js";
+export * from "./const.js";
 /**
  * a flag indicating that melonJS is fully initialized
  * @type {boolean}
@@ -30,11 +31,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 +106,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 };