melonjs 15.2.1 → 15.4.0

package/dist/types/math/vector3.d.ts

@@ -12,18 +12,16 @@ export default class Vector3d {
     /**
      * @ignore
      */
-    onResetEvent(x?: number, y?: number, z?: number): Vector3d;
+    onResetEvent(x?: number, y?: number, z?: number): this;
     x: any;
     y: any;
     z: any;
     /**
      * @ignore
      */
-    _set(x: any, y: any, z?: number): Vector3d;
+    _set(x: any, y: any, z?: number): this;
     /**
      * set the Vector x and y properties to the given values<br>
-     * @name set
-     * @memberof Vector3d
      * @param {number} x
      * @param {number} y
      * @param {number} [z=0]
@@ -32,39 +30,29 @@ export default class Vector3d {
     set(x: number, y: number, z?: number | undefined): Vector3d;
     /**
      * set the Vector x and y properties to 0
-     * @name setZero
-     * @memberof Vector3d
      * @returns {Vector3d} Reference to this object for method chaining
      */
     setZero(): Vector3d;
     /**
      * set the Vector x and y properties using the passed vector
-     * @name setV
-     * @memberof Vector3d
      * @param {Vector2d|Vector3d} v
      * @returns {Vector3d} Reference to this object for method chaining
      */
     setV(v: Vector2d | Vector3d): Vector3d;
     /**
      * Add the passed vector to this vector
-     * @name add
-     * @memberof Vector3d
      * @param {Vector2d|Vector3d} v
      * @returns {Vector3d} Reference to this object for method chaining
      */
     add(v: Vector2d | Vector3d): Vector3d;
     /**
      * Substract the passed vector to this vector
-     * @name sub
-     * @memberof Vector3d
      * @param {Vector2d|Vector3d} v
      * @returns {Vector3d} Reference to this object for method chaining
      */
     sub(v: Vector2d | Vector3d): Vector3d;
     /**
      * Multiply this vector values by the given scalar
-     * @name scale
-     * @memberof Vector3d
      * @param {number} x
      * @param {number} [y=x]
      * @param {number} [z=1]
@@ -73,45 +61,33 @@ export default class Vector3d {
     scale(x: number, y?: number | undefined, z?: number | undefined): Vector3d;
     /**
      * Multiply this vector values by the passed vector
-     * @name scaleV
-     * @memberof Vector3d
      * @param {Vector2d|Vector3d} v
      * @returns {Vector3d} Reference to this object for method chaining
      */
     scaleV(v: Vector2d | Vector3d): Vector3d;
     /**
      * Convert this vector into isometric coordinate space
-     * @name toIso
-     * @memberof Vector3d
      * @returns {Vector3d} Reference to this object for method chaining
      */
     toIso(): Vector3d;
     /**
      * Convert this vector into 2d coordinate space
-     * @name to2d
-     * @memberof Vector3d
      * @returns {Vector3d} Reference to this object for method chaining
      */
     to2d(): Vector3d;
     /**
      * Divide this vector values by the passed value
-     * @name div
-     * @memberof Vector3d
      * @param {number} n - the value to divide the vector by
      * @returns {Vector3d} Reference to this object for method chaining
      */
     div(n: number): Vector3d;
     /**
      * Update this vector values to absolute values
-     * @name abs
-     * @memberof Vector3d
      * @returns {Vector3d} Reference to this object for method chaining
      */
     abs(): Vector3d;
     /**
      * Clamp the vector value within the specified value range
-     * @name clamp
-     * @memberof Vector3d
      * @param {number} low
      * @param {number} high
      * @returns {Vector3d} new me.Vector3d
@@ -119,8 +95,6 @@ export default class Vector3d {
     clamp(low: number, high: number): Vector3d;
     /**
      * Clamp this vector value within the specified value range
-     * @name clampSelf
-     * @memberof Vector3d
      * @param {number} low
      * @param {number} high
      * @returns {Vector3d} Reference to this object for method chaining
@@ -128,107 +102,73 @@ export default class Vector3d {
     clampSelf(low: number, high: number): Vector3d;
     /**
      * Update this vector with the minimum value between this and the passed vector
-     * @name minV
-     * @memberof Vector3d
      * @param {Vector2d|Vector3d} v
      * @returns {Vector3d} Reference to this object for method chaining
      */
     minV(v: Vector2d | Vector3d): Vector3d;
     /**
      * Update this vector with the maximum value between this and the passed vector
-     * @name maxV
-     * @memberof Vector3d
      * @param {Vector2d|Vector3d} v
      * @returns {Vector3d} Reference to this object for method chaining
      */
     maxV(v: Vector2d | Vector3d): Vector3d;
     /**
      * Floor the vector values
-     * @name floor
-     * @memberof Vector3d
      * @returns {Vector3d} new me.Vector3d
      */
     floor(): Vector3d;
     /**
      * Floor this vector values
-     * @name floorSelf
-     * @memberof Vector3d
      * @returns {Vector3d} Reference to this object for method chaining
      */
     floorSelf(): Vector3d;
     /**
      * Ceil the vector values
-     * @name ceil
-     * @memberof Vector3d
      * @returns {Vector3d} new me.Vector3d
      */
     ceil(): Vector3d;
     /**
      * Ceil this vector values
-     * @name ceilSelf
-     * @memberof Vector3d
      * @returns {Vector3d} Reference to this object for method chaining
      */
     ceilSelf(): Vector3d;
     /**
      * Negate the vector values
-     * @name negate
-     * @memberof Vector3d
      * @returns {Vector3d} new me.Vector3d
      */
     negate(): Vector3d;
     /**
      * Negate this vector values
-     * @name negateSelf
-     * @memberof Vector3d
      * @returns {Vector3d} Reference to this object for method chaining
      */
     negateSelf(): Vector3d;
     /**
      * Copy the components of the given vector into this one
-     * @name copy
-     * @memberof Vector3d
      * @param {Vector2d|Vector3d} v
      * @returns {Vector3d} Reference to this object for method chaining
      */
     copy(v: Vector2d | Vector3d): Vector3d;
     /**
-     * return true if the two vectors are the same
-     * @name equals
-     * @memberof Vector3d
-     * @method
-     * @param {Vector2d|Vector3d} v
-     * @returns {boolean}
-     */
-    /**
-     * return true if this vector is equal to the given values
-     * @name equals
-     * @memberof Vector3d
-     * @param {number} x
-     * @param {number} y
+     * return true if this vector is equal to the given values or vector
+     * @param {number|Vector2d|ObservableVector2d|Vector3d|ObservableVector3d} x
+     * @param {number} [y]
      * @param {number} [z]
      * @returns {boolean}
      */
     equals(...args: any[]): boolean;
     /**
      * normalize this vector (scale the vector so that its magnitude is 1)
-     * @name normalize
-     * @memberof Vector3d
      * @returns {Vector3d} Reference to this object for method chaining
      */
     normalize(): Vector3d;
     /**
      * change this vector to be perpendicular to what it was before.<br>
      * (Effectively rotates it 90 degrees in a clockwise direction around the z axis)
-     * @name perp
-     * @memberof Vector3d
      * @returns {Vector3d} Reference to this object for method chaining
      */
     perp(): Vector3d;
     /**
      * Rotate this vector (counter-clockwise) by the specified angle (in radians) around the z axis
-     * @name rotate
-     * @memberof Vector3d
      * @param {number} angle - The angle to rotate (in radians)
      * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around (on the same z axis)
      * @returns {Vector3d} Reference to this object for method chaining
@@ -236,38 +176,28 @@ export default class Vector3d {
     rotate(angle: number, v?: Vector2d | ObservableVector2d): Vector3d;
     /**
      * return the dot product of this vector and the passed one
-     * @name dot
-     * @memberof Vector3d
      * @param {Vector2d|Vector3d} v
      * @returns {number} The dot product.
      */
     dot(v: Vector2d | Vector3d): number;
     /**
      * calculate the cross product of this vector and the passed one
-     * @name cross
-     * @memberof Vector3d
      * @param {Vector3d} v
      * @returns {Vector3d} Reference to this object for method chaining
      */
     cross(v: Vector3d): Vector3d;
     /**
-     * return the square length of this vector
-     * @name length2
-     * @memberof Vector3d
-     * @returns {number} The length^2 of this vector.
-     */
+    * return the square length of this vector
+    * @returns {number} The length^2 of this vector.
+    */
     length2(): number;
     /**
      * return the length (magnitude) of this vector
-     * @name length
-     * @memberof Vector3d
      * @returns {number} the length of this vector
      */
     length(): number;
     /**
      * Linearly interpolate between this vector and the given one.
-     * @name lerp
-     * @memberof Vector3d
      * @param {Vector3d} v
      * @param {number} alpha - distance along the line (alpha = 0 will be this vector, and alpha = 1 will be the given one).
      * @returns {Vector3d} Reference to this object for method chaining
@@ -275,8 +205,6 @@ export default class Vector3d {
     lerp(v: Vector3d, alpha: number): Vector3d;
     /**
      * interpolate the position of this vector on the x and y axis towards the given one by the given maximum step.
-     * @name moveTowards
-     * @memberof Vector3d
      * @param {Vector2d|Vector3d} target
      * @param {number} step - the maximum step per iteration (Negative values will push the vector away from the target)
      * @returns {Vector3d} Reference to this object for method chaining
@@ -284,24 +212,18 @@ export default class Vector3d {
     moveTowards(target: Vector2d | Vector3d, step: number): Vector3d;
     /**
      * return the distance between this vector and the passed one
-     * @name distance
-     * @memberof Vector3d
      * @param {Vector2d|Vector3d} v
      * @returns {number}
      */
     distance(v: Vector2d | Vector3d): number;
     /**
      * return the angle between this vector and the passed one
-     * @name angle
-     * @memberof Vector3d
      * @param {Vector2d|Vector3d} v
      * @returns {number} angle in radians
      */
     angle(v: Vector2d | Vector3d): number;
     /**
      * project this vector on to another vector.
-     * @name project
-     * @memberof Vector3d
      * @param {Vector2d|Vector3d} v - The vector to project onto.
      * @returns {Vector3d} Reference to this object for method chaining
      */
@@ -309,23 +231,17 @@ export default class Vector3d {
     /**
      * Project this vector onto a vector of unit length.<br>
      * This is slightly more efficient than `project` when dealing with unit vectors.
-     * @name projectN
-     * @memberof Vector3d
      * @param {Vector2d|Vector3d} v - The unit vector to project onto.
      * @returns {Vector3d} Reference to this object for method chaining
      */
     projectN(v: Vector2d | Vector3d): Vector3d;
     /**
      * return a clone copy of this vector
-     * @name clone
-     * @memberof Vector3d
      * @returns {Vector3d} new me.Vector3d
      */
     clone(): Vector3d;
     /**
      * convert the object to a string representation
-     * @name toString
-     * @memberof Vector3d
      * @returns {string}
      */
     toString(): string;

package/dist/types/particles/settings.d.ts

@@ -1,32 +1,32 @@
 export default ParticleEmitterSettings;
 declare namespace ParticleEmitterSettings {
-    const width: number;
-    const height: number;
-    const image: HTMLCanvasElement;
-    const textureSize: number;
-    const tint: string;
-    const totalParticles: number;
-    const angle: number;
-    const angleVariation: number;
-    const minLife: number;
-    const maxLife: number;
-    const speed: number;
-    const speedVariation: number;
-    const minRotation: number;
-    const maxRotation: number;
-    const minStartScale: number;
-    const maxStartScale: number;
-    const minEndScale: number;
-    const maxEndScale: number;
-    const gravity: number;
-    const wind: number;
-    const followTrajectory: boolean;
-    const textureAdditive: boolean;
-    const blendMode: string;
-    const onlyInViewport: boolean;
-    const floating: boolean;
-    const maxParticles: number;
-    const frequency: number;
-    const duration: number;
-    const framesToSkip: number;
+    let width: number;
+    let height: number;
+    let image: HTMLCanvasElement;
+    let textureSize: number;
+    let tint: string;
+    let totalParticles: number;
+    let angle: number;
+    let angleVariation: number;
+    let minLife: number;
+    let maxLife: number;
+    let speed: number;
+    let speedVariation: number;
+    let minRotation: number;
+    let maxRotation: number;
+    let minStartScale: number;
+    let maxStartScale: number;
+    let minEndScale: number;
+    let maxEndScale: number;
+    let gravity: number;
+    let wind: number;
+    let followTrajectory: boolean;
+    let textureAdditive: boolean;
+    let blendMode: string;
+    let onlyInViewport: boolean;
+    let floating: boolean;
+    let maxParticles: number;
+    let frequency: number;
+    let duration: number;
+    let framesToSkip: number;
 }

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

@@ -272,15 +272,17 @@ export default class Body {
     forEach(callback: Function, thisArg?: object | undefined, ...args: any[]): void;
     /**
      * Returns true if the any of the shape composing the body contains the given point.
-     * @method Body#contains
-     * @param {Vector2d} point
-     * @returns {boolean} true if contains
-     */
-    /**
-     * Returns true if the any of the shape composing the body contains the given point.
-     * @param  {number} x -  x coordinate
-     * @param  {number} y -  y coordinate
+     * @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;
     /**

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

@@ -96,7 +96,7 @@ export default class Bounds {
      * @param {number} x - the x coordinate around which to center this bounds
      * @param {number} y - the y coordinate around which to center this bounds
      */
-    centerOn(x: number, y: number): Bounds;
+    centerOn(x: number, y: number): this;
     /**
      * Updates bounds using the given vertices
      * @param {Vector2d[]|Point[]} vertices - an array of Vector2d or Point
@@ -131,17 +131,17 @@ export default class Bounds {
     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.
-     * @param {number} x
-     * @param {number} y
+     * @param {number|Vector2d} x -  x coordinate or a vector point to check
+     * @param {number} [y] - y coordinate
      * @returns {boolean} True if the bounds contain the point, otherwise false
+     * @example
+     * if (bounds.contains(10, 10)) {
+     *   // do something
+     * }
+     * // or
+     * if (bounds.contains(myVector2d)) {
+     *   // do something
+     * }
      */
     contains(...args: any[]): boolean;
     /**
@@ -156,29 +156,23 @@ export default class Bounds {
      */
     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
-     * @param {number} x
-     * @param {number} y
+     * Translates the bounds by the given point
+     * @param {number|Vector2d} x -  x coordinate or a vector point to translate by
+     * @param {number} [y]
+     * @example
+     * bounds.translate(10, 10);
+     * // or
+     * bounds.translate(myVector2d);
      */
     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.
-     * @param {number} x
-     * @param {number} y
+     * @param {number|Vector2d} x -  x coordinate or a vector point to shift to
+     * @param {number} [y]
+     * @example
+     * bounds.shift(10, 10);
+     * // or
+     * bounds.shift(myVector2d);
      */
     shift(...args: any[]): void;
     /**

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

@@ -1,18 +1,18 @@
 export default collision;
 declare namespace collision {
-    const maxChildren: number;
-    const maxDepth: number;
+    let maxChildren: number;
+    let 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;
+        let NO_OBJECT: number;
+        let PLAYER_OBJECT: number;
+        let NPC_OBJECT: number;
+        let ENEMY_OBJECT: number;
+        let COLLECTABLE_OBJECT: number;
+        let ACTION_OBJECT: number;
+        let PROJECTILE_OBJECT: number;
+        let WORLD_SHAPE: number;
+        let USER: number;
+        let ALL_OBJECT: number;
     }
     /**
      * Checks for object colliding with the given line

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

@@ -25,7 +25,7 @@ export default class Detector {
      * 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
+     * @returns {boolean} true if colliding
      */
     collides(bodyA: Body, bodyB: Body, response?: ResponseObject): boolean;
     /**

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

@@ -30,13 +30,10 @@ export default class World extends Container {
      */
     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).
+     * Enabled pre-rendering for all tile layers. <br>
+     * If false layers are rendered dynamically, if true layers are first fully 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 a boolean "preRender" property to your layer in Tiled ({@link https://doc.mapeditor.org/en/stable/manual/custom-properties/#adding-properties}).
      * @type {boolean}
      * @default false
      */