littlejsengine 1.9.5 → 1.9.7

package/dist/littlejs.d.ts

@@ -214,6 +214,11 @@ declare module "littlejsengine" {
      *  @default
      *  @memberof Settings */
     export let showSplashScreen: boolean;
+    /** Disables all rendering, audio, and input for servers
+     *  @type {Boolean}
+     *  @default
+     *  @memberof Settings */
+    export let headlessMode: boolean;
     /** Default size of tiles in pixels
      *  @type {Vector2}
      *  @default Vector2(16,16)
@@ -389,6 +394,10 @@ declare module "littlejsengine" {
      *  @param {Boolean} show
      *  @memberof Settings */
     export function setShowSplashScreen(show: boolean): void;
+    /** Set to disalbe rendering, audio, and input for servers
+     *  @param {Boolean} headless
+     *  @memberof Settings */
+    export function setHeadlessMode(headless: boolean): void;
     /** Set if webgl rendering is enabled
      *  @param {Boolean} enable
      *  @memberof Settings */
@@ -1103,9 +1112,9 @@ declare module "littlejsengine" {
      *  @param {Color}   [additiveColor=(0,0,0,0)]  - Additive color to be applied
      *  @param {Boolean} [useWebGL=glEnable]        - Use accelerated WebGL rendering
      *  @param {Boolean} [screenSpace=false]        - If true the pos and size are in screen space
-     *  @param {CanvasRenderingContext2D} [context] - Canvas 2D context to draw to
+     *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context] - Canvas 2D context to draw to
      *  @memberof Draw */
-    export function drawTile(pos: Vector2, size?: Vector2, tileInfo?: TileInfo, color?: Color, angle?: number, mirror?: boolean, additiveColor?: Color, useWebGL?: boolean, screenSpace?: boolean, context?: CanvasRenderingContext2D): void;
+    export function drawTile(pos: Vector2, size?: Vector2, tileInfo?: TileInfo, color?: Color, angle?: number, mirror?: boolean, additiveColor?: Color, useWebGL?: boolean, screenSpace?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Draw colored rect centered on pos
      *  @param {Vector2} pos
      *  @param {Vector2} [size=(1,1)]
@@ -1113,9 +1122,9 @@ declare module "littlejsengine" {
      *  @param {Number}  [angle]
      *  @param {Boolean} [useWebGL=glEnable]
      *  @param {Boolean} [screenSpace=false]
-     *  @param {CanvasRenderingContext2D} [context]
+     *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context]
      *  @memberof Draw */
-    export function drawRect(pos: Vector2, size?: Vector2, color?: Color, angle?: number, useWebGL?: boolean, screenSpace?: boolean, context?: CanvasRenderingContext2D): void;
+    export function drawRect(pos: Vector2, size?: Vector2, color?: Color, angle?: number, useWebGL?: boolean, screenSpace?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Draw colored line between two points
      *  @param {Vector2} posA
      *  @param {Vector2} posB
@@ -1123,9 +1132,9 @@ declare module "littlejsengine" {
      *  @param {Color}   [color=(1,1,1,1)]
      *  @param {Boolean} [useWebGL=glEnable]
      *  @param {Boolean} [screenSpace=false]
-     *  @param {CanvasRenderingContext2D} [context]
+     *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context]
      *  @memberof Draw */
-    export function drawLine(posA: Vector2, posB: Vector2, thickness?: number, color?: Color, useWebGL?: boolean, screenSpace?: boolean, context?: CanvasRenderingContext2D): void;
+    export function drawLine(posA: Vector2, posB: Vector2, thickness?: number, color?: Color, useWebGL?: boolean, screenSpace?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Draw directly to a 2d canvas context in world space
      *  @param {Vector2}  pos
      *  @param {Vector2}  size
@@ -1133,15 +1142,15 @@ declare module "littlejsengine" {
      *  @param {Boolean}  mirror
      *  @param {Function} drawFunction
      *  @param {Boolean} [screenSpace=false]
-     *  @param {CanvasRenderingContext2D} [context=mainContext]
+     *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=mainContext]
      *  @memberof Draw */
-    export function drawCanvas2D(pos: Vector2, size: Vector2, angle: number, mirror: boolean, drawFunction: Function, screenSpace?: boolean, context?: CanvasRenderingContext2D): void;
+    export function drawCanvas2D(pos: Vector2, size: Vector2, angle: number, mirror: boolean, drawFunction: Function, screenSpace?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Enable normal or additive blend mode
      *  @param {Boolean} [additive]
      *  @param {Boolean} [useWebGL=glEnable]
-     *  @param {CanvasRenderingContext2D} [context=mainContext]
+     *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=mainContext]
      *  @memberof Draw */
-    export function setBlendMode(additive?: boolean, useWebGL?: boolean, context?: CanvasRenderingContext2D): void;
+    export function setBlendMode(additive?: boolean, useWebGL?: boolean, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Draw text on overlay canvas in screen space
      *  Automatically splits new lines into rows
      *  @param {String}  text
@@ -1152,9 +1161,9 @@ declare module "littlejsengine" {
      *  @param {Color}   [lineColor=(0,0,0,1)]
      *  @param {CanvasTextAlign}  [textAlign]
      *  @param {String}  [font=fontDefault]
-     *  @param {CanvasRenderingContext2D} [context=overlayContext]
+     *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=overlayContext]
      *  @memberof Draw */
-    export function drawTextScreen(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: CanvasTextAlign, font?: string, context?: CanvasRenderingContext2D): void;
+    export function drawTextScreen(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: CanvasTextAlign, font?: string, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Draw text on overlay canvas in world space
      *  Automatically splits new lines into rows
      *  @param {String}  text
@@ -1165,9 +1174,9 @@ declare module "littlejsengine" {
      *  @param {Color}   [lineColor=(0,0,0,1)]
      *  @param {CanvasTextAlign}  [textAlign='center']
      *  @param {String}  [font=fontDefault]
-     *  @param {CanvasRenderingContext2D} [context=overlayContext]
+     *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=overlayContext]
      *  @memberof Draw */
-    export function drawText(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: CanvasTextAlign, font?: string, context?: CanvasRenderingContext2D): void;
+    export function drawText(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: CanvasTextAlign, font?: string, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     export let engineFontImage: any;
     /**
      * Font Image Object - Draw text on a 2D canvas by using characters in an image
@@ -1186,13 +1195,13 @@ declare module "littlejsengine" {
          *  @param {HTMLImageElement} [image]    - Image for the font, if undefined default font is used
          *  @param {Vector2} [tileSize=(8,8)]    - Size of the font source tiles
          *  @param {Vector2} [paddingSize=(0,1)] - How much extra space to add between characters
-         *  @param {CanvasRenderingContext2D} [context=overlayContext] - context to draw to
+         *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=overlayContext] - context to draw to
          */
-        constructor(image?: HTMLImageElement, tileSize?: Vector2, paddingSize?: Vector2, context?: CanvasRenderingContext2D);
+        constructor(image?: HTMLImageElement, tileSize?: Vector2, paddingSize?: Vector2, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D);
         image: any;
         tileSize: Vector2;
         paddingSize: Vector2;
-        context: CanvasRenderingContext2D;
+        context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;
         /** Draw text in world space using the image font
          *  @param {String}  text
          *  @param {Vector2} pos
@@ -1215,6 +1224,10 @@ declare module "littlejsengine" {
     /** Toggle fullsceen mode
      *  @memberof Draw */
     export function toggleFullscreen(): void;
+    /** Get the camera's visible area in world space
+     *  @return {Vector2}
+     *  @memberof Draw */
+    export function getCameraSize(): Vector2;
     /**
      * LittleJS WebGL Interface
      * - All webgl used by the engine is wrapped up here
@@ -1372,16 +1385,6 @@ declare module "littlejsengine" {
     /** True if a touch device has been detected
      *  @memberof Input */
     export const isTouchDevice: boolean;
-    /**
-     * LittleJS Audio System
-     * - <a href=https://killedbyapixel.github.io/ZzFX/>ZzFX Sound Effects</a> - ZzFX Sound Effect Generator
-     * - <a href=https://keithclark.github.io/ZzFXM/>ZzFXM Music</a> - ZzFXM Music System
-     * - Caches sounds and music for fast playback
-     * - Can attenuate and apply stereo panning to sounds
-     * - Ability to play mp3, ogg, and wave files
-     * - Speech synthesis functions
-     * @namespace Audio
-     */
     /**
      * Sound Object - Stores a sound for later use and can be played positionally
      *
@@ -1456,9 +1459,9 @@ declare module "littlejsengine" {
          *  @param {Number} [randomness] - How much to randomize frequency each time sound plays
          *  @param {Number} [range=soundDefaultRange] - World space max range of sound, will not play if camera is farther away
          *  @param {Number} [taper=soundDefaultTaper] - At what percentage of range should it start tapering off
+         *  @param {Function} [onloadCallback] - callback function to call when sound is loaded
          */
-        constructor(filename: string, randomness?: number, range?: number, taper?: number);
-        randomness: number;
+        constructor(filename: string, randomness?: number, range?: number, taper?: number, onloadCallback?: Function);
     }
     /**
      * Music Object - Stores a zzfx music track for later use
@@ -1507,9 +1510,9 @@ declare module "littlejsengine" {
      *  @param {String}  filename - Location of sound file to play
      *  @param {Number}  [volume] - How much to scale volume by
      *  @param {Boolean} [loop] - True if the music should loop
-     *  @return {HTMLAudioElement} - The audio element for this sound
+     *  @return {SoundWave} - The sound object for this file
      *  @memberof Audio */
-    export function playAudioFile(filename: string, volume?: number, loop?: boolean): HTMLAudioElement;
+    export function playAudioFile(filename: string, volume?: number, loop?: boolean): SoundWave;
     /** Speak text with passed in settings
      *  @param {String} text - The text to speak
      *  @param {String} [language] - The language/accent to use (examples: en, it, ru, ja, zh)
@@ -1528,6 +1531,16 @@ declare module "littlejsengine" {
      *  @return {Number} - The frequency of the note
      *  @memberof Audio */
     export function getNoteFrequency(semitoneOffset: number, rootFrequency?: number): number;
+    /**
+     * LittleJS Audio System
+     * - <a href=https://killedbyapixel.github.io/ZzFX/>ZzFX Sound Effects</a> - ZzFX Sound Effect Generator
+     * - <a href=https://keithclark.github.io/ZzFXM/>ZzFXM Music</a> - ZzFXM Music System
+     * - Caches sounds and music for fast playback
+     * - Can attenuate and apply stereo panning to sounds
+     * - Ability to play mp3, ogg, and wave files
+     * - Speech synthesis functions
+     * @namespace Audio
+     */
     /** Audio context used by the engine
      *  @type {AudioContext}
      *  @memberof Audio */
@@ -1625,6 +1638,8 @@ declare module "littlejsengine" {
         spawnTime: number;
         /** @property {Array}   - List of children of this object */
         children: any[];
+        /** @property {Boolean}  - Limit object speed using linear or circular math */
+        clampSpeedLinear: boolean;
         /** @property {EngineObject} - Parent of object if in local space  */
         parent: any;
         /** @property {Vector2}      - Local position if child */
@@ -1639,7 +1654,9 @@ declare module "littlejsengine" {
         isSolid: boolean;
         /** @property {Boolean} - Object collides with raycasts */
         collideRaycast: boolean;
-        /** Update the object transform and physics, called automatically by engine once each frame */
+        /** Update the object transform, called automatically by engine even when paused */
+        updateTransforms(): void;
+        /** Update the object physics, called automatically by engine once each frame */
         update(): void;
         groundObject: any;
         /** Render the object, draws a tile by default, automatically called each frame, sorted by renderOrder */
@@ -1785,22 +1802,13 @@ declare module "littlejsengine" {
         constructor(position?: Vector2, size?: Vector2, tileInfo?: TileInfo, scale?: Vector2, renderOrder?: number);
         /** @property {HTMLCanvasElement} - The canvas used by this tile layer */
         canvas: HTMLCanvasElement;
-        /** @property {CanvasRenderingContext2D} - The 2D canvas context used by this tile layer */
+        /** @property {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} - The 2D canvas context used by this tile layer */
         context: CanvasRenderingContext2D;
         /** @property {Vector2} - How much to scale this layer when rendered */
         scale: Vector2;
         /** @property {Boolean} - If true this layer will render to overlay canvas and appear above all objects */
         isOverlay: boolean;
         data: TileLayerData[];
-        /** Set data at a given position in the array
-         *  @param {Vector2}       layerPos - Local position in array
-         *  @param {TileLayerData} data     - Data to set
-         *  @param {Boolean}       [redraw] - Force the tile to redraw if true */
-        setData(layerPos: Vector2, data: TileLayerData, redraw?: boolean): void;
-        /** Get data at a given position in the array
-         *  @param {Vector2} layerPos - Local position in array
-         *  @return {TileLayerData} */
-        getData(layerPos: Vector2): TileLayerData;
         /** Draw all the tile data to an offscreen canvas
          *  - This may be slow in some browsers but only needs to be done once */
         redraw(): void;
@@ -1808,8 +1816,6 @@ declare module "littlejsengine" {
          *  - This can be used to manually update small parts of the level
          *  @param {Boolean} [clear] - Should it clear the canvas before drawing */
         redrawStart(clear?: boolean): void;
-        /** @type {[HTMLCanvasElement, CanvasRenderingContext2D, Vector2, Vector2, number]} */
-        savedRenderSettings: [HTMLCanvasElement, CanvasRenderingContext2D, Vector2, Vector2, number];
         /** Call to end the redraw process */
         redrawEnd(): void;
         /** Draw the tile at a given position in the tile grid
@@ -1826,6 +1832,17 @@ declare module "littlejsengine" {
          *  @param {Boolean}  mirror
          *  @param {Function} drawFunction */
         drawCanvas2D(pos: Vector2, size: Vector2, angle: number, mirror: boolean, drawFunction: Function): void;
+        /** Set data at a given position in the array
+         *  @param {Vector2}       layerPos - Local position in array
+         *  @param {TileLayerData} data     - Data to set
+         *  @param {Boolean}       [redraw] - Force the tile to redraw if true */
+        setData(layerPos: Vector2, data: TileLayerData, redraw?: boolean): void;
+        /** Get data at a given position in the array
+         *  @param {Vector2} layerPos - Local position in array
+         *  @return {TileLayerData} */
+        getData(layerPos: Vector2): TileLayerData;
+        /** @type {[HTMLCanvasElement, CanvasRenderingContext2D, Vector2, Vector2, number]} */
+        savedRenderSettings: [HTMLCanvasElement, CanvasRenderingContext2D, Vector2, Vector2, number];
         /** Draw a tile directly onto the layer canvas in world space
          *  @param {Vector2}  pos
          *  @param {Vector2}  [size=(1,1)]
@@ -1948,22 +1965,23 @@ declare module "littlejsengine" {
      */
     export class Particle extends EngineObject {
         /**
-         * Create a particle with the given shis.colorStart = undefined;ettings
-         * @param {Vector2}  position     - World space position of the particle
-         * @param {TileInfo} [tileInfo]   - Tile info to render particles
-         * @param {Number}   [angle]      - Angle to rotate the particle
-         * @param {Color}    [colorStart] - Color at start of life
-         * @param {Color}    [colorEnd]   - Color at end of life
-         * @param {Number}   [lifeTime]   - How long to live for
-         * @param {Number}   [sizeStart]  - Angle to rotate the particle
-         * @param {Number}   [sizeEnd]    - Angle to rotate the particle
-         * @param {Number}   [fadeRate]   - Angle to rotate the particle
-         * @param {Boolean}  [additive]   - Angle to rotate the particle
-         * @param {Number}   [trailScale] - If a trail, how long to make it
+         * Create a particle with the passed in settings
+         * Typically this is created automatically by a ParticleEmitter
+         * @param {Vector2}  position   - World space position of the particle
+         * @param {TileInfo} tileInfo   - Tile info to render particles
+         * @param {Number}   angle      - Angle to rotate the particle
+         * @param {Color}    colorStart - Color at start of life
+         * @param {Color}    colorEnd   - Color at end of life
+         * @param {Number}   lifeTime   - How long to live for
+         * @param {Number}   sizeStart  - Size at start of life
+         * @param {Number}   sizeEnd    - Size at end of life
+         * @param {Number}   fadeRate   - How quick to fade in/out
+         * @param {Boolean}  additive   - Does it use additive blend mode
+         * @param {Number}   trailScale - If a trail, how long to make it
          * @param {ParticleEmitter} [localSpaceEmitter] - Parent emitter if local space
-         * @param {Function}  [destroyCallback] - Called when particle dies
+         * @param {Function} [destroyCallback] - Callback when particle dies
          */
-        constructor(position: Vector2, tileInfo?: TileInfo, angle?: number, colorStart?: Color, colorEnd?: Color, lifeTime?: number, sizeStart?: number, sizeEnd?: number, fadeRate?: number, additive?: boolean, trailScale?: number, localSpaceEmitter?: ParticleEmitter, destroyCallback?: Function);
+        constructor(position: Vector2, tileInfo: TileInfo, angle: number, colorStart: Color, colorEnd: Color, lifeTime: number, sizeStart: number, sizeEnd: number, fadeRate: number, additive: boolean, trailScale: number, localSpaceEmitter?: ParticleEmitter, destroyCallback?: Function);
         /** @property {Color} - Color at start of life */
         colorStart: Color;
         /** @property {Color} - Calculated change in color */