melonjs 14.2.0 → 14.3.0

package/dist/types/camera/camera2d.d.ts

@@ -0,0 +1,289 @@
+/**
+ * @classdesc
+ * a 2D orthographic camera
+ * @augments Renderable
+ */
+export default class Camera2d extends Renderable {
+    /**
+     * Axis definition
+     * @enum {number}
+     * @property {number} NONE no axis
+     * @property {number} HORIZONTAL horizontal axis only
+     * @property {number} VERTICAL vertical axis only
+     * @property {number} BOTH both axis
+     * @readonly
+     * @name AXIS
+     * @memberof Camera2d
+     */
+    readonly AXIS: {
+        NONE: number;
+        HORIZONTAL: number;
+        VERTICAL: number;
+        BOTH: number;
+    };
+    /**
+     * Camera bounds
+     * @public
+     * @type {Bounds}
+     * @name bounds
+     * @memberof Camera2d
+     */
+    public bounds: Bounds;
+    /**
+     * enable or disable damping
+     * @private
+     * @default true
+     */
+    private smoothFollow;
+    /**
+     * Camera damping for smooth transition [0 .. 1].
+     * 1 being the maximum value and will snap the camera to the target position
+     * @public
+     * @type {number}
+     * @name damping
+     * @default 1.0
+     * @memberof Camera2d
+     */
+    public damping: number;
+    /**
+     * the closest point relative to the camera
+     * @public
+     * @type {number}
+     * @name near
+     * @default -1000
+     * @memberof Camera2d
+     */
+    public near: number;
+    /**
+     * the furthest point relative to the camera.
+     * @public
+     * @type {number}
+     * @name far
+     * @default 1000
+     * @memberof Camera2d
+     */
+    public far: number;
+    /**
+     * the default camera projection matrix
+     * (2d cameras use an orthographic projection by default).
+     * @public
+     * @type {Matrix3d}
+     * @name projectionMatrix
+     * @memberof Camera2d
+     */
+    public projectionMatrix: Matrix3d;
+    /**
+     * the invert camera transform used to unproject points
+     * @ignore
+     * @type {Matrix2d}
+     * @name invCurrentTransform
+     * @memberof Camera2d
+     */
+    invCurrentTransform: Matrix2d;
+    offset: Vector2d;
+    target: Vector2d | ObservableVector3d | null;
+    follow_axis: number;
+    _shake: {
+        intensity: number;
+        duration: number;
+        axis: number;
+        onComplete: null;
+    };
+    _fadeOut: {
+        color: null;
+        tween: null;
+    };
+    _fadeIn: {
+        color: null;
+        tween: null;
+    };
+    /** @ignore */
+    _updateProjectionMatrix(): void;
+    /** @ignore */
+    _followH(target: any): number;
+    /** @ignore */
+    _followV(target: any): number;
+    /**
+     * reset the camera position to specified coordinates
+     * @name reset
+     * @memberof Camera2d
+     * @param {number} [x=0]
+     * @param {number} [y=0]
+     */
+    reset(x?: number | undefined, y?: number | undefined): void;
+    /**
+     * change the deadzone settings.
+     * the "deadzone" defines an area within the current camera in which
+     * the followed renderable can move without scrolling the camera.
+     * @name setDeadzone
+     * @see Camera2d.follow
+     * @memberof Camera2d
+     * @param {number} w - deadzone width
+     * @param {number} h - deadzone height
+     */
+    setDeadzone(w: number, h: number): void;
+    deadzone: Rect | undefined;
+    /**
+     * resize the camera
+     * @name resize
+     * @memberof Camera2d
+     * @param {number} w - new width of the camera
+     * @param {number} h - new height of the camera
+     * @returns {Camera2d} this camera
+     */
+    resize(w: number, h: number): Camera2d;
+    /**
+     * set the camera boundaries (set to the world limit by default).
+     * the camera is bound to the given coordinates and cannot move/be scrolled outside of it.
+     * @name setBounds
+     * @memberof Camera2d
+     * @param {number} x - world left limit
+     * @param {number} y - world top limit
+     * @param {number} w - world width limit
+     * @param {number} h - world height limit
+     */
+    setBounds(x: number, y: number, w: number, h: number): void;
+    /**
+     * set the camera to follow the specified renderable. <br>
+     * (this will put the camera center around the given target)
+     * @name follow
+     * @memberof Camera2d
+     * @param {Renderable|Vector2d} target - renderable or position vector to follow
+     * @param {number} [axis=me.game.viewport.AXIS.BOTH] - Which axis to follow (see {@link Camera2d.AXIS})
+     * @param {number} [damping=1] - default damping value
+     * @example
+     * // set the camera to follow this renderable on both axis, and enable damping
+     * me.game.viewport.follow(this, me.game.viewport.AXIS.BOTH, 0.1);
+     */
+    follow(target: Renderable | Vector2d, axis?: number | undefined, damping?: number | undefined): void;
+    /**
+     * unfollow the current target
+     * @name unfollow
+     * @memberof Camera2d
+     */
+    unfollow(): void;
+    /**
+     * move the camera upper-left position by the specified offset.
+     * @name move
+     * @memberof Camera2d
+     * @see Camera2d.focusOn
+     * @param {number} x
+     * @param {number} y
+     * @example
+     * // Move the camera up by four pixels
+     * me.game.viewport.move(0, -4);
+     */
+    move(x: number, y: number): void;
+    /**
+     * move the camera upper-left position to the specified coordinates
+     * @name moveTo
+     * @memberof Camera2d
+     * @see Camera2d.focusOn
+     * @param {number} x
+     * @param {number} y
+     */
+    moveTo(x: number, y: number): void;
+    /** @ignore */
+    updateTarget(): void;
+    /** @ignore */
+    update(dt: any): boolean;
+    /**
+     * shake the camera
+     * @name shake
+     * @memberof Camera2d
+     * @param {number} intensity - maximum offset that the screen can be moved
+     * while shaking
+     * @param {number} duration - expressed in milliseconds
+     * @param {number} [axis=me.game.viewport.AXIS.BOTH] - specify on which axis to apply the shake effect (see {@link Camera2d.AXIS})
+     * @param {Function} [onComplete] - callback once shaking effect is over
+     * @param {boolean} [force] - if true this will override the current effect
+     * @example
+     * // shake it baby !
+     * me.game.viewport.shake(10, 500, me.game.viewport.AXIS.BOTH);
+     */
+    shake(intensity: number, duration: number, axis?: number | undefined, onComplete?: Function | undefined, force?: boolean | undefined): void;
+    /**
+     * fadeOut(flash) effect<p>
+     * screen is filled with the specified color and slowly goes back to normal
+     * @name fadeOut
+     * @memberof Camera2d
+     * @param {Color|string} color - a CSS color value
+     * @param {number} [duration=1000] - expressed in milliseconds
+     * @param {Function} [onComplete] - callback once effect is over
+     * @example
+     * // fade the camera to white upon dying, reload the level, and then fade out back
+     * me.game.viewport.fadeIn("#fff", 150, function() {
+     *     me.audio.play("die", false);
+     *     me.level.reload();
+     *     me.game.viewport.fadeOut("#fff", 150);
+     * });
+     */
+    fadeOut(color: Color | string, duration?: number | undefined, onComplete?: Function | undefined): void;
+    /**
+     * fadeIn effect <p>
+     * fade to the specified color
+     * @name fadeIn
+     * @memberof Camera2d
+     * @param {Color|string} color - a CSS color value
+     * @param {number} [duration=1000] - expressed in milliseconds
+     * @param {Function} [onComplete] - callback once effect is over
+     * @example
+     * // flash the camera to white for 75ms
+     * me.game.viewport.fadeIn("#FFFFFF", 75);
+     */
+    fadeIn(color: Color | string, duration?: number | undefined, onComplete?: Function | undefined): void;
+    /**
+     * set the camera position around the specified object
+     * @name focusOn
+     * @memberof Camera2d
+     * @param {Renderable} target - the renderable to focus the camera on
+     */
+    focusOn(target: Renderable): void;
+    /**
+     * check if the specified renderable is in the camera
+     * @name isVisible
+     * @memberof Camera2d
+     * @param {Renderable} obj - to be checked against
+     * @param {boolean} [floating = obj.floating] - if visibility check should be done against screen coordinates
+     * @returns {boolean}
+     */
+    isVisible(obj: Renderable, floating?: boolean | undefined): boolean;
+    /**
+     * convert the given "local" (screen) coordinates into world coordinates
+     * @name localToWorld
+     * @memberof Camera2d
+     * @param {number} x
+     * @param {number} y
+     * @param {number} [v] - an optional vector object where to set the
+     * converted value
+     * @returns {Vector2d}
+     */
+    localToWorld(x: number, y: number, v?: number | undefined): Vector2d;
+    /**
+     * convert the given world coordinates into "local" (screen) coordinates
+     * @name worldToLocal
+     * @memberof Camera2d
+     * @param {number} x
+     * @param {number} y
+     * @param {number} [v] - an optional vector object where to set the
+     * converted value
+     * @returns {Vector2d}
+     */
+    worldToLocal(x: number, y: number, v?: number | undefined): Vector2d;
+    /**
+     * render the camera effects
+     * @ignore
+     */
+    drawFX(renderer: any): void;
+    /**
+     * draw all object visibile in this viewport
+     * @ignore
+     */
+    draw(renderer: any, container: any): void;
+}
+import Renderable from "./../renderable/renderable.js";
+import Matrix3d from "./../math/matrix3.js";
+import Matrix2d from "./../math/matrix2.js";
+import Vector2d from "./../math/vector2.js";
+import ObservableVector3d from "./../math/observable_vector3.js";
+import Rect from "./../geometries/rectangle.js";

package/dist/types/entity/entity.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @classdesc
+ * a Generic Object Entity
+ * @augments Renderable
+ * @see Renderable
+ */
+export default class Entity extends Renderable {
+    /**
+     * @param {number} x - the x coordinates of the entity object
+     * @param {number} y - the y coordinates of the entity object
+     * @param {object} settings - Entity properties, to be defined through Tiled or when calling the entity constructor
+     * <img src="images/object_properties.png"/>
+     * @param {number} settings.width - the physical width the entity takes up in game
+     * @param {number} settings.height - the physical height the entity takes up in game
+     * @param {string} [settings.name] - object entity name
+     * @param {string} [settings.id] - object unique IDs
+     * @param {Image|string} [settings.image] - resource name of a spritesheet to use for the entity renderable component
+     * @param {Vector2d} [settings.anchorPoint=0.0] - Entity anchor point
+     * @param {number} [settings.framewidth=settings.width] - width of a single frame in the given spritesheet
+     * @param {number} [settings.frameheight=settings.width] - height of a single frame in the given spritesheet
+     * @param {string} [settings.type] - object type
+     * @param {number} [settings.collisionMask] - Mask collision detection for this object
+     * @param {Rect[]|Polygon[]|Line[]|Ellipse[]} [settings.shapes] - the initial list of collision shapes (usually populated through Tiled)
+     */
+    constructor(x: number, y: number, settings: {
+        width: number;
+        height: number;
+        name?: string | undefined;
+        id?: string | undefined;
+        image?: string | (new (width?: number | undefined, height?: number | undefined) => HTMLImageElement) | undefined;
+        anchorPoint?: any;
+        framewidth?: number | undefined;
+        frameheight?: number | undefined;
+        type?: string | undefined;
+        collisionMask?: number | undefined;
+        shapes?: Line[] | Polygon[] | Ellipse[] | Rect[] | undefined;
+    });
+    /**
+     * The array of renderable children of this entity.
+     * @ignore
+     */
+    children: any[];
+    public set renderable(arg: Renderable);
+    /**
+     * The entity renderable component (can be any objects deriving from me.Renderable, like me.Sprite for example)
+     * @public
+     * @type {Renderable}
+     * @name renderable
+     * @memberof Entity
+     */
+    public get renderable(): Renderable;
+    /**
+     * object type (as defined in Tiled)
+     * @public
+     * @type {string}
+     * @name type
+     * @memberof Entity
+     */
+    public type: string;
+    /**
+     * object unique ID (as defined in Tiled)
+     * @public
+     * @type {number}
+     * @name id
+     * @memberof Entity
+     */
+    public id: number;
+    /**
+     * dead/living state of the entity<br>
+     * default value : true
+     * @public
+     * @type {boolean}
+     * @name alive
+     * @memberof Entity
+     */
+    public alive: boolean;
+    body: Body;
+    /** @ignore */
+    update(dt: any): boolean;
+    /**
+     * update the bounds position when the body is modified
+     * @ignore
+     * @name onBodyUpdate
+     * @memberof Entity
+     * @param {Body} body - the body whose bounds to update
+     */
+    onBodyUpdate(body: Body): void;
+    preDraw(renderer: any): void;
+    /**
+     * onDeactivateEvent Notification function<br>
+     * Called by engine before deleting the object
+     * @name onDeactivateEvent
+     * @memberof Entity
+     */
+    onDeactivateEvent(): void;
+}
+import Renderable from "./../renderable/renderable.js";
+import Body from "./../physics/body.js";

package/{src/game.js → dist/types/game.d.ts}

@@ -1,20 +1,9 @@
-import * as event from "./system/event.js";
-import Application from "./application/application.js";
-
+export default game;
 /**
  * game is a default instance of a melonJS Application and represents your current game,
  * it contains all the objects, tilemap layers, current viewport, collision map, etc...<br>
  * @namespace game
  * @see Application
  */
-
-// create a default melonJS application instance
-let game = new Application();
-
- // initialize the game manager on system boot
-event.on(event.BOOT, () => {
-    // initialize the default game instance
-    game.init();
-});
-
-export default game;
+declare let game: Application;
+import Application from "./application/application.js";

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

@@ -0,0 +1,154 @@
+/**
+ * @classdesc
+ * an ellipse Object
+ */
+export default class Ellipse {
+    /**
+     * @param {number} x - the center x coordinate of the ellipse
+     * @param {number} y - the center y coordinate of the ellipse
+     * @param {number} w - width (diameter) of the ellipse
+     * @param {number} h - height (diameter) of the ellipse
+     */
+    constructor(x: number, y: number, w: number, h: number);
+    /**
+     * the center coordinates of the ellipse
+     * @public
+     * @type {Vector2d}
+     * @name pos
+     * @memberof Ellipse
+     */
+    public pos: Vector2d;
+    /**
+     * The bounding rectangle for this shape
+     * @private
+     */
+    private _bounds;
+    /**
+     * Maximum radius of the ellipse
+     * @public
+     * @type {number}
+     * @name radius
+     * @memberof Ellipse
+     */
+    public radius: number;
+    /**
+     * Pre-scaled radius vector for ellipse
+     * @public
+     * @type {Vector2d}
+     * @name radiusV
+     * @memberof Ellipse
+     */
+    public radiusV: Vector2d;
+    /**
+     * Radius squared, for pythagorean theorom
+     * @public
+     * @type {Vector2d}
+     * @name radiusSq
+     * @memberof Ellipse
+     */
+    public radiusSq: Vector2d;
+    /**
+     * x/y scaling ratio for ellipse
+     * @public
+     * @type {Vector2d}
+     * @name ratio
+     * @memberof Ellipse
+     */
+    public ratio: Vector2d;
+    shapeType: string;
+    /** @ignore */
+    onResetEvent(x: any, y: any, w: any, h: any): void;
+    /**
+     * set new value to the Ellipse shape
+     * @name setShape
+     * @memberof Ellipse
+     * @param {number} x - the center x coordinate of the ellipse
+     * @param {number} y - the center y coordinate of the ellipse
+     * @param {number} w - width (diameter) of the ellipse
+     * @param {number} h - height (diameter) of the ellipse
+     * @returns {Ellipse} this instance for objecf chaining
+     */
+    setShape(x: number, y: number, w: number, h: number): Ellipse;
+    /**
+     * Rotate this Ellipse (counter-clockwise) by the specified angle (in radians).
+     * @name rotate
+     * @memberof Ellipse
+     * @param {number} angle - The angle to rotate (in radians)
+     * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around
+     * @returns {Ellipse} Reference to this object for method chaining
+     */
+    rotate(angle: number, v?: Vector2d | ObservableVector2d): Ellipse;
+    /**
+     * Scale this Ellipse by the specified scalar.
+     * @name scale
+     * @memberof Ellipse
+     * @param {number} x
+     * @param {number} [y=x]
+     * @returns {Ellipse} Reference to this object for method chaining
+     */
+    scale(x: number, y?: number | undefined): Ellipse;
+    /**
+     * Scale this Ellipse by the specified vector.
+     * @name scale
+     * @memberof Ellipse
+     * @param {Vector2d} v
+     * @returns {Ellipse} Reference to this object for method chaining
+     */
+    scaleV(v: Vector2d): Ellipse;
+    /**
+     * apply the given transformation matrix to this ellipse
+     * @name transform
+     * @memberof Ellipse
+     * @param {Matrix2d} matrix - the transformation matrix
+     * @returns {Polygon} Reference to this object for method chaining
+     */
+    transform(matrix: Matrix2d): Polygon;
+    /**
+     * translate the circle/ellipse by the specified offset
+     * @name translate
+     * @memberof Ellipse
+     * @method
+     * @param {number} x - x offset
+     * @param {number} y - y offset
+     * @returns {Ellipse} this ellipse
+     */
+    /**
+     * translate the circle/ellipse by the specified vector
+     * @name translate
+     * @memberof Ellipse
+     * @param {Vector2d} v - vector offset
+     * @returns {Ellipse} this ellipse
+     */
+    translate(...args: any[]): Ellipse;
+    /**
+     * check if this circle/ellipse contains the specified point
+     * @name contains
+     * @method
+     * @memberof Ellipse
+     * @param {Vector2d} point
+     * @returns {boolean} true if contains
+     */
+    /**
+     * check if this circle/ellipse contains the specified point
+     * @name contains
+     * @memberof Ellipse
+     * @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 Ellipse
+     * @returns {Bounds} this shape bounding box Rectangle object
+     */
+    getBounds(): Bounds;
+    /**
+     * clone this Ellipse
+     * @name clone
+     * @memberof Ellipse
+     * @returns {Ellipse} new Ellipse
+     */
+    clone(): Ellipse;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * @classdesc
+ * a line segment Object
+ * @augments Polygon
+ * @param {number} x - origin point of the Line
+ * @param {number} y - origin point of the Line
+ * @param {Vector2d[]} points - array of vectors defining the Line
+ */
+export default class Line extends Polygon {
+}
+import Polygon from "./poly.js";

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;
+}