melonjs 14.2.0 → 14.4.0

package/dist/types/level/tiled/renderer/TMXRenderer.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @classdesc
+ * The map renderer base class
+ */
+export default class TMXRenderer {
+    /**
+     * @param {number} cols - width of the tilemap in tiles
+     * @param {number} rows - height of the tilemap in tiles
+     * @param {number} tilewidth - width of each tile in pixels
+     * @param {number} tileheight - height of each tile in pixels
+     */
+    constructor(cols: number, rows: number, tilewidth: number, tileheight: number);
+    cols: number;
+    rows: number;
+    tilewidth: number;
+    tileheight: number;
+    bounds: Bounds;
+    /**
+     * return true if the renderer can render the specified map or layer
+     * @param {TMXTileMap|TMXLayer} component - TMX Map or Layer
+     * @returns {boolean}
+     */
+    canRender(component: TMXTileMap | TMXLayer): boolean;
+    /**
+     * return the bounding rect for this map renderer
+     * @param {TMXLayer} [layer] - calculate the bounding rect for a specific layer (will return a new bounds object)
+     * @returns {Bounds}
+     */
+    getBounds(layer?: TMXLayer | undefined): Bounds;
+    /**
+     * return the tile position corresponding to the specified pixel
+     * @param {number} x - X coordinate
+     * @param {number} y - Y coordinate
+     * @param {Vector2d} [v] - an optional vector object where to put the return values
+     * @returns {Vector2d}
+     */
+    pixelToTileCoords(x: number, y: number, v?: any): Vector2d;
+    /**
+     * return the pixel position corresponding of the specified tile
+     * @param {number} col - tile horizontal position
+     * @param {number} row - tile vertical position
+     * @param {Vector2d} [v] - an optional vector object where to put the return values
+     * @returns {Vector2d}
+     */
+    tileToPixelCoords(col: number, row: number, v?: any): Vector2d;
+    /**
+     * draw the given tile at the specified layer
+     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
+     * @param {number} x - X coordinate where to draw the tile
+     * @param {number} y - Y coordinate where to draw the tile
+     * @param {Tile} tile - the tile object to draw
+     */
+    drawTile(renderer: CanvasRenderer | WebGLRenderer, x: number, y: number, tile: Tile): void;
+    /**
+     * draw the given TMX Layer for the given area
+     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
+     * @param {TMXLayer} layer - a TMX Layer object
+     * @param {Rect} rect - the area of the layer to draw
+     */
+    drawTileLayer(renderer: CanvasRenderer | WebGLRenderer, layer: TMXLayer, rect: Rect): void;
+}
+import Bounds from "./../../../physics/bounds.js";
+import TMXLayer from "./../TMXLayer.js";

package/dist/types/level/tiled/renderer/TMXStaggeredRenderer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @classdesc
+ * a Staggered Map Renderder
+ * @augments TMXHexagonalRenderer
+ */
+export default class TMXStaggeredRenderer extends TMXHexagonalRenderer {
+}
+import TMXHexagonalRenderer from "./TMXHexagonalRenderer.js";

package/dist/types/level/tiled/renderer/autodetect.d.ts

@@ -0,0 +1,9 @@
+/**
+ * return a compatible renderer object for the given map
+ * @param {TMXTileMap} map
+ * @ignore
+ */
+export function getNewTMXRenderer(map: TMXTileMap): TMXOrthogonalRenderer | TMXIsometricRenderer | TMXHexagonalRenderer;
+import TMXOrthogonalRenderer from "./TMXOrthogonalRenderer.js";
+import TMXIsometricRenderer from "./TMXIsometricRenderer.js";
+import TMXHexagonalRenderer from "./TMXHexagonalRenderer.js";

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

@@ -0,0 +1,181 @@
+export default loader;
+declare namespace loader {
+    const nocache: string;
+    const onload: undefined;
+    const onProgress: undefined;
+    const crossOrigin: string;
+    const withCredentials: boolean;
+    /**
+     * just increment the number of already loaded resources
+     * @ignore
+     */
+    function onResourceLoaded(res: any): void;
+    /**
+     * on error callback for image loading
+     * @ignore
+     */
+    function onLoadingError(res: any): never;
+    /**
+     * enable the nocache mechanism
+     * @ignore
+     */
+    function setNocache(enable: any): 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/")
+     */
+    function setBaseURL(type: string, url?: string | undefined): void;
+    /**
+     * set all the specified game resources to be preloaded.
+     * @name preload
+     * @memberof loader
+     * @public
+     * @param {object[]} res
+     * @param {string} res.name - internal name of the resource
+     * @param {string} res.type  - "audio", binary", "image", "json","js", "tmx", "tsx", "fontface"
+     * @param {string} res.src  - path and/or file name of the resource (for audio assets only the path is required)
+     * @param {boolean} [res.stream] - Set to true to force HTML5 Audio, which allows not to wait for large file to be downloaded before playing.
+     * @param {Function} [onload=loader.onload] - function to be called when all resources are loaded
+     * @param {boolean} [switchToLoadState=true] - automatically switch to the loading screen
+     * @example
+     * game_resources = [
+     *   // PNG tileset
+     *   {name: "tileset-platformer", type: "image",  src: "data/map/tileset.png"},
+     *   // PNG packed texture
+     *   {name: "texture", type:"image", src: "data/gfx/texture.png"}
+     *   // PNG base64 encoded image
+     *   {name: "texture", type:"image", src: "data:image/png;base64,iVBORw0KAAAQAAAAEACA..."}
+     *   // TSX file
+     *   {name: "meta_tiles", type: "tsx", src: "data/map/meta_tiles.tsx"},
+     *   // TMX level (XML & JSON)
+     *   {name: "map1", type: "tmx", src: "data/map/map1.json"},
+     *   {name: "map2", type: "tmx", src: "data/map/map2.tmx"},
+     *   {name: "map3", type: "tmx", format: "json", data: {"height":15,"layers":[...],"tilewidth":32,"version":1,"width":20}},
+     *   {name: "map4", type: "tmx", format: "xml", data: {xml representation of tmx}},
+     *   // audio resources
+     *   {name: "bgmusic", type: "audio",  src: "data/audio/"},
+     *   {name: "cling",   type: "audio",  src: "data/audio/"},
+     *   // base64 encoded audio resources
+     *   {name: "band",   type: "audio",  src: "data:audio/wav;base64,..."},
+     *   // binary file
+     *   {name: "ymTrack", type: "binary", src: "data/audio/main.ym"},
+     *   // JSON file (used for texturePacker)
+     *   {name: "texture", type: "json", src: "data/gfx/texture.json"},
+     *   // JavaScript file
+     *   {name: "plugin", type: "js", src: "data/js/plugin.js"},
+     *   // Font Face
+     *   { name: "'kenpixel'", type: "fontface",  src: "url('data/font/kenvector_future.woff2')" }
+     * ];
+     * ...
+     * // set all resources to be loaded
+     * me.loader.preload(game.resources, this.loaded.bind(this));
+     */
+    function preload(res: {
+        name: string;
+        type: string;
+        src: string;
+        stream?: boolean | undefined;
+    }[], onload?: Function | undefined, switchToLoadState?: boolean | undefined): void;
+    /**
+     * Load a single resource (to be used if you need to load additional resource during the game)
+     * @name load
+     * @memberof loader
+     * @public
+     * @param {object} res
+     * @param {string} res.name - internal name of the resource
+     * @param {string} res.type  - "audio", binary", "image", "json", "tmx", "tsx"
+     * @param {string} res.src  - path and/or file name of the resource (for audio assets only the path is required)
+     * @param {boolean} [res.stream] - Set to true to force HTML5 Audio, which allows not to wait for large file to be downloaded before playing.
+     * @param {Function} [onload] - function to be called when the resource is loaded
+     * @param {Function} [onerror] - function to be called in case of error
+     * @returns {number} the amount of corresponding resource to be preloaded
+     * @example
+     * // load an image asset
+     * me.loader.load({name: "avatar",  type:"image",  src: "data/avatar.png"}, this.onload.bind(this), this.onerror.bind(this));
+     * // load a base64 image asset
+     *  me.loader.load({name: "avatar", type:"image", src: "data:image/png;base64,iVBORw0KAAAQAAAAEACA..."};
+     * // start loading music
+     * me.loader.load({
+     *     name   : "bgmusic",
+     *     type   : "audio",
+     *     src    : "data/audio/"
+     * }, function () {
+     *     me.audio.play("bgmusic");
+     * });
+     */
+    function load(res: {
+        name: string;
+        type: string;
+        src: string;
+        stream?: boolean | undefined;
+    }, onload?: Function | undefined, onerror?: Function | undefined): number;
+    /**
+     * unload specified resource to free memory
+     * @name unload
+     * @memberof loader
+     * @public
+     * @param {object} res
+     * @param {string} res.name - internal name of the resource
+     * @param {string} res.type  - "audio", binary", "image", "json", "tmx", "tsx"
+     * @returns {boolean} true if unloaded
+     * @example me.loader.unload({name: "avatar",  type:"image"});
+     */
+    function unload(res: {
+        name: string;
+        type: string;
+    }): boolean;
+    /**
+     * unload all resources to free memory
+     * @name unloadAll
+     * @memberof loader
+     * @public
+     * @example me.loader.unloadAll();
+     */
+    function unloadAll(): void;
+    /**
+     * return the specified TMX/TSX object
+     * @name getTMX
+     * @memberof loader
+     * @public
+     * @param {string} elt - name of the tmx/tsx element ("map1");
+     * @returns {object} requested element or null if not found
+     */
+    function getTMX(elt: string): object;
+    /**
+     * return the specified Binary object
+     * @name getBinary
+     * @memberof loader
+     * @public
+     * @param {string} elt - name of the binary object ("ymTrack");
+     * @returns {object} requested element or null if not found
+     */
+    function getBinary(elt: string): object;
+    /**
+     * return the specified Image Object
+     * @name getImage
+     * @memberof loader
+     * @public
+     * @param {string} image - name of the Image element ("tileset-platformer");
+     * @returns {HTMLImageElement} requested element or null if not found
+     */
+    function getImage(image: string): HTMLImageElement;
+    /**
+     * return the specified JSON Object
+     * @name getJSON
+     * @memberof loader
+     * @public
+     * @param {string} elt - name of the json file to load
+     * @returns {object}
+     */
+    function getJSON(elt: string): object;
+}

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

@@ -0,0 +1,18 @@
+export default DefaultLoadingScreen;
+/**
+ * a default loading screen
+ * @ignore
+ */
+declare class DefaultLoadingScreen extends Stage {
+    /**
+     * call when the loader is resetted
+     * @ignore
+     */
+    onResetEvent(): void;
+    /**
+     * Called by engine before deleting the object
+     * @ignore
+     */
+    onDestroyEvent(): void;
+}
+import Stage from "./../state/stage.js";

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

@@ -0,0 +1,170 @@
+/**
+ * @classdesc
+ * A color manipulation object.
+ */
+export default class Color {
+    /**
+     * @param {number} [r=0] - red component or array of color components
+     * @param {number} [g=0] - green component
+     * @param {number} [b=0] - blue component
+     * @param {number} [alpha=1.0] - alpha value
+     */
+    constructor(r?: number | undefined, g?: number | undefined, b?: number | undefined, alpha?: number | undefined);
+    /**
+     * @ignore
+     */
+    onResetEvent(r?: number, g?: number, b?: number, alpha?: number): Color;
+    glArray: Float32Array | undefined;
+    set r(arg: number);
+    /**
+     * Color Red Component [0 .. 255]
+     * @type {number}
+     */
+    get r(): number;
+    set g(arg: number);
+    /**
+     * Color Green Component [0 .. 255]
+     * @type {number}
+     */
+    get g(): number;
+    set b(arg: number);
+    /**
+     * Color Blue Component [0 .. 255]
+     * @type {number}
+     */
+    get b(): number;
+    set alpha(arg: number);
+    /**
+     * Color Alpha Component [0.0 .. 1.0]
+     * @type {number}
+     */
+    get alpha(): number;
+    /**
+     * Set this color to the specified value.
+     * @param {number} r - red component [0 .. 255]
+     * @param {number} g - green component [0 .. 255]
+     * @param {number} b - blue component [0 .. 255]
+     * @param {number} [alpha=1.0] - alpha value [0.0 .. 1.0]
+     * @returns {Color} Reference to this object for method chaining
+     */
+    setColor(r: number, g: number, b: number, alpha?: number | undefined): Color;
+    /**
+     * set this color to the specified HSV value
+     * @param {number} h - hue (a value from 0 to 1)
+     * @param {number} s - saturation (a value from 0 to 1)
+     * @param {number} v - value (a value from 0 to 1)
+     * @returns {Color} Reference to this object for method chaining
+     */
+    setHSV(h: number, s: number, v: number): Color;
+    /**
+     * set this color to the specified HSL value
+     * @param {number} h - hue (a value from 0 to 1)
+     * @param {number} s - saturation (a value from 0 to 1)
+     * @param {number} l - lightness (a value from 0 to 1)
+     * @returns {Color} Reference to this object for method chaining
+     */
+    setHSL(h: number, s: number, l: number): Color;
+    /**
+     * Create a new copy of this color object.
+     * @returns {Color} Reference to the newly cloned object
+     */
+    clone(): Color;
+    /**
+     * Copy a color object or CSS color into this one.
+     * @param {Color|string} color
+     * @returns {Color} Reference to this object for method chaining
+     */
+    copy(color: Color | string): Color;
+    /**
+     * Blend this color with the given one using addition.
+     * @param {Color} color
+     * @returns {Color} Reference to this object for method chaining
+     */
+    add(color: Color): Color;
+    /**
+     * Darken this color value by 0..1
+     * @param {number} scale
+     * @returns {Color} Reference to this object for method chaining
+     */
+    darken(scale: number): Color;
+    /**
+     * Linearly interpolate between this color and the given one.
+     * @param {Color} color
+     * @param {number} alpha - with alpha = 0 being this color, and alpha = 1 being the given one.
+     * @returns {Color} Reference to this object for method chaining
+     */
+    lerp(color: Color, alpha: number): Color;
+    /**
+     * Lighten this color value by 0..1
+     * @param {number} scale
+     * @returns {Color} Reference to this object for method chaining
+     */
+    lighten(scale: number): Color;
+    /**
+     * Generate random r,g,b values for this color object
+     * @param {number} [min=0] - minimum value for the random range
+     * @param {number} [max=255] - maxmium value for the random range
+     * @returns {Color} Reference to this object for method chaining
+     */
+    random(min?: number | undefined, max?: number | undefined): Color;
+    /**
+     * Return true if the r,g,b,a values of this color are equal with the
+     * given one.
+     * @param {Color} color
+     * @returns {boolean}
+     */
+    equals(color: Color): boolean;
+    /**
+     * Parse a CSS color string and set this color to the corresponding
+     * r,g,b values
+     * @param {string} cssColor
+     * @returns {Color} Reference to this object for method chaining
+     */
+    parseCSS(cssColor: string): Color;
+    /**
+     * Parse an RGB or RGBA CSS color string
+     * @param {string} rgbColor
+     * @returns {Color} Reference to this object for method chaining
+     */
+    parseRGB(rgbColor: string): Color;
+    /**
+     * Parse a Hex color ("#RGB", "#RGBA" or "#RRGGBB", "#RRGGBBAA" format) and set this color to
+     * the corresponding r,g,b,a values
+     * @param {string} hexColor
+     * @param {boolean} [argb = false] - true if format is #ARGB, or #AARRGGBB (as opposed to #RGBA or #RGGBBAA)
+     * @returns {Color} Reference to this object for method chaining
+     */
+    parseHex(hexColor: string, argb?: boolean | undefined): Color;
+    /**
+     * Pack this color into a Uint32 ARGB representation
+     * @param {number} [alpha=1.0] - alpha value [0.0 .. 1.0]
+     * @returns {number}
+     */
+    toUint32(alpha?: number | undefined): number;
+    /**
+     * return an array representation of this object
+     * @returns {Float32Array}
+     */
+    toArray(): Float32Array;
+    /**
+     * return the color in "#RRGGBB" format
+     * @returns {string}
+     */
+    toHex(): string;
+    /**
+     * Get the color in "#RRGGBBAA" format
+     * @returns {string}
+     */
+    toHex8(alpha?: number): string;
+    /**
+     * Get the color in "rgb(R,G,B)" format
+     * @returns {string}
+     */
+    toRGB(): string;
+    /**
+     * Get the color in "rgba(R,G,B,A)" format
+     * @param {number} [alpha=1.0] - alpha value [0.0 .. 1.0]
+     * @returns {string}
+     */
+    toRGBA(alpha?: number | undefined): string;
+}

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

@@ -0,0 +1,165 @@
+/**
+ * returns true if the given value is a power of two
+ * @public
+ * @memberof Math
+ * @name isPowerOfTwo
+ * @param {number} val
+ * @returns {boolean}
+ */
+export function isPowerOfTwo(val: number): boolean;
+/**
+ * returns the next power of two for the given value
+ * @public
+ * @memberof Math
+ * @name nextPowerOfTwo
+ * @param {number} val
+ * @returns {boolean}
+ */
+export function nextPowerOfTwo(val: number): boolean;
+/**
+ * Converts an angle in degrees to an angle in radians
+ * @public
+ * @memberof Math
+ * @name degToRad
+ * @param {number} angle - angle in degrees
+ * @returns {number} corresponding angle in radians
+ * @example
+ * // convert a specific angle
+ * me.Math.degToRad(60); // return 1.0471...
+ */
+export function degToRad(angle: number): number;
+/**
+ * Converts an angle in radians to an angle in degrees.
+ * @public
+ * @memberof Math
+ * @name radToDeg
+ * @param {number} radians - angle in radians
+ * @returns {number} corresponding angle in degrees
+ * @example
+ * // convert a specific angle
+ * me.Math.radToDeg(1.0471975511965976); // return 60
+ */
+export function radToDeg(radians: number): number;
+/**
+ * clamp the given value
+ * @public
+ * @memberof Math
+ * @name clamp
+ * @param {number} val - the value to clamp
+ * @param {number} low - lower limit
+ * @param {number} high - higher limit
+ * @returns {number} clamped value
+ */
+export function clamp(val: number, low: number, high: number): number;
+/**
+ * return a random integer between min (included) and max (excluded)
+ * @public
+ * @memberof Math
+ * @name random
+ * @param {number} min - minimum value.
+ * @param {number} max - maximum value.
+ * @returns {number} random value
+ * @example
+ * // Print a random number; one of 5, 6, 7, 8, 9
+ * console.log(me.Math.random(5, 10) );
+ */
+export function random(min: number, max: number): number;
+/**
+ * return a random float between min, max (exclusive)
+ * @public
+ * @memberof Math
+ * @name randomFloat
+ * @param {number} min - minimum value.
+ * @param {number} max - maximum value.
+ * @returns {number} random value
+ * @example
+ * // Print a random number; one of 5, 6, 7, 8, 9
+ * console.log(me.Math.randomFloat(5, 10) );
+ */
+export function randomFloat(min: number, max: number): number;
+/**
+ * return a weighted random between min, max (exclusive)
+ * @public
+ * @memberof Math
+ * @name weightedRandom
+ * @param {number} min - minimum value.
+ * @param {number} max - maximum value.
+ * @returns {number} random value
+ * @example
+ * // Print a random number; one of 5, 6, 7, 8, 9
+ * console.log(me.Math.weightedRandom(5, 10) );
+ */
+export function weightedRandom(min: number, max: number): number;
+/**
+ * round a value to the specified number of digit
+ * @public
+ * @memberof Math
+ * @name round
+ * @param {number} num - value to be rounded.
+ * @param {number} [dec=0] - number of decimal digit to be rounded to.
+ * @returns {number} rounded value
+ * @example
+ * // round a specific value to 2 digits
+ * me.Math.round(10.33333, 2); // return 10.33
+ */
+export function round(num: number, dec?: number | undefined): number;
+/**
+ * check if the given value is close to the expected one
+ * @public
+ * @memberof Math
+ * @name toBeCloseTo
+ * @param {number} expected - value to be compared with.
+ * @param {number} actual - actual value to compare
+ * @param {number} [precision=2] - float precision for the comparison
+ * @returns {boolean} if close to
+ * @example
+ * // test if the given value is close to 10
+ * if (me.Math.toBeCloseTo(10, value)) {
+ *     // do something
+ * }
+ */
+export function toBeCloseTo(expected: number, actual: number, precision?: number | undefined): boolean;
+/**
+ * a collection of math utility functions
+ * @namespace Math
+ */
+/**
+ * constant to convert from degrees to radians
+ * @public
+ * @type {number}
+ * @name DEG_TO_RAD
+ * @memberof Math
+ */
+export const DEG_TO_RAD: number;
+/**
+ * constant to convert from radians to degrees
+ * @public
+ * @type {number}
+ * @name RAD_TO_DEG
+ * @memberof Math
+ */
+export const RAD_TO_DEG: number;
+/**
+ * constant equals to 2 times pi
+ * @public
+ * @type {number}
+ * @name TAU
+ * @memberof Math
+ */
+export const TAU: number;
+/**
+ * constant equals to half pi
+ * @public
+ * @type {number}
+ * @name ETA
+ * @memberof Math
+ */
+export const ETA: number;
+/**
+ * the difference between 1 and the smallest floating point number greater than 1
+ * @public
+ * @type {number}
+ * @name EPSILON
+ * @memberof Math
+ */
+export const EPSILON: number;