melonjs 14.4.0 → 14.5.0

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

@@ -0,0 +1,57 @@
+/**
+ * enable the nocache mechanism
+ * @ignore
+ */
+export function setNocache(enable?: boolean): void;
+/**
+ * change the default baseURL for the given asset type.<br>
+ * (this will prepend the asset URL and must finish with a '/')
+ * @name setBaseURL
+ * @memberof loader
+ * @public
+ * @param {string} type  - "*", "audio", binary", "image", "json", "js", "tmx", "tsx"
+ * @param {string} [url="./"] - default base URL
+ * @example
+ * // change the base URL relative address for audio assets
+ * me.loader.setBaseURL("audio", "data/audio/");
+ * // change the base URL absolute address for all object types
+ * me.loader.setBaseURL("*", "http://myurl.com/")
+ */
+export function setBaseURL(type: string, url?: string | undefined): void;
+export let nocache: string;
+export let baseURL: {};
+/**
+ * crossOrigin attribute to configure the CORS requests for Image data element.
+ * By default (that is, when the attribute is not specified), CORS is not used at all.
+ * The "anonymous" keyword means that there will be no exchange of user credentials via cookies,
+ * client-side SSL certificates or HTTP authentication as described in the Terminology section of the CORS specification.<br>
+ * @type {string}
+ * @name crossOrigin
+ * @default undefined
+ * @memberof loader
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_settings_attributes
+ * @example
+ *  // allow for cross-origin texture loading in WebGL
+ * me.loader.crossOrigin = "anonymous";
+ *
+ * // set all ressources to be loaded
+ * me.loader.preload(game.resources, this.loaded.bind(this));
+ */
+export let crossOrigin: string;
+/**
+ * indicates whether or not cross-site Access-Control requests should be made using credentials such as cookies,
+ * authorization headers or TLS client certificates. Setting withCredentials has no effect on same-site requests.
+ * @public
+ * @type {boolean}
+ * @name withCredentials
+ * @default false
+ * @memberof loader
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials
+ * @example
+ *  // enable withCredentials
+ * me.loader.withCredentials = true;
+ *
+ * // set all ressources to be loaded
+ * me.loader.preload(game.resources, this.loaded.bind(this));
+ */
+export let withCredentials: boolean;

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

@@ -168,18 +168,18 @@ export default class ParticleEmitter extends Container {
     isRunning(): boolean;
     /**
      * Launch particles from emitter constantly (e.g. for stream)
-     * @param {number} duration - [optional] time that the emitter releases particles in ms
+     * @param {number} [duration] - time that the emitter releases particles in ms
      */
-    streamParticles(duration: number): void;
+    streamParticles(duration?: number | undefined): void;
     /**
      * Stop the emitter from generating new particles (used only if emitter is Stream)
      */
     stopStream(): void;
     /**
      * Launch all particles from emitter and stop (e.g. for explosion)
-     * @param {number} total - [optional] number of particles to launch
+     * @param {number} [total] - number of particles to launch
      */
-    burstParticles(total: number): void;
+    burstParticles(total?: number | undefined): void;
     /**
      * @ignore
      */

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

@@ -4,9 +4,9 @@
  */
 export default class Bounds {
     /**
-     * @param {Vector2d[]} [vertices] - an array of me.Vector2d points
+     * @param {Vector2d[]|Point[]} [vertices] - an array of Vector2d or Point
      */
-    constructor(vertices?: Vector2d[] | undefined);
+    constructor(vertices?: Vector2d[] | Point[] | undefined);
     _center: Vector2d;
     /**
      * @ignore
@@ -22,147 +22,106 @@ export default class Bounds {
     } | 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);
+    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);
+    get x(): number;
+    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);
+    get y(): number;
+    set width(arg: number);
     /**
      * width of the bounds
-     * @public
      * @type {number}
-     * @name width
-     * @memberof Bounds
      */
-    public get width(): number;
-    public set height(arg: number);
+    get width(): number;
+    set height(arg: number);
     /**
      * width of the bounds
-     * @public
      * @type {number}
-     * @name width
-     * @memberof Bounds
      */
-    public get height(): number;
+    get height(): number;
     /**
      * left coordinate of the bound
-     * @public
      * @type {number}
-     * @name left
-     * @memberof Bounds
      */
-    public get left(): number;
+    get left(): number;
     /**
      * right coordinate of the bound
-     * @public
      * @type {number}
-     * @name right
-     * @memberof Bounds
      */
-    public get right(): number;
+    get right(): number;
     /**
      * top coordinate of the bound
-     * @public
      * @type {number}
-     * @name top
-     * @memberof Bounds
      */
-    public get top(): number;
+    get top(): number;
     /**
      * bottom coordinate of the bound
-     * @public
      * @type {number}
-     * @name bottom
-     * @memberof Bounds
      */
-    public get bottom(): number;
+    get bottom(): number;
     /**
      * center position of the bound on the x axis
-     * @public
      * @type {number}
-     * @name centerX
-     * @memberof Bounds
      */
-    public get centerX(): number;
+    get centerX(): number;
     /**
      * center position of the bound on the y axis
-     * @public
      * @type {number}
-     * @name centerY
-     * @memberof Bounds
      */
-    public get centerY(): number;
+    get centerY(): number;
     /**
      * return the center position of the bound
-     * @public
      * @type {Vector2d}
-     * @name center
-     * @memberof Bounds
      */
-    public get center(): Vector2d;
+    get center(): Vector2d;
+    /**
+     * center the bounds position around the given coordinates
+     * @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;
     /**
      * Updates bounds using the given vertices
-     * @name update
-     * @memberof Bounds
-     * @param {Vector2d[]} vertices - an array of me.Vector2d points
+     * @param {Vector2d[]|Point[]} vertices - an array of Vector2d or Point
      */
-    update(vertices: Vector2d[]): void;
+    update(vertices: Vector2d[] | Point[]): void;
     /**
      * add the given vertices to the bounds definition.
-     * @name add
-     * @memberof Bounds
-     * @param {Vector2d[]} vertices - an array of me.Vector2d points
+     * @param {Vector2d[]|Point[]} vertices - an array of Vector2d or Point
      * @param {boolean} [clear=false] - either to reset the bounds before adding the new vertices
      */
-    add(vertices: Vector2d[], clear?: boolean | undefined): void;
+    add(vertices: Vector2d[] | Point[], 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)
+     * @param {Vector2d|Point} point - the vector or point to be added to the bounds
+     * @param {Matrix2d} [m] - an optional transform to apply to the given point (if the given point is a Vector2d)
      */
     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
@@ -180,8 +139,6 @@ export default class Bounds {
      */
     /**
      * 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
@@ -189,16 +146,12 @@ export default class Bounds {
     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;
@@ -211,8 +164,6 @@ export default class Bounds {
      */
     /**
      * 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
      */
@@ -226,23 +177,17 @@ export default class Bounds {
      */
     /**
      * 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;

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

@@ -206,23 +206,12 @@ export default class Container extends Renderable {
      * @returns {Renderable[]} an array of renderable object
      */
     getChildren(): Renderable[];
-    /**
-     * update the bounding box for this shape.
-     * @ignore
-     * @returns {Bounds} this shape bounding box Rectangle object
-     */
-    updateBounds(forceUpdateChildBounds?: boolean): Bounds;
     /**
      * Checks if this container is root or if it's attached to the root container.
      * @private
      * @returns {boolean}
      */
     private isAttachedToRoot;
-    /**
-     * update the cointainer's bounding rect (private)
-     * @ignore
-     */
-    updateBoundsPos(newX: any, newY: any): Bounds;
     /**
      * @ignore
      */

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

@@ -5,16 +5,28 @@
  */
 export default class Renderable extends Rect {
     /**
-     * to identify the object as a renderable object
-     * @ignore
+     * Position of the Renderable relative to its parent container
+     * @public
+     * @type {ObservableVector3d}
      */
-    isRenderable: boolean;
+    public pos: ObservableVector3d;
     /**
-     * If true then physic collision and input events will not impact this renderable
-     * @type {boolean}
-     * @default true
+     * The anchor point is used for attachment behavior, and/or when applying transformations.<br>
+     * The coordinate system places the origin at the top left corner of the frame (0, 0) and (1, 1) means the bottom-right corner<br>
+     * <img src="images/anchor_point.png"/><br>
+     * a Renderable's anchor point defaults to (0.5,0.5), which corresponds to the center position.<br>
+     * <br>
+     * <i><b>Note:</b> Object created through Tiled will have their anchorPoint set to (0, 0) to match Tiled Level editor implementation.
+     * To specify a value through Tiled, use a json expression like `json:{"x":0.5,"y":0.5}`. </i>
+     * @type {ObservableVector2d}
+     * @default <0.5,0.5>
      */
-    isKinematic: boolean;
+    anchorPoint: ObservableVector2d;
+    /**
+     * the renderable default transformation matrix
+     * @type {Matrix2d}
+     */
+    currentTransform: Matrix2d;
     /**
      * the renderable physic body
      * @type {Body}
@@ -51,11 +63,6 @@ export default class Renderable extends Rect {
      * }
      */
     body: Body;
-    /**
-     * the renderable default transformation matrix
-     * @type {Matrix2d}
-     */
-    currentTransform: Matrix2d;
     /**
      * (G)ame (U)nique (Id)entifier" <br>
      * a GUID will be allocated for any renderable object added <br>
@@ -100,18 +107,6 @@ export default class Renderable extends Rect {
      * @default false
      */
     floating: boolean;
-    /**
-     * The anchor point is used for attachment behavior, and/or when applying transformations.<br>
-     * The coordinate system places the origin at the top left corner of the frame (0, 0) and (1, 1) means the bottom-right corner<br>
-     * <img src="images/anchor_point.png"/><br>
-     * a Renderable's anchor point defaults to (0.5,0.5), which corresponds to the center position.<br>
-     * <br>
-     * <i><b>Note:</b> Object created through Tiled will have their anchorPoint set to (0, 0) to match Tiled Level editor implementation.
-     * To specify a value through Tiled, use a json expression like `json:{"x":0.5,"y":0.5}`. </i>
-     * @type {ObservableVector2d}
-     * @default <0.5,0.5>
-     */
-    anchorPoint: ObservableVector2d;
     /**
      * When enabled, an object container will automatically apply
      * any defined transformation before calling the child draw method.
@@ -182,15 +177,20 @@ export default class Renderable extends Rect {
      */
     name: string;
     /**
-     * Position of the Renderable relative to its parent container
-     * @public
-     * @type {ObservableVector3d}
+     * to identify the object as a renderable object
+     * @ignore
      */
-    public pos: ObservableVector3d;
+    isRenderable: boolean;
+    /**
+     * If true then physic collision and input events will not impact this renderable
+     * @type {boolean}
+     * @default true
+     */
+    isKinematic: boolean;
     /**
      * when true the renderable will be redrawn during the next update cycle
      * @type {boolean}
-     * @default false
+     * @default true
      */
     isDirty: boolean;
     _flip: {
@@ -317,11 +317,17 @@ export default class Renderable extends Rect {
      * @returns {boolean} true if the renderable is dirty
      */
     update(dt: number): boolean;
+    /**
+     * update the bounding box for this shape.
+     * @param {boolean} [absolute=true] - update the bounds size and position in (world) absolute coordinates
+     * @returns {Bounds} this shape bounding box Rectangle object
+     */
+    updateBounds(absolute?: boolean | undefined): Bounds;
     /**
      * update the renderable's bounding rect (private)
      * @ignore
      */
-    updateBoundsPos(newX: any, newY: any): void;
+    updateBoundsPos(newX?: number, newY?: number): void;
     /**
      * return the renderable absolute position in the game world
      * @returns {Vector2d}
@@ -397,6 +403,6 @@ export default class Renderable extends Rect {
     onDestroyEvent(): void;
 }
 import Rect from "./../geometries/rectangle.js";
-import ObservableVector2d from "./../math/observable_vector2.js";
 import ObservableVector3d from "./../math/observable_vector3.js";
+import ObservableVector2d from "./../math/observable_vector2.js";
 import Color from "./../math/color.js";

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

@@ -83,7 +83,7 @@ export default class Sprite extends Renderable {
     anim: {};
     resetAnim: Function | (() => Sprite) | undefined;
     current: {
-        name: string;
+        name: undefined;
         length: number;
         offset: object;
         width: number;
@@ -234,13 +234,13 @@ export default class Sprite extends Renderable {
      * force the current animation frame index.
      * @name setAnimationFrame
      * @memberof Sprite
-     * @param {number} [idx=0] - animation frame index
+     * @param {number} [index=0] - animation frame index
      * @returns {Sprite} Reference to this object for method chaining
      * @example
      * // reset the current animation to the first frame
      * this.setAnimationFrame();
      */
-    setAnimationFrame(idx?: number | undefined): Sprite;
+    setAnimationFrame(index?: number | undefined): Sprite;
     /**
      * return the current animation frame index.
      * @name getCurrentAnimationFrame

package/dist/types/state/state.d.ts

@@ -135,7 +135,7 @@ declare namespace state {
      */
     function transition(effect: string, color: any, duration?: number | undefined): void;
     /**
-     * enable/disable transition for a specific state (by default enabled for all)
+     * enable/disable the transition to a particular state (by default enabled for all)
      * @name setTransition
      * @memberof state
      * @public

package/dist/types/system/pooling.d.ts

@@ -26,14 +26,14 @@ declare class ObjectPool {
      * @param {boolean} [recycling=false] - enables object recycling for the specified class
      * @example
      * // implement CherryEntity
-     * class CherryEntity extends Spritesheet {
+     * class Cherry extends Sprite {
      *    onResetEvent() {
      *        // reset object mutable properties
      *        this.lifeBar = 100;
      *    }
      * };
      * // add our users defined entities in the object pool and enable object recycling
-     * me.pool.register("cherryentity", CherryEntity, true);
+     * me.pool.register("cherrysprite", Cherry, true);
      */
     register(className: string, classObj: object, recycling?: boolean | undefined): void;
     /**

package/dist/types/video/renderer.d.ts

@@ -188,7 +188,7 @@ export default class Renderer {
      * @param {Rect|RoundRect|Polygon|Line|Ellipse} [mask] - the shape defining the mask to be applied
      * @param {boolean} [invert=false] - either the given shape should define what is visible (default) or the opposite
      */
-    setMask(mask?: Rect | Polygon | Ellipse | RoundRect | Line | undefined): void;
+    setMask(mask?: Polygon | Rect | Ellipse | RoundRect | Line | undefined): void;
     /**
      * disable (remove) the rendering mask set through setMask.
      * @see Renderer#setMask

package/dist/types/video/webgl/compositors/compositor.d.ts

@@ -0,0 +1,101 @@
+/**
+ * @classdesc
+ * A base Compositor object.
+ */
+export default class Compositor {
+    /**
+     * @param {WebGLRenderer} renderer - the current WebGL renderer session
+     */
+    constructor(renderer: WebGLRenderer);
+    /**
+     * Initialize the compositor
+     * @ignore
+     */
+    init(renderer: any): void;
+    renderer: any;
+    gl: any;
+    color: any;
+    viewMatrix: any;
+    /**
+     * a reference to the active WebGL shader
+     * @type {GLShader}
+     */
+    activeShader: any;
+    /**
+     * primitive type to render (gl.POINTS, gl.LINE_STRIP, gl.LINE_LOOP, gl.LINES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN, gl.TRIANGLES)
+     * @type {number}
+     * @default gl.TRIANGLES
+     */
+    mode: number | undefined;
+    /**
+     * an array of vertex attribute properties
+     * @see WebGLCompositor.addAttribute
+     * @type {Array}
+     */
+    attributes: any[] | undefined;
+    /**
+     * the size of a single vertex in bytes
+     * (will automatically be calculated as attributes definitions are added)
+     * @see WebGLCompositor.addAttribute
+     * @type {number}
+     */
+    vertexByteSize: number | undefined;
+    /**
+     * the size of a single vertex in floats
+     * (will automatically be calculated as attributes definitions are added)
+     * @see WebGLCompositor.addAttribute
+     * @type {number}
+     */
+    vertexSize: number | undefined;
+    /**
+     * Reset compositor internal state
+     * @ignore
+     */
+    reset(): void;
+    /**
+     * add vertex attribute property definition to the compositor
+     * @param {string} name - name of the attribute in the vertex shader
+     * @param {number} size - number of components per vertex attribute. Must be 1, 2, 3, or 4.
+     * @param {GLenum} type - data type of each component in the array
+     * @param {boolean} normalized - whether integer data values should be normalized into a certain range when being cast to a float
+     * @param {number} offset - offset in bytes of the first component in the vertex attribute array
+     */
+    addAttribute(name: string, size: number, type: GLenum, normalized: boolean, offset: number): void;
+    /**
+     * Sets the viewport
+     * @param {number} x - x position of viewport
+     * @param {number} y - y position of viewport
+     * @param {number} w - width of viewport
+     * @param {number} h - height of viewport
+     */
+    setViewport(x: number, y: number, w: number, h: number): void;
+    /**
+     * set/change the current projection matrix
+     * @param {Matrix3d} matrix
+     */
+    setProjection(matrix: Matrix3d): void;
+    /**
+     * Select the shader to use for compositing
+     * @see GLShader
+     * @param {GLShader} shader - a reference to a GLShader instance
+     */
+    useShader(shader: GLShader): void;
+    /**
+     * Flush batched texture operations to the GPU
+     * @param {number} [mode=gl.TRIANGLES] - the GL drawing mode
+     */
+    flush(mode?: number | undefined): void;
+    /**
+     * Clear the frame buffer
+     * @param {number} [alpha = 0.0] - the alpha value used when clearing the framebuffer
+     */
+    clear(alpha?: number | undefined): void;
+    /**
+     * Specify the color values used when clearing color buffers. The values are clamped between 0 and 1.
+     * @param {number} [r = 0] - the red color value used when the color buffers are cleared
+     * @param {number} [g = 0] - the green color value used when the color buffers are cleared
+     * @param {number} [b = 0] - the blue color value used when the color buffers are cleared
+     * @param {number} [a = 0] - the alpha color value used when the color buffers are cleared
+     */
+    clearColor(r?: number | undefined, g?: number | undefined, b?: number | undefined, a?: number | undefined): void;
+}