melonjs 14.2.0 → 14.4.0

package/dist/types/physics/bounds.d.ts

@@ -0,0 +1,250 @@
+/**
+ * @classdesc
+ * a bound object contains methods for creating and manipulating axis-aligned bounding boxes (AABB).
+ */
+export default class Bounds {
+    /**
+     * @param {Vector2d[]} [vertices] - an array of me.Vector2d points
+     */
+    constructor(vertices?: Vector2d[] | undefined);
+    _center: Vector2d;
+    /**
+     * @ignore
+     */
+    onResetEvent(vertices: any): void;
+    min: {
+        x: number;
+        y: number;
+    } | undefined;
+    max: {
+        x: number;
+        y: number;
+    } | undefined;
+    /**
+     * reset the bound
+     * @name clear
+     * @memberof Bounds
+     */
+    clear(): void;
+    /**
+     * sets the bounds to the given min and max value
+     * @name setMinMax
+     * @memberof Bounds
+     * @param {number} minX
+     * @param {number} minY
+     * @param {number} maxX
+     * @param {number} maxY
+     */
+    setMinMax(minX: number, minY: number, maxX: number, maxY: number): void;
+    public set x(arg: number);
+    /**
+     * x position of the bound
+     * @public
+     * @type {number}
+     * @name x
+     * @memberof Bounds
+     */
+    public get x(): number;
+    public set y(arg: number);
+    /**
+     * y position of the bounds
+     * @public
+     * @type {number}
+     * @name y
+     * @memberof Bounds
+     */
+    public get y(): number;
+    public set width(arg: number);
+    /**
+     * width of the bounds
+     * @public
+     * @type {number}
+     * @name width
+     * @memberof Bounds
+     */
+    public get width(): number;
+    public set height(arg: number);
+    /**
+     * width of the bounds
+     * @public
+     * @type {number}
+     * @name width
+     * @memberof Bounds
+     */
+    public get height(): number;
+    /**
+     * left coordinate of the bound
+     * @public
+     * @type {number}
+     * @name left
+     * @memberof Bounds
+     */
+    public get left(): number;
+    /**
+     * right coordinate of the bound
+     * @public
+     * @type {number}
+     * @name right
+     * @memberof Bounds
+     */
+    public get right(): number;
+    /**
+     * top coordinate of the bound
+     * @public
+     * @type {number}
+     * @name top
+     * @memberof Bounds
+     */
+    public get top(): number;
+    /**
+     * bottom coordinate of the bound
+     * @public
+     * @type {number}
+     * @name bottom
+     * @memberof Bounds
+     */
+    public get bottom(): number;
+    /**
+     * center position of the bound on the x axis
+     * @public
+     * @type {number}
+     * @name centerX
+     * @memberof Bounds
+     */
+    public get centerX(): number;
+    /**
+     * center position of the bound on the y axis
+     * @public
+     * @type {number}
+     * @name centerY
+     * @memberof Bounds
+     */
+    public get centerY(): number;
+    /**
+     * return the center position of the bound
+     * @public
+     * @type {Vector2d}
+     * @name center
+     * @memberof Bounds
+     */
+    public get center(): Vector2d;
+    /**
+     * Updates bounds using the given vertices
+     * @name update
+     * @memberof Bounds
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points
+     */
+    update(vertices: Vector2d[]): void;
+    /**
+     * add the given vertices to the bounds definition.
+     * @name add
+     * @memberof Bounds
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points
+     * @param {boolean} [clear=false] - either to reset the bounds before adding the new vertices
+     */
+    add(vertices: Vector2d[], clear?: boolean | undefined): void;
+    /**
+     * add the given bounds to the bounds definition.
+     * @name addBounds
+     * @memberof Bounds
+     * @param {Bounds} bounds
+     * @param {boolean} [clear=false] - either to reset the bounds before adding the new vertices
+     */
+    addBounds(bounds: Bounds, clear?: boolean | undefined): void;
+    /**
+     * add the given point to the bounds definition.
+     * @name addPoint
+     * @memberof Bounds
+     * @param {Vector2d|Point} point - the point to be added to the bounds
+     * @param {Matrix2d} [m] - an optional transform to apply to the given point (only if the given point is a vector)
+     */
+    addPoint(point: Vector2d | Point, m?: any): void;
+    /**
+     * add the given quad coordinates to this bound definition, multiplied by the given matrix
+     * @name addFrame
+     * @memberof Bounds
+     * @param {number} x0 - left X coordinates of the quad
+     * @param {number} y0 - top Y coordinates of the quad
+     * @param {number} x1 - right X coordinates of the quad
+     * @param {number} y1 - bottom y coordinates of the quad
+     * @param {Matrix2d} [m] - an optional transform to apply to the given frame coordinates
+     */
+    addFrame(x0: number, y0: number, x1: number, y1: number, m?: any): void;
+    /**
+     * Returns true if the bounds contains the given point.
+     * @name contains
+     * @memberof Bounds
+     * @method
+     * @param {Vector2d} point
+     * @returns {boolean} True if the bounds contain the point, otherwise false
+     */
+    /**
+     * Returns true if the bounds contains the given point.
+     * @name contains
+     * @memberof Bounds
+     * @param {number} x
+     * @param {number} y
+     * @returns {boolean} True if the bounds contain the point, otherwise false
+     */
+    contains(...args: any[]): boolean;
+    /**
+     * Returns true if the two bounds intersect.
+     * @name overlaps
+     * @memberof Bounds
+     * @param {Bounds|Rect} bounds
+     * @returns {boolean} True if the bounds overlap, otherwise false
+     */
+    overlaps(bounds: Bounds | Rect): boolean;
+    /**
+     * determines whether all coordinates of this bounds are finite numbers.
+     * @name isFinite
+     * @memberof Bounds
+     * @returns {boolean} false if all coordinates are positive or negative Infinity or NaN; otherwise, true.
+     */
+    isFinite(): boolean;
+    /**
+     * Translates the bounds by the given vector.
+     * @name translate
+     * @memberof Bounds
+     * @method
+     * @param {Vector2d} vector
+     */
+    /**
+     * Translates the bounds by x on the x axis, and y on the y axis
+     * @name translate
+     * @memberof Bounds
+     * @param {number} x
+     * @param {number} y
+     */
+    translate(...args: any[]): void;
+    /**
+     * Shifts the bounds to the given position vector.
+     * @name shift
+     * @memberof Bounds
+     * @method
+     * @param {Vector2d} position
+     */
+    /**
+     * Shifts the bounds to the given x, y position.
+     * @name shift
+     * @memberof Bounds
+     * @param {number} x
+     * @param {number} y
+     */
+    shift(...args: any[]): void;
+    /**
+     * clone this bounds
+     * @name clone
+     * @memberof Bounds
+     * @returns {Bounds}
+     */
+    clone(): Bounds;
+    /**
+     * Returns a polygon whose edges are the same as this bounds.
+     * @name toPolygon
+     * @memberof Bounds
+     * @returns {Polygon} a new Polygon that represents this bounds.
+     */
+    toPolygon(): Polygon;
+}
+import Vector2d from "./../math/vector2.js";

package/dist/types/physics/collision.d.ts

@@ -0,0 +1,44 @@
+export default collision;
+declare namespace collision {
+    const maxChildren: number;
+    const maxDepth: number;
+    namespace types {
+        const NO_OBJECT: number;
+        const PLAYER_OBJECT: number;
+        const NPC_OBJECT: number;
+        const ENEMY_OBJECT: number;
+        const COLLECTABLE_OBJECT: number;
+        const ACTION_OBJECT: number;
+        const PROJECTILE_OBJECT: number;
+        const WORLD_SHAPE: number;
+        const USER: number;
+        const ALL_OBJECT: number;
+    }
+    /**
+     * Checks for object colliding with the given line
+     * @name rayCast
+     * @memberof collision
+     * @public
+     * @param {Line} line - line to be tested for collision
+     * @param {Array.<Renderable>} [result] - a user defined array that will be populated with intersecting physic objects.
+     * @returns {Array.<Renderable>} an array of intersecting physic objects
+     * @example
+     *    // define a line accross the viewport
+     *    var ray = new me.Line(
+     *        // absolute position of the line
+     *        0, 0, [
+     *        // starting point relative to the initial position
+     *        new me.Vector2d(0, 0),
+     *        // ending point
+     *        new me.Vector2d(me.game.viewport.width, me.game.viewport.height)
+     *    ]);
+     *
+     *    // check for collition
+     *    result = me.collision.rayCast(ray);
+     *
+     *    if (result.length > 0) {
+     *        // ...
+     *    }
+     */
+    function rayCast(line: Line, result?: Renderable[] | undefined): Renderable[];
+}

package/dist/types/physics/detector.d.ts

@@ -0,0 +1,64 @@
+/**
+ * the Detector class contains methods for detecting collisions between bodies using a broadphase algorithm.
+ */
+export default class Detector {
+    /**
+     * @param {Container} world - the physic world this detector is bind to
+     */
+    constructor(world: Container);
+    world: Container;
+    /**
+     * the default response object used for collisions
+     * (will be automatically populated by the collides functions)
+     * @type {ResponseObject}
+     */
+    response: ResponseObject;
+    /**
+     * determine if two objects should collide (based on both respective objects body collision mask and type).<br>
+     * you can redefine this function if you need any specific rules over what should collide with what.
+     * @param {Renderable} a - a reference to the object A.
+     * @param {Renderable} b - a reference to the object B.
+     * @returns {boolean} true if they should collide, false otherwise
+     */
+    shouldCollide(a: Renderable, b: Renderable): boolean;
+    /**
+     * detect collision between two bodies.
+     * @param {Body} bodyA - a reference to body A.
+     * @param {Body} bodyB - a reference to body B.
+     * @returns {Boolean} true if colliding
+     */
+    collides(bodyA: Body, bodyB: Body, response?: ResponseObject): boolean;
+    /**
+     * find all the collisions for the specified object using a broadphase algorithm
+     * @ignore
+     * @param {Renderable} objA - object to be tested for collision
+     * @returns {boolean} in case of collision, false otherwise
+     */
+    collisions(objA: Renderable): boolean;
+    /**
+     * Checks for object colliding with the given line
+     * @ignore
+     * @param {Line} line - line to be tested for collision
+     * @param {Array.<Renderable>} [result] - a user defined array that will be populated with intersecting physic objects.
+     * @returns {Array.<Renderable>} an array of intersecting physic objects
+     * @example
+     *    // define a line accross the viewport
+     *    var ray = new me.Line(
+     *        // absolute position of the line
+     *        0, 0, [
+     *        // starting point relative to the initial position
+     *        new me.Vector2d(0, 0),
+     *        // ending point
+     *        new me.Vector2d(me.game.viewport.width, me.game.viewport.height)
+     *    ]);
+     *
+     *    // check for collition
+     *    result = me.collision.rayCast(ray);
+     *
+     *    if (result.length > 0) {
+     *        // ...
+     *    }
+     */
+    rayCast(line: Line, result?: Renderable[] | undefined): Array<Renderable>;
+}
+import ResponseObject from "./response.js";

package/dist/types/physics/quadtree.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @classdesc
+ * a QuadTree implementation in JavaScript, a 2d spatial subdivision algorithm.
+ * @see game.world.broadphase
+ */
+export default class QuadTree {
+    /**
+     * @param {World} world - the physic world this QuadTree belongs to
+     * @param {Bounds} bounds - bounds of the node
+     * @param {number} [max_objects=4] - max objects a node can hold before splitting into 4 subnodes
+     * @param {number} [max_levels=4] - total max levels inside root Quadtree
+     * @param {number} [level] - deepth level, required for subnodes
+     */
+    constructor(world: World, bounds: Bounds, max_objects?: number | undefined, max_levels?: number | undefined, level?: number | undefined);
+    world: World;
+    bounds: Bounds;
+    max_objects: number;
+    max_levels: number;
+    level: number;
+    objects: any[];
+    nodes: any[];
+    split(): void;
+    getIndex(item: any): number;
+    /**
+     * Insert the given object container into the node.
+     * @name insertContainer
+     * @memberof QuadTree
+     * @param {Container} container - group of objects to be added
+     */
+    insertContainer(container: Container): void;
+    /**
+     * Insert the given object into the node. If the node
+     * exceeds the capacity, it will split and add all
+     * objects to their corresponding subnodes.
+     * @name insert
+     * @memberof QuadTree
+     * @param {object} item - object to be added
+     */
+    insert(item: object): void;
+    /**
+     * Return all objects that could collide with the given object
+     * @name retrieve
+     * @memberof QuadTree
+     * @param {object} item - object to be checked against
+     * @param {object} [fn] - a sorting function for the returned array
+     * @returns {object[]} array with all detected objects
+     */
+    retrieve(item: object, fn?: object | undefined): object[];
+    /**
+     * Remove the given item from the quadtree.
+     * (this function won't recalculate the impacted node)
+     * @name remove
+     * @memberof QuadTree
+     * @param {object} item - object to be removed
+     * @returns {boolean} true if the item was found and removed.
+     */
+    remove(item: object): boolean;
+    /**
+     * return true if the node is prunable
+     * @name isPrunable
+     * @memberof QuadTree
+     * @returns {boolean} true if the node is prunable
+     */
+    isPrunable(): boolean;
+    /**
+     * return true if the node has any children
+     * @name hasChildren
+     * @memberof QuadTree
+     * @returns {boolean} true if the node has any children
+     */
+    hasChildren(): boolean;
+    /**
+     * clear the quadtree
+     * @name clear
+     * @memberof QuadTree
+     * @param {Bounds} [bounds=this.bounds] - the bounds to be cleared
+     */
+    clear(bounds?: any): void;
+}

package/dist/types/physics/response.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @classdesc
+ * An object representing the result of an intersection.
+ * @property {Renderable} a The first object participating in the intersection
+ * @property {Renderable} b The second object participating in the intersection
+ * @property {number} overlap Magnitude of the overlap on the shortest colliding axis
+ * @property {Vector2d} overlapV The overlap vector (i.e. `overlapN.scale(overlap, overlap)`). If this vector is subtracted from the position of a, a and b will no longer be colliding
+ * @property {Vector2d} overlapN The shortest colliding axis (unit-vector)
+ * @property {boolean} aInB Whether the first object is entirely inside the second
+ * @property {boolean} bInA Whether the second object is entirely inside the first
+ * @property {number} indexShapeA The index of the colliding shape for the object a body
+ * @property {number} indexShapeB The index of the colliding shape for the object b body
+ * @name ResponseObject
+ * @public
+ */
+export default class ResponseObject {
+    a: any;
+    b: any;
+    overlapN: Vector2d;
+    overlapV: Vector2d;
+    aInB: boolean;
+    bInA: boolean;
+    indexShapeA: number;
+    indexShapeB: number;
+    overlap: number;
+    /**
+     * Set some values of the response back to their defaults. <br>
+     * Call this between tests if you are going to reuse a single <br>
+     * Response object for multiple intersection tests <br>
+     * (recommended as it will avoid allocating extra memory) <br>
+     * @name clear
+     * @public
+     * @returns {object} this object for chaining
+     */
+    public clear(): object;
+}
+import Vector2d from "./../math/vector2.js";

package/dist/types/physics/sat.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Checks whether polygons collide.
+ * @ignore
+ * @param {Renderable} a - a reference to the object A.
+ * @param {Polygon} polyA - a reference to the object A Polygon to be tested
+ * @param {Renderable} b - a reference to the object B.
+ * @param {Polygon} polyB - a reference to the object B Polygon to be tested
+ * @param {Response=} response - Response object (optional) that will be populated if they intersect.
+ * @returns {boolean} true if they intersect, false if they don't.
+ */
+export function testPolygonPolygon(a: Renderable, polyA: Polygon, b: Renderable, polyB: Polygon, response?: Response | undefined): boolean;
+/**
+ * Check if two Ellipse collide.
+ * @ignore
+ * @param {Renderable} a - a reference to the object A.
+ * @param {Ellipse} ellipseA - a reference to the object A Ellipse to be tested
+ * @param {Renderable} b - a reference to the object B.
+ * @param {Ellipse} ellipseB - a reference to the object B Ellipse to be tested
+ * @param {Response=} response - Response object (optional) that will be populated if
+ *   the circles intersect.
+ * @returns {boolean} true if the circles intersect, false if they don't.
+ */
+export function testEllipseEllipse(a: Renderable, ellipseA: Ellipse, b: Renderable, ellipseB: Ellipse, response?: Response | undefined): boolean;
+/**
+ * Check if a polygon and an ellipse collide.
+ * @ignore
+ * @param {Renderable} a - a reference to the object A.
+ * @param {Polygon} polyA - a reference to the object A Polygon to be tested
+ * @param {Renderable} b - a reference to the object B.
+ * @param {Ellipse} ellipseB - a reference to the object B Ellipse to be tested
+ * @param {Response=} response - Response object (optional) that will be populated if they intersect.
+ * @returns {boolean} true if they intersect, false if they don't.
+ */
+export function testPolygonEllipse(a: Renderable, polyA: Polygon, b: Renderable, ellipseB: Ellipse, response?: Response | undefined): boolean;
+/**
+ * Check if an ellipse and a polygon collide. <br>
+ * **NOTE:** This is slightly less efficient than testPolygonEllipse as it just
+ * runs testPolygonEllipse and reverses the response at the end.
+ * @ignore
+ * @param {Renderable} a - a reference to the object A.
+ * @param {Ellipse} ellipseA - a reference to the object A Ellipse to be tested
+ * @param {Renderable} b - a reference to the object B.
+ * @param {Polygon} polyB - a reference to the object B Polygon to be tested
+ * @param {Response=} response - Response object (optional) that will be populated if
+ *   they intersect.
+ * @returns {boolean} true if they intersect, false if they don't.
+ */
+export function testEllipsePolygon(a: Renderable, ellipseA: Ellipse, b: Renderable, polyB: Polygon, response?: Response | undefined): boolean;

package/dist/types/physics/world.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @classdesc
+ * an object representing the physic world, and responsible for managing and updating all childs and physics
+ * @augments Container
+ */
+export default class World extends Container {
+    /**
+     * @param {number} [x=0] - position of the container (accessible via the inherited pos.x property)
+     * @param {number} [y=0] - position of the container (accessible via the inherited pos.y property)
+     * @param {number} [width=game.viewport.width] - width of the container
+     * @param {number} [height=game.viewport.height] - height of the container
+     */
+    constructor(x?: number | undefined, y?: number | undefined, width?: number | undefined, height?: number | undefined);
+    /**
+     * the application (game) this physic world belong to
+     * @type {Application}
+     */
+    app: Application;
+    /**
+     * the rate at which the game world is updated,
+     * may be greater than or lower than the display fps
+     * @default 60
+     * @see timer.maxfps
+     */
+    fps: number;
+    /**
+     * world gravity
+     * @type {Vector2d}
+     * @default <0,0.98>
+     */
+    gravity: Vector2d;
+    /**
+     * Specify the rendering method for tile layers. <br>
+     * if false visible part of the layers are rendered dynamically,<br>
+     * if true the entire layers are first rendered into an offscreen canvas.<br>
+     * the "best" rendering method depends of your game
+     * (amount of layer, layer size, amount of tiles per layer, etc.)<br>
+     * note : rendering method is also configurable per layer by adding this
+     * property to your layer (in Tiled).
+     * @type {boolean}
+     * @default false
+     */
+    preRender: boolean;
+    /**
+     * the active physic bodies in this simulation
+     * @type {Set<Body>}
+     */
+    bodies: Set<Body>;
+    /**
+     * the instance of the game world quadtree used for broadphase
+     * @type {QuadTree}
+     */
+    broadphase: QuadTree;
+    /**
+     * the collision detector instance used by this world instance
+     * @type {Detector}
+     */
+    detector: Detector;
+    /**
+     * Add a physic body to the game world
+     * @see Container.addChild
+     * @param {Body} body
+     * @returns {World} this game world
+     */
+    addBody(body: Body): World;
+    /**
+     * Remove a physic body from the game world
+     * @see Container.removeChild
+     * @param {Body} body
+     * @returns {World} this game world
+     */
+    removeBody(body: Body): World;
+    /**
+     * Apply gravity to the given body
+     * @private
+     * @param {Body} body
+     */
+    private bodyApplyGravity;
+}
+import Container from "../renderable/container.js";
+import Vector2d from "./../math/vector2.js";
+import QuadTree from "./quadtree.js";
+import Detector from "./detector.js";

package/dist/types/plugin/plugin.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This namespace is a container for all registered plugins.
+ * @see plugin.register
+ * @namespace plugins
+ */
+export const plugins: {};
+/**
+ * @namespace plugin
+ */
+export const plugin: any;

package/dist/types/polyfill/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/requestAnimationFrame.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,19 @@
+/**
+ * @classdesc
+ * a basic collectable helper class for immovable object (e.g. a coin)
+ * @augments Sprite
+ */
+export default class Collectable extends Sprite {
+    /**
+     * @param {number} x - the x coordinates of the collectable
+     * @param {number} y - the y coordinates of the collectable
+     * @param {object} settings - See {@link Sprite}
+     */
+    constructor(x: number, y: number, settings: object);
+    name: any;
+    type: any;
+    id: any;
+    body: Body;
+}
+import Sprite from "./sprite.js";
+import Body from "./../physics/body.js";

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

@@ -0,0 +1,28 @@
+/**
+ * @classdesc
+ * a generic Color Layer Object.  Fills the entire Canvas with the color not just the container the object belongs to.
+ * @augments Renderable
+ */
+export default class ColorLayer extends Renderable {
+    /**
+     * @param {string} name - Layer name
+     * @param {Color|string} color - CSS color
+     * @param {number} [z = 0] - z-index position
+     */
+    constructor(name: string, color: Color | string, z?: number | undefined);
+    /**
+     * the layer color component
+     * @public
+     * @type {Color}
+     * @name color
+     * @memberof ColorLayer#
+     */
+    public color: Color;
+    onResetEvent(name: any, color: any, z?: number): void;
+    /**
+     * Destroy function
+     * @ignore
+     */
+    destroy(): void;
+}
+import Renderable from "./renderable.js";