melonjs 14.1.2 → 14.3.0

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

@@ -0,0 +1,126 @@
+export default timer;
+declare const timer: Timer;
+/**
+ * @classdesc
+ * a Timer class to manage timing related function (FPS, Game Tick, Time...)
+ * @see {@link timer} the default global timer instance
+ */
+declare class Timer {
+    /**
+     * Last game tick value. <br>
+     * Use this value to scale velocities during frame drops due to slow hardware or when setting an FPS limit.
+     * This feature is disabled by default (Enable interpolation to use it).
+     * @public
+     * @see interpolation
+     * @See maxfps
+     * @type {number}
+     * @name tick
+     */
+    public tick: number;
+    /**
+     * Last measured fps rate.<br>
+     * This feature is disabled by default, unless the debugPanel is enabled/visible.
+     * @public
+     * @type {number}
+     * @name fps
+     */
+    public fps: number;
+    /**
+     * Set the maximum target display frame per second
+     * @public
+     * @see tick
+     * @type {number}
+     * @default 60
+     */
+    public maxfps: number;
+    /**
+     * Enable/disable frame interpolation
+     * @see tick
+     * @type {boolean}
+     * @default false
+     */
+    interpolation: boolean;
+    framecount: number;
+    framedelta: number;
+    last: number;
+    now: number;
+    delta: number;
+    step: number;
+    minstep: number;
+    timers: any[];
+    timerId: number;
+    /**
+     * reset time (e.g. usefull in case of pause)
+     * @ignore
+     */
+    reset(): void;
+    /**
+     * Calls a function once after a specified delay. See me.timer.setInterval to repeativly call a function.
+     * @param {Function} fn - the function you want to execute after delay milliseconds.
+     * @param {number} delay - the number of milliseconds (thousandths of a second) that the function call should be delayed by.
+     * @param {boolean} [pauseable=true] - respects the pause state of the engine.
+     * @param {...*} args - optional parameters which are passed through to the function specified by fn once the timer expires.
+     * @returns {number} The numerical ID of the timer, which can be used later with me.timer.clearTimeout().
+     * @example
+     * // set a timer to call "myFunction" after 1000ms
+     * me.timer.setTimeout(myFunction, 1000);
+     * // set a timer to call "myFunction" after 1000ms (respecting the pause state) and passing param1 and param2
+     * me.timer.setTimeout(myFunction, 1000, true, param1, param2);
+     */
+    setTimeout(fn: Function, delay: number, pauseable?: boolean | undefined, ...args: any[]): number;
+    /**
+     * Calls a function continously at the specified interval.  See setTimeout to call function a single time.
+     * @param {Function} fn - the function to execute
+     * @param {number} delay - the number of milliseconds (thousandths of a second) on how often to execute the function
+     * @param {boolean} [pauseable=true] - respects the pause state of the engine.
+     * @param {...*} args - optional parameters which are passed through to the function specified by fn once the timer expires.
+     * @returns {number} The numerical ID of the timer, which can be used later with me.timer.clearInterval().
+     * @example
+     * // set a timer to call "myFunction" every 1000ms
+     * me.timer.setInterval(myFunction, 1000);
+     * // set a timer to call "myFunction" every 1000ms (respecting the pause state) and passing param1 and param2
+     * me.timer.setInterval(myFunction, 1000, true, param1, param2);
+     */
+    setInterval(fn: Function, delay: number, pauseable?: boolean | undefined, ...args: any[]): number;
+    /**
+     * Clears the delay set by me.timer.setTimeout().
+     * @param {number} timeoutID - ID of the timeout to be cleared
+     */
+    clearTimeout(timeoutID: number): void;
+    /**
+     * Clears the Interval set by me.timer.setInterval().
+     * @param {number} intervalID - ID of the interval to be cleared
+     */
+    clearInterval(intervalID: number): void;
+    /**
+     * Return the current timestamp in milliseconds <br>
+     * since the game has started or since linux epoch (based on browser support for High Resolution Timer)
+     * @returns {number}
+     */
+    getTime(): number;
+    /**
+     * Return elapsed time in milliseconds since the last update
+     * @returns {number}
+     */
+    getDelta(): number;
+    /**
+     * compute the actual frame time and fps rate
+     * @ignore
+     */
+    countFPS(): void;
+    /**
+     * update
+     * @ignore
+     */
+    update(time: any): void;
+    /**
+     * clear Timers
+     * @ignore
+     */
+    clearTimer(timerId: any): void;
+    /**
+     * update timers
+     * @ignore
+     */
+    updateTimers(): void;
+}

package/dist/types/text/bitmaptext.d.ts

@@ -0,0 +1,151 @@
+/**
+ * @classdesc
+ * a bitmap font object
+ * @augments Renderable
+ */
+export default class BitmapText extends Renderable {
+    /**
+     * @param {number} x - position of the text object
+     * @param {number} y - position of the text object
+     * @param {object} settings - the text configuration
+     * @param {string|Image} settings.font - a font name to identify the corresponing source image
+     * @param {string} [settings.fontData=settings.font] - the bitmap font data corresponding name, or the bitmap font data itself
+     * @param {number} [settings.size] - size a scaling ratio
+     * @param {Color|string} [settings.fillStyle] - a CSS color value used to tint the bitmapText (@see BitmapText.tint)
+     * @param {number} [settings.lineWidth=1] - line width, in pixels, when drawing stroke
+     * @param {string} [settings.textAlign="left"] - horizontal text alignment
+     * @param {string} [settings.textBaseline="top"] - the text baseline
+     * @param {number} [settings.lineHeight=1.0] - line spacing height
+     * @param {Vector2d} [settings.anchorPoint={x:0.0, y:0.0}] - anchor point to draw the text at
+     * @param {number} [settings.wordWrapWidth] - the maximum length in CSS pixel for a single segment of text
+     * @param {(string|string[])} [settings.text] - a string, or an array of strings
+     * @example
+     * // Use me.loader.preload or me.loader.load to load assets
+     * me.loader.preload([
+     *     { name: "arial", type: "binary" src: "data/font/arial.fnt" },
+     *     { name: "arial", type: "image" src: "data/font/arial.png" },
+     * ])
+     * // Then create an instance of your bitmap font:
+     * var myFont = new me.BitmapText(x, y, {font:"arial", text:"Hello"});
+     * // two possibilities for using "myFont"
+     * // either call the draw function from your Renderable draw function
+     * myFont.draw(renderer, "Hello!", 0, 0);
+     * // or just add it to the word container
+     * me.game.world.addChild(myFont);
+     */
+    constructor(x: number, y: number, settings: {
+        font: string | (new (width?: number | undefined, height?: number | undefined) => HTMLImageElement);
+        fontData?: string | undefined;
+        size?: number | undefined;
+        fillStyle?: string | Color | undefined;
+        lineWidth?: number | undefined;
+        textAlign?: string | undefined;
+        textBaseline?: string | undefined;
+        lineHeight?: number | undefined;
+        anchorPoint?: any;
+        wordWrapWidth?: number | undefined;
+        text?: string | string[] | undefined;
+    });
+    /**
+     * Set the default text alignment (or justification),<br>
+     * possible values are "left", "right", and "center".
+     * @public
+     * @type {string}
+     * @default "left"
+     */
+    public textAlign: string;
+    /**
+     * Set the text baseline (e.g. the Y-coordinate for the draw operation), <br>
+     * possible values are "top", "hanging, "middle, "alphabetic, "ideographic, "bottom"<br>
+     * @public
+     * @type {string}
+     * @default "top"
+     */
+    public textBaseline: string;
+    /**
+     * Set the line spacing height (when displaying multi-line strings). <br>
+     * Current font height will be multiplied with this value to set the line height.
+     * @public
+     * @type {number}
+     * @default 1.0
+     */
+    public lineHeight: number;
+    /**
+     * the maximum length in CSS pixel for a single segment of text.
+     * (use -1 to disable word wrapping)
+     * @public
+     * @type {number}
+     * @default -1
+     */
+    public wordWrapWidth: number;
+    /**
+     * the text to be displayed
+     * @private
+     */
+    private _text;
+    /**
+     * scaled font size
+     * @private
+     */
+    private fontScale;
+    /**
+     * font image
+     * @private
+     */
+    private fontImage;
+    /**
+     * font data
+     * @private
+     */
+    private fontData;
+    public set fillStyle(arg: Color);
+    /**
+     * defines the color used to tint the bitmap text
+     * @public
+     * @type {Color}
+     * @see Renderable#tint
+     */
+    public get fillStyle(): Color;
+    metrics: TextMetrics;
+    /**
+     * change the font settings
+     * @param {string} textAlign - ("left", "center", "right")
+     * @param {number} [scale]
+     * @returns {BitmapText} this object for chaining
+     */
+    set(textAlign: string, scale?: number | undefined): BitmapText;
+    /**
+     * change the text to be displayed
+     * @param {number|string|string[]} value - a string, or an array of strings
+     * @returns {BitmapText} this object for chaining
+     */
+    setText(value?: number | string | string[]): BitmapText;
+    /**
+     * change the font display size
+     * @param {number} scale - ratio
+     * @returns {BitmapText} this object for chaining
+     */
+    resize(scale: number): BitmapText;
+    /**
+     * measure the given text size in pixels
+     * @param {string} [text]
+     * @returns {TextMetrics} a TextMetrics object with two properties: `width` and `height`, defining the output dimensions
+     */
+    measureText(text?: string | undefined): TextMetrics;
+    /**
+     * draw the bitmap font
+     * @param {CanvasRenderer|WebGLRenderer} renderer - Reference to the destination renderer instance
+     * @param {string} [text]
+     * @param {number} [x]
+     * @param {number} [y]
+     */
+    draw(renderer: CanvasRenderer | WebGLRenderer, text?: string | undefined, x?: number | undefined, y?: number | undefined): void;
+    /**
+     * Destroy function
+     * @ignore
+     */
+    destroy(): void;
+}
+import Renderable from "./../renderable/renderable.js";
+import Color from "./../math/color.js";
+import TextMetrics from "./textmetrics.js";

package/dist/types/text/bitmaptextdata.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Class for storing relevant data from the font file.
+ * @ignore
+ */
+export default class BitmapTextData {
+    /**
+     * @param {string} data - The bitmap font data pulled from the resource loader using me.loader.getBinary()
+     */
+    constructor(data: string);
+    /**
+     * @ignore
+     */
+    onResetEvent(data: any): void;
+    padTop: number | undefined;
+    padRight: number | undefined;
+    padBottom: number | undefined;
+    padLeft: number | undefined;
+    lineHeight: number | undefined;
+    capHeight: any;
+    descent: any;
+    /**
+     * The map of glyphs, each key is a char code.
+     * @name glyphs
+     * @type {object}
+     * @memberof BitmapTextData
+     */
+    glyphs: object | undefined;
+    /**
+     * This parses the font data text and builds a map of glyphs containing the data for each character
+     * @name parse
+     * @memberof BitmapTextData
+     * @param {string} fontData
+     */
+    parse(fontData: string): void;
+}

package/dist/types/text/glyph.d.ts

@@ -0,0 +1,28 @@
+/**
+ * a glyph representing a single character in a font
+ * @ignore
+ */
+export default class Glyph {
+    id: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    u: number;
+    v: number;
+    u2: number;
+    v2: number;
+    xoffset: number;
+    yoffset: number;
+    xadvance: number;
+    fixedWidth: boolean;
+    /**
+     * @ignore
+     */
+    getKerning(ch: any): any;
+    /**
+     * @ignore
+     */
+    setKerning(ch: any, value: any): void;
+    kerning: {} | undefined;
+}

package/dist/types/text/text.d.ts

@@ -0,0 +1,173 @@
+/**
+ * @classdesc
+ * a generic system font object.
+ * @augments Renderable
+ */
+export default class Text extends Renderable {
+    /**
+     * @param {number} x - position of the text object
+     * @param {number} y - position of the text object
+     * @param {object} settings - the text configuration
+     * @param {string} settings.font - a CSS family font name
+     * @param {number|string} settings.size - size, or size + suffix (px, em, pt)
+     * @param {Color|string} [settings.fillStyle="#000000"] - a CSS color value
+     * @param {Color|string} [settings.strokeStyle="#000000"] - a CSS color value
+     * @param {number} [settings.lineWidth=1] - line width, in pixels, when drawing stroke
+     * @param {string} [settings.textAlign="left"] - horizontal text alignment
+     * @param {string} [settings.textBaseline="top"] - the text baseline
+     * @param {number} [settings.lineHeight=1.0] - line spacing height
+     * @param {Vector2d} [settings.anchorPoint={x:0.0, y:0.0}] - anchor point to draw the text at
+     * @param {boolean} [settings.offScreenCanvas=false] - whether to draw the font to an individual "cache" texture first
+     * @param {number} [settings.wordWrapWidth] - the maximum length in CSS pixel for a single segment of text
+     * @param {(string|string[])} [settings.text=""] - a string, or an array of strings
+     * @example
+     * var font = new me.Text(0, 0, {font: "Arial", size: 8, fillStyle: this.color});
+     */
+    constructor(x: number, y: number, settings: {
+        font: string;
+        size: number | string;
+        fillStyle?: string | Color | undefined;
+        strokeStyle?: string | Color | undefined;
+        lineWidth?: number | undefined;
+        textAlign?: string | undefined;
+        textBaseline?: string | undefined;
+        lineHeight?: number | undefined;
+        anchorPoint?: any;
+        offScreenCanvas?: boolean | undefined;
+        wordWrapWidth?: number | undefined;
+        text?: string | string[] | undefined;
+    });
+    /** @ignore */
+    onResetEvent(x: any, y: any, settings: any): void;
+    fillStyle: any;
+    strokeStyle: any;
+    /**
+     * sets the current line width, in pixels, when drawing stroke
+     * @public
+     * @type {number}
+     * @default 1
+     */
+    public lineWidth: number | undefined;
+    /**
+     * Set the default text alignment (or justification),<br>
+     * possible values are "left", "right", and "center".<br>
+     * @public
+     * @type {string}
+     * @default "left"
+     */
+    public textAlign: string | undefined;
+    /**
+     * Set the text baseline (e.g. the Y-coordinate for the draw operation), <br>
+     * possible values are "top", "hanging, "middle, "alphabetic, "ideographic, "bottom"<br>
+     * @public
+     * @type {string}
+     * @default "top"
+     */
+    public textBaseline: string | undefined;
+    /**
+     * Set the line spacing height (when displaying multi-line strings). <br>
+     * Current font height will be multiplied with this value to set the line height.
+     * @public
+     * @type {number}
+     * @default 1.0
+     */
+    public lineHeight: number | undefined;
+    /**
+     * whether to draw the font to a indidividual offscreen canvas texture first <br>
+     * Note: this will improve performances when using WebGL, but will impact
+     * memory consumption as every text element will have its own canvas texture
+     * @public
+     * @type {boolean}
+     * @default false
+     */
+    public offScreenCanvas: boolean | undefined;
+    /**
+     * the maximum length in CSS pixel for a single segment of text.
+     * (use -1 to disable word wrapping)
+     * @public
+     * @type {number}
+     * @default -1
+     */
+    public wordWrapWidth: number | undefined;
+    /**
+     * the text to be displayed
+     * @private
+     */
+    private _text;
+    /**
+     * the font size (in px)
+     * @public
+     * @type {number}
+     * @default 10
+     */
+    public fontSize: number | undefined;
+    canvasTexture: object | undefined;
+    metrics: TextMetrics | undefined;
+    /**
+     * make the font bold
+     * @returns {Text} this object for chaining
+     */
+    bold(): Text;
+    font: any;
+    /**
+     * make the font italic
+     * @returns {Text} this object for chaining
+     */
+    italic(): Text;
+    /**
+     * set the font family and size
+     * @param {string} font - a CSS font name
+     * @param {number|string} [size=10] - size in px, or size + suffix (px, em, pt)
+     * @returns {Text} this object for chaining
+     * @example
+     * font.setFont("Arial", 20);
+     * font.setFont("Arial", "1.5em");
+     */
+    setFont(font: string, size?: string | number | undefined): Text;
+    /**
+     * change the text to be displayed
+     * @param {number|string|string[]} value - a string, or an array of strings
+     * @returns {Text} this object for chaining
+     */
+    setText(value?: number | string | string[]): Text;
+    glTextureUnit: any;
+    /**
+     * measure the given text size in pixels
+     * @param {CanvasRenderer|WebGLRenderer} renderer - reference to the active renderer
+     * @param {string} [text] - the text to be measured
+     * @returns {TextMetrics} a TextMetrics object defining the dimensions of the given piece of text
+     */
+    measureText(renderer: CanvasRenderer | WebGLRenderer, text?: string | undefined): TextMetrics;
+    /**
+     * draw a text at the specified coord
+     * @param {CanvasRenderer|WebGLRenderer} renderer - Reference to the destination renderer instance
+     * @param {string} [text]
+     * @param {number} [x]
+     * @param {number} [y]
+     * @param {boolean} [stroke=false] - draw stroke the the text if true
+     */
+    draw(renderer: CanvasRenderer | WebGLRenderer, text?: string | undefined, x?: number | undefined, y?: number | undefined, stroke?: boolean | undefined): void;
+    /**
+     * draw a stroke text at the specified coord, as defined <br>
+     * by the `lineWidth` and `fillStroke` properties. <br>
+     * Note : using drawStroke is not recommended for performance reasons
+     * @param {CanvasRenderer|WebGLRenderer} renderer - Reference to the destination renderer instance
+     * @param {string} text
+     * @param {number} x
+     * @param {number} y
+     */
+    drawStroke(renderer: CanvasRenderer | WebGLRenderer, text: string, x: number, y: number): void;
+    /**
+     * @ignore
+     */
+    _drawFont(context: any, text: any, x: any, y: any, stroke?: boolean): TextMetrics | undefined;
+    /**
+     * Destroy function
+     * @ignore
+     */
+    destroy(): void;
+}
+import Renderable from "./../renderable/renderable.js";
+import TextMetrics from "./textmetrics.js";
+import WebGLRenderer from "./../video/webgl/webgl_renderer.js";
+import Color from "./../math/color.js";

package/dist/types/text/textmetrics.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @classdesc
+ * a Text Metrics object that contains helper for text manipulation
+ * @augments Bounds
+ */
+export default class TextMetrics extends Bounds {
+    /**
+     * @param {Text|BitmapText} ancestor - the parent object that contains this TextMetrics object
+     */
+    constructor(ancestor: Text | BitmapText);
+    /**
+     * a reference to the parent object that contains this TextMetrics object
+     * @public
+     * @type {Renderable}
+     * @default undefined
+     */
+    public ancestor: Renderable;
+    /**
+     * Returns the height of a segment of inline text in CSS pixels.
+     * @returns {number} the height of a segment of inline text in CSS pixels.
+     */
+    lineHeight(): number;
+    /**
+     * Returns the width of the given segment of inline text in CSS pixels.
+     * @param {string} text - the text to be measured
+     * @param {CanvasRenderingContext2D} [context] - reference to an active 2d context for canvas rendering
+     * @returns {number} the width of the given segment of inline text in CSS pixels.
+     */
+    lineWidth(text: string, context?: CanvasRenderingContext2D | undefined): number;
+    /**
+     * measure the given text size in CSS pixels
+     * @param {string} text - the text to be measured
+     * @param {CanvasRenderingContext2D} [context] - reference to an active 2d context for canvas rendering
+     * @returns {TextMetrics} this
+     */
+    measureText(text: string, context?: CanvasRenderingContext2D | undefined): TextMetrics;
+    /**
+     * wrap the given text based on the given width
+     * @param {string|string[]} text - the text to be wrapped
+     * @param {number} width - maximum width of one segment of text in css pixel
+     * @param {CanvasRenderingContext2D} [context] - reference to an active 2d context for canvas rendering
+     * @returns {string[]} an array of string representing wrapped text
+     */
+    wordWrap(text: string | string[], width: number, context?: CanvasRenderingContext2D | undefined): string[];
+}
+import Bounds from "./../physics/bounds.js";
+import Text from "./text.js";

package/dist/types/text/textstyle.d.ts

@@ -0,0 +1,5 @@
+/**
+ * apply the current text style to the given context
+ * @ignore
+ */
+export default function setContextStyle(context: any, style: any, stroke?: boolean): void;

package/dist/types/tweens/easing.d.ts

@@ -0,0 +1,46 @@
+/**
+ * *
+ */
+export type Easing = Function;
+/**
+ * Easing Function :<br>
+ * <p>
+ * Easing.Linear.None<br>
+ * Easing.Quadratic.In<br>
+ * Easing.Quadratic.Out<br>
+ * Easing.Quadratic.InOut<br>
+ * Easing.Cubic.In<br>
+ * Easing.Cubic.Out<br>
+ * Easing.Cubic.InOut<br>
+ * Easing.Quartic.In<br>
+ * Easing.Quartic.Out<br>
+ * Easing.Quartic.InOut<br>
+ * Easing.Quintic.In<br>
+ * Easing.Quintic.Out<br>
+ * Easing.Quintic.InOut<br>
+ * Easing.Sinusoidal.In<br>
+ * Easing.Sinusoidal.Out<br>
+ * Easing.Sinusoidal.InOut<br>
+ * Easing.Exponential.In<br>
+ * Easing.Exponential.Out<br>
+ * Easing.Exponential.InOut<br>
+ * Easing.Circular.In<br>
+ * Easing.Circular.Out<br>
+ * Easing.Circular.InOut<br>
+ * Easing.Elastic.In<br>
+ * Easing.Elastic.Out<br>
+ * Easing.Elastic.InOut<br>
+ * Easing.Back.In<br>
+ * Easing.Back.Out<br>
+ * Easing.Back.InOut<br>
+ * Easing.Bounce.In<br>
+ * Easing.Bounce.Out<br>
+ * Easing.Bounce.InOut
+ * </p>
+ * @public
+ * @constant
+ * @enum {Function}
+ * @name Easing
+ * @memberof Tween
+ */
+export let Easing: any;

package/dist/types/tweens/interpolation.d.ts

@@ -0,0 +1,18 @@
+/**
+ * *
+ */
+export type Interpolation = Function;
+/**
+ * Interpolation Function :<br>
+ * <p>
+ * Interpolation.Linear<br>
+ * Interpolation.Bezier<br>
+ * Interpolation.CatmullRom
+ * </p>
+ * @public
+ * @constant
+ * @enum {Function}
+ * @name Interpolation
+ * @memberof Tween
+ */
+export let Interpolation: any;