melonjs 17.4.0 → 18.0.0

package/build/math/vector3d.d.ts

@@ -0,0 +1,242 @@
+import { XYPoint } from "../utils/types.ts";
+import { Vector2d } from "./vector2d.ts";
+/**
+ * a generic 3D Vector Object
+ */
+export declare class Vector3d {
+    x: number;
+    y: number;
+    z: number;
+    /**
+     * @param [x] - x value of the vector
+     * @param [y] - y value of the vector
+     * @param [z] - z value of the vector
+     */
+    constructor(x?: number, y?: number, z?: number);
+    onResetEvent(x?: number, y?: number, z?: number): void;
+    /**
+     * set the Vector x and y properties to the given values
+     * @param x x component
+     * @param y y component
+     * @param [z] z component
+     * @returns Reference to this object for method chaining
+     */
+    set(x: number, y: number, z?: number | undefined): this;
+    /**
+     * set the Vector x and y properties to 0
+     * @returns Reference to this object for method chaining
+     */
+    setZero(): this;
+    /**
+     * set the Vector x and y properties using the passed vector
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    setV(v: Vector2d | Vector3d): this;
+    /**
+     * Add the passed vector to this vector
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    add(v: Vector2d | Vector3d): this;
+    /**
+     * Substract the passed vector to this vector
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    sub(v: Vector2d | Vector3d): this;
+    /**
+     * Multiply this vector values by the given scalar
+     * @param x x component
+     * @param [y] y component
+     * @param [z] z component
+     * @returns Reference to this object for method chaining
+     */
+    scale(x: number, y?: number, z?: number): this;
+    /**
+     * Multiply this vector values by the passed vector
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    scaleV(v: Vector3d): this;
+    /**
+     * Convert this vector into isometric coordinate space
+     * @returns Reference to this object for method chaining
+     */
+    toIso(): this;
+    /**
+     * Convert this vector into 2d coordinate space
+     * @returns Reference to this object for method chaining
+     */
+    to2d(): this;
+    /**
+     * Divide this vector values by the passed value
+     * @param n - the value to divide the vector by
+     * @returns Reference to this object for method chaining
+     */
+    div(n: number): this;
+    /**
+     * Update this vector values to absolute values
+     * @returns Reference to this object for method chaining
+     */
+    abs(): this;
+    /**
+     * Clamp the vector value within the specified value range
+     * @param low lower bound
+     * @param high upper bound
+     * @returns new Vector3d
+     */
+    clamp(low: number, high: number): Vector3d;
+    /**
+     * Clamp this vector value within the specified value range
+     * @param low lower bound
+     * @param high upper bound
+     * @returns Reference to this object for method chaining
+     */
+    clampSelf(low: number, high: number): this;
+    /**
+     * Update this vector with the minimum value between this and the passed vector
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    minV(v: Vector2d | Vector3d): this;
+    /**
+     * Update this vector with the maximum value between this and the passed vector
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    maxV(v: Vector2d | Vector3d): this;
+    /**
+     * Floor the vector values
+     * @returns new Vector3d
+     */
+    floor(): Vector3d;
+    /**
+     * Floor this vector values
+     * @returns Reference to this object for method chaining
+     */
+    floorSelf(): this;
+    /**
+     * Ceil the vector values
+     * @returns new Vector3d
+     */
+    ceil(): Vector3d;
+    /**
+     * Ceil this vector values
+     * @returns Reference to this object for method chaining
+     */
+    ceilSelf(): this;
+    /**
+     * Negate the vector values
+     * @returns new Vector3d
+     */
+    negate(): Vector3d;
+    /**
+     * Negate this vector values
+     * @returns Reference to this object for method chaining
+     */
+    negateSelf(): this;
+    /**
+     * Copy the components of the given vector into this one
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    copy(v: Vector2d | Vector3d): this;
+    /**
+     * return true if this vector is equal to the given values or vector
+     * @param args other vector or vector components
+     * @returns true if both vectors are equal
+     */
+    equals(...args: [number] | [Vector2d] | [Vector3d] | [number, number] | [number, number, number]): boolean;
+    /**
+     * normalize this vector (scale the vector so that its magnitude is 1)
+     * @returns Reference to this object for method chaining
+     */
+    normalize(): this;
+    /**
+     * 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)
+     * @returns Reference to this object for method chaining
+     */
+    perp(): this;
+    /**
+     * Rotate this vector (counter-clockwise) by the specified angle (in radians) around the z axis
+     * @param angle - The angle to rotate (in radians)
+     * @param [v] - an optional point to rotate around (on the same z axis)
+     * @returns Reference to this object for method chaining
+     */
+    rotate(angle: number, v?: XYPoint): this;
+    /**
+     * return the dot product of this vector and the passed one
+     * @param v other vector
+     * @returns The dot product.
+     */
+    dot(v: Vector2d | Vector3d): number;
+    /**
+     * calculate the cross product of this vector and the passed one
+     * @param v other vector
+     * @returns Reference to this object for method chaining
+     */
+    cross(v: Vector3d): this;
+    /**
+     * return the square length of this vector
+     * @returns The length^2 of this vector.
+     */
+    length2(): number;
+    /**
+     * return the length (magnitude) of this vector
+     * @returns the length of this vector
+     */
+    length(): number;
+    /**
+     * Linearly interpolate between this vector and the given one.
+     * @param v other vector
+     * @param alpha - distance along the line (alpha = 0 will be this vector, and alpha = 1 will be the given one).
+     * @returns Reference to this object for method chaining
+     */
+    lerp(v: Vector3d, alpha: number): this;
+    /**
+     * interpolate the position of this vector on the x and y axis towards the given one by the given maximum step.
+     * @param target other vector
+     * @param step - the maximum step per iteration (Negative values will push the vector away from the target)
+     * @returns Reference to this object for method chaining
+     */
+    moveTowards(target: Vector2d | Vector3d, step: number): Vector2d | Vector3d;
+    /**
+     * return the distance between this vector and the passed one
+     * @param v other vector
+     * @returns distance
+     */
+    distance(v: Vector2d | Vector3d): number;
+    /**
+     * return the angle between this vector and the passed one
+     * @param v other vector
+     * @returns angle in radians
+     */
+    angle(v: Vector2d | Vector3d): number;
+    /**
+     * project this vector on to another vector.
+     * @param v - The vector to project onto.
+     * @returns Reference to this object for method chaining
+     */
+    project(v: Vector2d | Vector3d): this;
+    /**
+     * Project this vector onto a vector of unit length.<br>
+     * This is slightly more efficient than `project` when dealing with unit vectors.
+     * @param v - The unit vector to project onto.
+     * @returns Reference to this object for method chaining
+     */
+    projectN(v: Vector2d | Vector3d): this;
+    /**
+     * return a clone copy of this vector
+     * @returns new Vector3d
+     */
+    clone(): Vector3d;
+    /**
+     * convert the object to a string representation
+     * @returns stringified representation
+     */
+    toString(): `x:${number},y:${number},z:${number}`;
+}
+export declare const vector3dPool: import("../system/pool.ts").Pool<Vector3d, [x?: number | undefined, y?: number | undefined, z?: number | undefined]>;
+//# sourceMappingURL=vector3d.d.ts.map

package/build/math/vector3d.d.ts.map

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

package/{dist/types → build}/particles/emitter.d.ts

@@ -1,7 +1,5 @@
 /**
- * @classdesc
  * Particle Emitter Object.
- * @augments Container
  */
 export default class ParticleEmitter extends Container {
     /**
@@ -64,15 +62,12 @@ export default class ParticleEmitter extends Container {
         frequency: number;
         duration: number;
         framesToSkip: number;
-    } | undefined);
+    });
     /**
      * the current (active) emitter settings
-     * @public
      * @type {ParticleEmitterSettings}
-     * @name settings
-     * @memberof ParticleEmitter
      */
-    public settings: {
+    settings: {
         width: number;
         height: number;
         image: HTMLCanvasElement;
@@ -148,7 +143,7 @@ export default class ParticleEmitter extends Container {
         duration: number;
         framesToSkip: number;
     }): void;
-    _defaultParticle: object | undefined;
+    _defaultParticle: CanvasRenderTarget | undefined;
     /**
      * returns a random point on the x axis within the bounds of this emitter
      * @returns {number}
@@ -170,7 +165,7 @@ export default class ParticleEmitter extends Container {
      * Launch particles from emitter constantly (e.g. for stream)
      * @param {number} [duration] - time that the emitter releases particles in ms
      */
-    streamParticles(duration?: number | undefined): void;
+    streamParticles(duration?: number): void;
     /**
      * Stop the emitter from generating new particles (used only if emitter is Stream)
      */
@@ -179,10 +174,12 @@ export default class ParticleEmitter extends Container {
      * Launch all particles from emitter and stop (e.g. for explosion)
      * @param {number} [total] - number of particles to launch
      */
-    burstParticles(total?: number | undefined): void;
+    burstParticles(total?: number): void;
     /**
      * @ignore
      */
     update(dt: any): boolean;
 }
 import Container from "./../renderable/container.js";
+import CanvasRenderTarget from "../video/rendertarget/canvasrendertarget.js";
+//# sourceMappingURL=emitter.d.ts.map

package/build/particles/emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../src/particles/emitter.js"],"names":[],"mappings":"AAoBA;;GAEG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,eA7BW,MAAM,KACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2EhB;IA3CA;;;OAGG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAkB;IAMlB,cAAc;IACd,iBAAoB;IAIpB,cAAc;IACd,wBAAwB;IAIxB,cAAc;IACd,uBAAuB;IAGvB,cAAc;IACd,kBAAqB;IASrB,qBAAqB;IAGrB,YAAY;IAQb;;;OAGG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAcC;IAVC,iDAGC;IASH;;;OAGG;IACH,mBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAFa,MAAM,CAIlB;IAGD,cAAc;IACd,+BAMC;IAED;;;OAGG;IACH,aAFa,OAAO,CAInB;IAED;;;OAGG;IACH,2BAFW,MAAM,QAQhB;IAED;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,uBAFW,MAAM,QAShB;IAED;;OAEG;IACH,yBAmDC;CAiBD;sBAnQqB,8BAA8B;+BACrB,6CAA6C"}

package/build/particles/particle.d.ts

@@ -0,0 +1,47 @@
+import { Vector2d } from "../math/vector2d.ts";
+import Renderable from "../renderable/renderable.js";
+import CanvasRenderer from "../video/canvas/canvas_renderer.js";
+import WebGLRenderer from "../video/webgl/webgl_renderer.js";
+import ParticleEmitter from "./emitter.js";
+/**
+ * @import ParticleEmitter from "./emitter.js";
+ */
+/**
+ * Single Particle Object.
+ */
+export default class Particle extends Renderable {
+    vel: Vector2d;
+    image: any;
+    life: number;
+    startLife: number;
+    startScale: number;
+    endScale: number;
+    gravity: number;
+    wind: number;
+    followTrajectory: boolean;
+    onlyInViewport: boolean;
+    _deltaInv: number;
+    _angle: number;
+    alive: boolean;
+    /**
+     * @param emitter - the particle emitter
+     */
+    constructor(emitter: ParticleEmitter);
+    /**
+     * @ignore
+     */
+    onResetEvent(emitter: ParticleEmitter, newInstance?: boolean): void;
+    /**
+     * Update the Particle <br>
+     * This is automatically called by the game manager {@link game}
+     * @ignore
+     * @param dt - time since the last update in milliseconds
+     */
+    update(dt: number): boolean;
+    /**
+     * @ignore
+     */
+    draw(renderer: CanvasRenderer | WebGLRenderer): void;
+}
+export declare const particlePool: import("../system/pool.ts").Pool<Particle, [emitter: ParticleEmitter]>;
+//# sourceMappingURL=particle.d.ts.map

package/build/particles/particle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle.d.ts","sourceRoot":"","sources":["../../src/particles/particle.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAgB,MAAM,qBAAqB,CAAC;AAE7D,OAAO,UAAU,MAAM,6BAA6B,CAAC;AAGrD,OAAO,cAAc,MAAM,oCAAoC,CAAC;AAChE,OAAO,aAAa,MAAM,kCAAkC,CAAC;AAC7D,OAAO,eAAe,MAAM,cAAc,CAAC;AAE3C;;GAEG;AAEH;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,UAAU;IAC/C,GAAG,EAAE,QAAQ,CAAC;IACd,KAAK,EAAE,GAAG,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IAEf;;OAEG;gBACS,OAAO,EAAE,eAAe;IAapC;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,WAAW,GAAE,OAAe;IAkFnE;;;;;OAKG;IACM,MAAM,CAAC,EAAE,EAAE,MAAM;IAuD1B;;OAEG;IACM,IAAI,CAAC,QAAQ,EAAE,cAAc,GAAG,aAAa;CAKtD;AAED,eAAO,MAAM,YAAY,wEAWxB,CAAC"}

package/{dist/types → build}/particles/settings.d.ts

@@ -30,3 +30,4 @@ declare namespace ParticleEmitterSettings {
     let duration: number;
     let framesToSkip: number;
 }
+//# sourceMappingURL=settings.d.ts.map

package/build/particles/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/particles/settings.js"],"names":[],"mappings":";;eAQW,MAAM;gBAON,MAAM;eAQN,iBAAiB;qBASjB,MAAM;cAQN,MAAM;wBAON,MAAM;eAON,MAAM;wBAON,MAAM;iBAON,MAAM;iBAON,MAAM;eAON,MAAM;wBAON,MAAM;qBAON,MAAM;qBAON,MAAM;uBAON,MAAM;uBAON,MAAM;qBAON,MAAM;qBAON,MAAM;iBAON,MAAM;cAQN,MAAM;0BASN,OAAO;yBAOP,OAAO;mBASP,MAAM;wBASN,OAAO;kBAOP,OAAO;sBAOP,MAAM;mBAON,MAAM;kBAQN,MAAM;sBAQN,MAAM"}

package/{dist/types → build}/physics/body.d.ts

@@ -4,12 +4,10 @@
  * @import Renderable from "./../renderable/renderable.js";
  * @import Sprite from "./../renderable/sprite.js";
  * @import NineSliceSprite from "./../renderable/nineslicesprite.js";
- * @import Line from "./../geometries/line.js";
- * @import Vector2d from "./../math/vector2.js";
- * @import ObservableVector2d from "./../math/observable_vector2.js";
+ * @import {Vector2d} from "../math/vector2d.js";
+ * @import ResponseObject from "./response.js";
  **/
 /**
- * @classdesc
  * a Generic Physic Body Object with some physic properties and behavior functionality, to add as a member of a Renderable.
  * @see Renderable.body
  */
@@ -19,7 +17,7 @@ export default class Body {
      * @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?: object | Point | Rect | Polygon | Bounds | Point[] | Line | Ellipse | Polygon[] | Line[] | Ellipse[] | Rect[] | Bounds[] | undefined, onBodyUpdate?: Function | undefined);
+    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.
@@ -133,7 +131,7 @@ export default class Body {
     /**
      * The degree to which this body is affected by the world gravity
      * @public
-     * @see World.gravity
+     * @see {@link World.gravity}
      * @type {number}
      * @default 1.0
      */
@@ -141,7 +139,7 @@ export default class Body {
     /**
      * If true this body won't be affected by the world gravity
      * @public
-     * @see World.gravity
+     * @see {@link World.gravity}
      * @type {boolean}
      * @default false
      */
@@ -171,7 +169,7 @@ export default class Body {
      * static body do not move automatically and do not check againt collision with others
      * @param {boolean} [isStatic=true]
      */
-    setStatic(isStatic?: boolean | undefined): void;
+    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)
@@ -190,13 +188,13 @@ export default class Body {
      * @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 | undefined, clear?: boolean | undefined): void;
+    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 | undefined): void;
+    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)
@@ -210,13 +208,13 @@ export default class Body {
      * // or ...
      * this.body.fromJSON(me.loader.getJSON("shapesdef"), "banana");
      */
-    fromJSON(json: object, id?: string | undefined): number;
+    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 | undefined): Polygon | Line | Ellipse;
+    getShape(index?: number): Polygon | Line | Ellipse;
     /**
      * returns the AABB bounding box for this body
      * @returns {Bounds} bounding box Rectangle object
@@ -247,7 +245,7 @@ export default class Body {
      * // disable collision detection with all other objects
      * body.setCollisionMask(me.collision.types.NO_OBJECT);
      */
-    setCollisionMask(bitmask?: number | undefined): void;
+    setCollisionMask(bitmask?: number): void;
     /**
      * define the collision type of the body for collision filtering
      * @see collision.types
@@ -259,9 +257,10 @@ export default class Body {
     setCollisionType(type: number): void;
     /**
      * the built-in function to solve the collision response
-     * @param {object} response - the collision response object (see {@link ResponseObject})
+     * @param {ResponseObject} response - the collision response object
+     * @see {@link ResponseObject}
      */
-    respondToCollision(response: object): void;
+    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>
@@ -279,7 +278,7 @@ export default class Body {
      * mySprite.body.forEach((shape, index, array) => { ... });
      * mySprite.body.forEach((shape, index, array) => { ... }, thisArg);
      */
-    forEach(callback: Function, thisArg?: object | undefined, ...args: any[]): void;
+    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
@@ -299,10 +298,10 @@ export default class Body {
      * 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|ObservableVector2d} [v=Body.getBounds().center] - an optional point to rotate around
+     * @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 | ObservableVector2d | undefined): Body;
+    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
@@ -328,7 +327,7 @@ export default class Body {
      * @param {number} dt - time since the last update in milliseconds.
      * @returns {boolean} true if resulting velocity is different than 0
      */
-    protected update(dt: number): boolean;
+    protected update(): boolean;
     /**
      * Destroy function<br>
      * @ignore
@@ -340,11 +339,12 @@ 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.js";
-import Polygon from "./../geometries/poly.js";
-import type Line from "./../geometries/line.js";
-import Ellipse from "./../geometries/ellipse.js";
-import Point from "../geometries/point.js";
-import type Vector2d from "./../math/vector2.js";
-import Rect from "./../geometries/rectangle.js";
-import type ObservableVector2d from "./../math/observable_vector2.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

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