melonjs 19.4.0 → 19.6.0

package/build/physics/body.d.ts

@@ -1,351 +0,0 @@
-/**
- * @import Entity from "./../renderable/entity/entity.js";
- * @import Container from "./../renderable/container.js";
- * @import Renderable from "./../renderable/renderable.js";
- * @import Sprite from "./../renderable/sprite.js";
- * @import NineSliceSprite from "./../renderable/nineslicesprite.js";
- * @import {Vector2d} from "../math/vector2d.js";
- * @import ResponseObject from "./response.js";
- **/
-/**
- * a Generic Physic Body Object with some physic properties and behavior functionality, to add as a member of a Renderable.
- * @category Physics
- * @see Renderable.body
- */
-export default class Body {
-    /**
-     * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} ancestor - the parent object this body is attached to
-     * @param {Rect|Rect[]|Polygon|Polygon[]|Line|Line[]|Ellipse|Ellipse[]|Point|Point[]|Bounds|Bounds[]|object} [shapes] - a initial shape, list of shapes, or JSON object defining the body
-     * @param {Function} [onBodyUpdate] - callback for when the body is updated (e.g. add/remove shapes)
-     */
-    constructor(ancestor: Renderable | Container | Entity | Sprite | NineSliceSprite, shapes?: Rect | Rect[] | Polygon | Polygon[] | Line | Line[] | Ellipse | Ellipse[] | Point | Point[] | Bounds | Bounds[] | object, onBodyUpdate?: Function);
-    /**
-     * a reference to the parent object that contains this body,
-     * or undefined if it has not been added to one.
-     * @public
-     * @type {Renderable|Container|Entity|Sprite|NineSliceSprite}
-     * @default undefined
-     */
-    public ancestor: Renderable | Container | Entity | Sprite | NineSliceSprite;
-    /**
-     * The AABB bounds box representing this body
-     * @public
-     * @type {Bounds}
-     */
-    public bounds: Bounds;
-    /**
-     * The collision shapes of the body
-     * @ignore
-     * @type {Polygon[]|Line[]|Ellipse[]|Point|Point[]}
-     */
-    shapes: Polygon[] | Line[] | Ellipse[] | Point | Point[];
-    /**
-     * The body collision mask, that defines what should collide with what.<br>
-     * (by default will collide with all entities)
-     * @ignore
-     * @type {number}
-     * @default collision.types.ALL_OBJECT
-     * @see collision.types
-     */
-    collisionMask: number;
-    /**
-     * define the collision type of the body for collision filtering
-     * @public
-     * @type {number}
-     * @default collision.types.ENEMY_OBJECT
-     * @see collision.types
-     * @example
-     * // set the body collision type
-     * body.collisionType = me.collision.types.PLAYER_OBJECT;
-     */
-    public collisionType: number;
-    /**
-     * The current velocity of the body.
-     * See to apply a force if you need to modify a body velocity
-     * @see Body.force
-     * @public
-     * @type {Vector2d}
-     * @default <0,0>
-     */
-    public vel: Vector2d;
-    /**
-     * body force to apply to this the body in the current step.
-     * (any positive or negative force will be cancelled after every world/body update cycle)
-     * @public
-     * @type {Vector2d}
-     * @default <0,0>
-     * @see Body.setMaxVelocity
-     * @example
-     * // define a default maximum acceleration, initial force and friction
-     * this.body.force.set(1, 0);
-     * this.body.friction.set(0.4, 0);
-     * this.body.setMaxVelocity(3, 15);
-     *
-     * // apply a positive or negative force when pressing left of right key
-     * update(dt) {
-     *     if (me.input.isKeyPressed("left"))    {
-     *          this.body.force.x = -this.body.maxVel.x;
-     *      } else if (me.input.isKeyPressed("right")) {
-     *         this.body.force.x = this.body.maxVel.x;
-     *     }
-     * }
-     */
-    public force: Vector2d;
-    /**
-     * body friction
-     * @public
-     * @type {Vector2d}
-     * @default <0,0>
-     */
-    public friction: Vector2d;
-    /**
-     * the body bounciness level when colliding with other solid bodies :
-     * a value of 0 will not bounce, a value of 1 will fully rebound.
-     * @public
-     * @type {number}
-     * @default 0
-     */
-    public bounce: number;
-    /**
-     * the body mass
-     * @public
-     * @type {number}
-     * @default 1
-     */
-    public mass: number;
-    /**
-     * max velocity (to limit body velocity)
-     * @public
-     * @type {Vector2d}
-     * @default <490,490>
-     */
-    public maxVel: Vector2d;
-    /**
-     * Either this body is a static body or not.
-     * A static body is completely fixed and can never change position or angle.
-     * @readonly
-     * @public
-     * @type {boolean}
-     * @default false
-     */
-    public readonly isStatic: boolean;
-    /**
-     * The degree to which this body is affected by the world gravity
-     * @public
-     * @see {@link World.gravity}
-     * @type {number}
-     * @default 1.0
-     */
-    public gravityScale: number;
-    /**
-     * If true this body won't be affected by the world gravity
-     * @public
-     * @see {@link World.gravity}
-     * @type {boolean}
-     * @default false
-     */
-    public ignoreGravity: boolean;
-    /**
-     * falling state of the body<br>
-     * true if the object is falling<br>
-     * false if the object is standing on something<br>
-     * @readonly
-     * @public
-     * @type {boolean}
-     * @default false
-     */
-    public readonly falling: boolean;
-    /**
-     * jumping state of the body<br>
-     * equal true if the body is jumping<br>
-     * @readonly
-     * @public
-     * @type {boolean}
-     * @default false
-     */
-    public readonly jumping: boolean;
-    onBodyUpdate: Function | undefined;
-    /**
-     * set the body as a static body
-     * static body do not move automatically and do not check against collision with others
-     * @param {boolean} [isStatic=true]
-     */
-    setStatic(isStatic?: boolean): void;
-    /**
-     * add a collision shape to this body <br>
-     * (note: me.Rect objects will be converted to me.Polygon before being added)
-     * @param {Rect|Polygon|Line|Ellipse|Point|Point[]|Bounds|object} shape - a shape or JSON object
-     * @returns {number} the shape array length
-     * @example
-     * // add a rectangle shape
-     * this.body.addShape(new me.Rect(0, 0, image.width, image.height));
-     * // add a shape from a JSON object
-     * this.body.addShape(me.loader.getJSON("shapesdef").banana);
-     */
-    addShape(shape: Rect | Polygon | Line | Ellipse | Point | Point[] | Bounds | object): number;
-    /**
-     * set the body vertices to the given one
-     * @param {Vector2d[]} vertices - an array of me.Vector2d points defining a convex hull
-     * @param {number} [index=0] - the shape object for which to set the vertices
-     * @param {boolean} [clear=true] - either to reset the body definition before adding the new vertices
-     */
-    setVertices(vertices: Vector2d[], index?: number, clear?: boolean): void;
-    /**
-     * add the given vertices to the body shape
-     * @param {Vector2d[]} vertices - an array of me.Vector2d points defining a convex hull
-     * @param {number} [index=0] - the shape object for which to set the vertices
-     */
-    addVertices(vertices: Vector2d[], index?: number): void;
-    /**
-     * add collision mesh based on a JSON object
-     * (this will also apply any physic properties defined in the given JSON file)
-     * @param {object} json - a JSON object as exported from a Physics Editor tool
-     * @param {string} [id] - an optional shape identifier within the given the json object
-     * @see https://www.codeandweb.com/physicseditor
-     * @returns {number} how many shapes were added to the body
-     * @example
-     * // define the body based on the banana shape
-     * this.body.fromJSON(me.loader.getJSON("shapesdef").banana);
-     * // or ...
-     * this.body.fromJSON(me.loader.getJSON("shapesdef"), "banana");
-     */
-    fromJSON(json: object, id?: string): number;
-    /**
-     * return the collision shape at the given index
-     * @param {number} [index=0] - the shape object at the specified index
-     * @returns {Polygon|Line|Ellipse} shape a shape object if defined
-     */
-    getShape(index?: number): Polygon | Line | Ellipse;
-    /**
-     * returns the AABB bounding box for this body
-     * @returns {Bounds} bounding box Rectangle object
-     */
-    getBounds(): Bounds;
-    /**
-     * remove the specified shape from the body shape list
-     * @param {Polygon|Line|Ellipse} shape - a shape object
-     * @returns {number} the shape array length
-     */
-    removeShape(shape: Polygon | Line | Ellipse): number;
-    /**
-     * remove the shape at the given index from the body shape list
-     * @param {number} index - the shape object at the specified index
-     * @returns {number} the shape array length
-     */
-    removeShapeAt(index: number): number;
-    /**
-     * By default all physic bodies are able to collide with all other bodies, <br>
-     * but it's also possible to specify 'collision filters' to provide a finer <br>
-     * control over which body can collide with each other.
-     * @see collision.types
-     * @param {number} [bitmask = collision.types.ALL_OBJECT] - the collision mask
-     * @example
-     * // filter collision detection with collision shapes, enemies and collectables
-     * body.setCollisionMask(me.collision.types.WORLD_SHAPE | me.collision.types.ENEMY_OBJECT | me.collision.types.COLLECTABLE_OBJECT);
-     * ...
-     * // disable collision detection with all other objects
-     * body.setCollisionMask(me.collision.types.NO_OBJECT);
-     */
-    setCollisionMask(bitmask?: number): void;
-    /**
-     * define the collision type of the body for collision filtering
-     * @see collision.types
-     * @param {number} type - the collision type
-     * @example
-     * // set the body collision type
-     * body.collisionType = me.collision.types.PLAYER_OBJECT;
-     */
-    setCollisionType(type: number): void;
-    /**
-     * the built-in function to solve the collision response
-     * @param {ResponseObject} response - the collision response object
-     * @see {@link ResponseObject}
-     */
-    respondToCollision(response: ResponseObject): void;
-    /**
-     * The forEach() method executes a provided function once per body shape element. <br>
-     * the callback function is invoked with three arguments: <br>
-     *    - The current element being processed in the array <br>
-     *    - The index of element in the array. <br>
-     *    - The array forEach() was called upon. <br>
-     * @param {Function} callback - function to execute on each element
-     * @param {object} [thisArg] - value to use as this(i.e reference Object) when executing callback.
-     * @example
-     * // iterate through all shapes of the physic body
-     * mySprite.body.forEach((shape) => {
-     *    shape.doSomething();
-     * });
-     * mySprite.body.forEach((shape, index) => { ... });
-     * mySprite.body.forEach((shape, index, array) => { ... });
-     * mySprite.body.forEach((shape, index, array) => { ... }, thisArg);
-     */
-    forEach(callback: Function, thisArg?: object): void;
-    /**
-     * Returns true if the any of the shape composing the body contains the given point.
-     * @param {number|Vector2d} x -  x coordinate or a vector point to check
-     * @param {number} [y] -  y coordinate
-     * @returns {boolean} true if contains
-     * @example
-     * if (mySprite.body.contains(10, 10)) {
-     *   // do something
-     * }
-     * // or
-     * if (mySprite.body.contains(myVector2d)) {
-     *   // do something
-     * }
-     */
-    contains(...args: any[]): boolean;
-    /**
-     * Rotate this body (counter-clockwise) by the specified angle (in radians).
-     * Unless specified the body will be rotated around its center point
-     * @param {number} angle - The angle to rotate (in radians)
-     * @param {Vector2d} [v=Body.getBounds().center] - an optional point to rotate around
-     * @returns {Body} Reference to this object for method chaining
-     */
-    rotate(angle: number, v?: Vector2d): Body;
-    /**
-     * cap the body velocity (body.maxVel property) to the specified value<br>
-     * @param {number} x - max velocity on x axis
-     * @param {number} y - max velocity on y axis
-     */
-    setMaxVelocity(x: number, y: number): void;
-    /**
-     * set the body default friction
-     * @param {number} x - horizontal friction
-     * @param {number} y - vertical friction
-     */
-    setFriction(x?: number, y?: number): void;
-    /**
-     * Updates the parent's position as well as computes the new body's velocity based
-     * on the values of force/friction.  Velocity changes are proportional to the
-     * me.timer.tick value (which can be used to scale velocities).  The approach to moving the
-     * parent renderable is to compute new values of the Body.vel property then add them to
-     * the parent.pos value thus changing the position by the amount of Body.vel each time the
-     * update call is made. <br>
-     * Updates to Body.vel are bounded by maxVel (which defaults to viewport size if not set) <br>
-     * At this time a call to Body.Update does not call the onBodyUpdate callback that is listed in the constructor arguments.
-     * @protected
-     * @param {number} dt - time since the last update in milliseconds.
-     * @returns {boolean} true if resulting velocity is different than 0
-     */
-    protected update(): boolean;
-    /**
-     * Destroy function<br>
-     * @ignore
-     */
-    destroy(): void;
-}
-import type Renderable from "./../renderable/renderable.js";
-import type Container from "./../renderable/container.js";
-import type Entity from "./../renderable/entity/entity.js";
-import type Sprite from "./../renderable/sprite.js";
-import type NineSliceSprite from "./../renderable/nineslicesprite.js";
-import { Bounds } from "./bounds.ts";
-import { Polygon } from "../geometries/polygon.ts";
-import { Line } from "./../geometries/line.ts";
-import { Ellipse } from "./../geometries/ellipse.ts";
-import { Point } from "../geometries/point.ts";
-import type { Vector2d } from "../math/vector2d.js";
-import { Rect } from "./../geometries/rectangle.ts";
-import type ResponseObject from "./response.js";
-//# sourceMappingURL=body.d.ts.map

package/build/physics/body.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"body.d.ts","sourceRoot":"","sources":["../../src/physics/body.js"],"names":[],"mappings":"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"}

package/build/physics/detector.d.ts

@@ -1,72 +0,0 @@
-export default Detector;
-/**
- * the Detector class contains methods for detecting collisions between bodies using a broadphase algorithm.
- */
-declare 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|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
-     * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
-     * @returns {boolean} true if they should collide, false otherwise
-     */
-    shouldCollide(a: Renderable | Container | Entity | Sprite | NineSliceSprite, b: Renderable | Container | Entity | Sprite | NineSliceSprite): 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|Container|Entity|Sprite|NineSliceSprite} objA - object to be tested for collision
-     * @returns {boolean} in case of collision, false otherwise
-     */
-    collisions(objA: Renderable | Container | Entity | Sprite | NineSliceSprite): 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
-     *    let ray = new Line(
-     *        // absolute position of the line
-     *        0, 0, [
-     *        // starting point relative to the initial position
-     *        new Vector2d(0, 0),
-     *        // ending point
-     *        new Vector2d(app.viewport.width, app.viewport.height)
-     *    ]);
-     *
-     *    // check for collition
-     *    result = me.collision.rayCast(ray);
-     *
-     *    if (result.length > 0) {
-     *        // ...
-     *    }
-     */
-    rayCast(line: Line, result?: Array<Renderable>): Array<Renderable>;
-}
-import type Container from "./../renderable/container.js";
-import ResponseObject from "./response.js";
-import type Renderable from "./../renderable/renderable.js";
-import type Entity from "./../renderable/entity/entity.js";
-import type Sprite from "./../renderable/sprite.js";
-import type NineSliceSprite from "./../renderable/nineslicesprite.js";
-import type { Line } from "./../geometries/line.ts";
-//# sourceMappingURL=detector.d.ts.map

package/build/physics/detector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../../src/physics/detector.js"],"names":[],"mappings":";AAuDA;;GAEG;AACH;IACC;;OAEG;IACH,mBAFW,SAAS,EAYnB;IARA,iBAAkB;IAElB;;;;OAIG;IACH,UAFU,cAAc,CAEY;IAGrC;;;;;;OAMG;IACH,iBAJW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,KAClD,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,GAChD,OAAO,CAiBnB;IAED;;;;;OAKG;IACH,gBAJW,IAAI,SACJ,IAAI,8BACF,OAAO,CAkCnB;IAED;;;;;OAKG;IACH,iBAHW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,GAChD,OAAO,CAsGnB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,cArBW,IAAI,WACJ,KAAK,CAAE,UAAU,CAAC,GAChB,KAAK,CAAE,UAAU,CAAC,CAiE9B;CACD;2BA5RyB,8BAA8B;2BA/B7B,eAAe;4BAgCf,+BAA+B;wBAFnC,kCAAkC;wBAGlC,2BAA2B;iCAClB,oCAAoC;0BAC7C,yBAAyB"}

package/build/physics/quadtree.d.ts

@@ -1,69 +0,0 @@
-/**
- * a QuadTree implementation in JavaScript, a 2d spatial subdivision algorithm.
- * @category Physics
- * @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, max_levels?: number, level?: number);
-    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.
-     * @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.
-     * @param {object} item - object to be added
-     */
-    insert(item: object): void;
-    /**
-     * Return all objects that could collide with the given object
-     * @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, result: any): object[];
-    /**
-     * Remove the given item from the quadtree.
-     * (this function won't recalculate the impacted node)
-     * @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
-     * @returns {boolean} true if the node is prunable
-     */
-    isPrunable(): boolean;
-    /**
-     * return true if the node has any children
-     * @returns {boolean} true if the node has any children
-     */
-    hasChildren(): boolean;
-    /**
-     * clear the quadtree
-     * @param {Bounds} [bounds=this.bounds] - the bounds to be cleared
-     */
-    clear(bounds?: Bounds): void;
-}
-import type World from "./world.js";
-import type { Bounds } from "./bounds.ts";
-import type Container from "./../renderable/container.js";
-//# sourceMappingURL=quadtree.d.ts.map

package/build/physics/quadtree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"quadtree.d.ts","sourceRoot":"","sources":["../../src/physics/quadtree.js"],"names":[],"mappings":"AA2DA;;;;GAIG;AACH;IACC;;;;;;OAMG;IACH,mBANW,KAAK,UACL,MAAM,gBACN,MAAM,eACN,MAAM,UACN,MAAM,EAahB;IAVA,aAAkB;IAClB,eAAoB;IAEpB,oBAA8B;IAC9B,mBAA4B;IAE5B,cAAkB;IAElB,eAAiB;IACjB,aAAe;IAMhB,cA8DC;IAOD,4BA+CC;IAED;;;OAGG;IACH,2BAFW,SAAS,QAyBnB;IAED;;;;;OAKG;IACH,aAFW,MAAM,QAoChB;IAED;;;;;OAKG;IACH,eAJW,MAAM,OACN,MAAM,gBACJ,MAAM,EAAE,CAmCpB;IAED;;;;;OAKG;IACH,aAHW,MAAM,GACJ,OAAO,CAkCnB;IAED;;;OAGG;IACH,cAFa,OAAO,CAInB;IAED;;;OAGG;IACH,eAFa,OAAO,CAUnB;IAED;;;OAGG;IACH,eAFW,MAAM,QAsBhB;CACD;uBAlZqB,YAAY;4BAET,aAAa;2BADZ,8BAA8B"}

package/build/physics/sat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sat.d.ts","sourceRoot":"","sources":["../../src/physics/sat.js"],"names":[],"mappings":"AAiNA;;;;;;;;;GASG;AACH,sCAPW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,aACP,QAAQ,YAAC,GACP,OAAO,CA8CnB;AAED;;;;;;;;;;GAUG;AACH,sCARW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,aACP,QAAQ,YAAC,GAEP,OAAO,CAiEnB;AAED;;;;;;;;;GASG;AACH,sCAPW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,aACP,QAAQ,YAAC,GACP,OAAO,CAsKnB;AAED;;;;;;;;;;;;GAYG;AACH,sCARW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,aACP,QAAQ,YAAC,GAEP,OAAO,CAiBnB;4BAvhB0B,+BAA+B;2BADhC,8BAA8B;wBADjC,kCAAkC;wBAGlC,2BAA2B;iCAClB,oCAAoC;6BAC1C,0BAA0B;6BAC1B,4BAA4B"}