littlejsengine 1.9.4 → 1.9.6

package/dist/littlejs.d.ts

@@ -1,4 +1,4 @@
-declare module "littlejs.esm" {
+declare module "littlejsengine" {
     /**
      * LittleJS - The Tiny Fast JavaScript Game Engine
      * MIT License - Copyright 2021 Frank Force
@@ -79,7 +79,7 @@ declare module "littlejs.esm" {
      *  @memberof Engine */
     export function engineObjectsDestroy(): void;
     /** Triggers a callback for each object within a given area
-     *  @param {Vector2} [pos]                 - Center of test area
+     *  @param {Vector2} [pos]                 - Center of test area, or undefined for all objects
      *  @param {Number|Vector2} [size]         - Radius of circle if float, rectangle size if Vector2
      *  @param {Function} [callbackFunction]   - Calls this function on every object that passes the test
      *  @param {Array} [objects=engineObjects] - List of objects to check
@@ -214,6 +214,11 @@ declare module "littlejs.esm" {
      *  @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 "littlejs.esm" {
      *  @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 */
@@ -619,13 +628,13 @@ declare module "littlejs.esm" {
      *  @memberof Utilities */
     export function nearestPowerOfTwo(value: number): number;
     /** Returns true if two axis aligned bounding boxes are overlapping
-     *  @param {Vector2} pointA         - Center of box A
-     *  @param {Vector2} sizeA          - Size of box A
-     *  @param {Vector2} pointB         - Center of box B
-     *  @param {Vector2} [sizeB=(0,0)]  - Size of box B, a point if undefined
-     *  @return {Boolean}               - True if overlapping
+     *  @param {Vector2} posA          - Center of box A
+     *  @param {Vector2} sizeA         - Size of box A
+     *  @param {Vector2} posB          - Center of box B
+     *  @param {Vector2} [sizeB=(0,0)] - Size of box B, a point if undefined
+     *  @return {Boolean}              - True if overlapping
      *  @memberof Utilities */
-    export function isOverlapping(pointA: Vector2, sizeA: Vector2, pointB: Vector2, sizeB?: Vector2): boolean;
+    export function isOverlapping(posA: Vector2, sizeA: Vector2, posB: Vector2, sizeB?: Vector2): boolean;
     /** Returns an oscillating wave between 0 and amplitude with frequency of 1 Hz by default
      *  @param {Number} [frequency] - Frequency of the wave in Hz
      *  @param {Number} [amplitude] - Amplitude (max height) of the wave
@@ -888,7 +897,7 @@ declare module "littlejs.esm" {
          * @param {Number} [alphaAmount]
          * @return {Color} */
         mutate(amount?: number, alphaAmount?: number): Color;
-        /** Returns this color expressed as a hex color code
+        /** Returns this color expressed as a rgb color code
          * @param {Boolean} [useAlpha] - if alpha should be included in result
          * @return {String} */
         toString(useAlpha?: boolean): string;
@@ -1103,9 +1112,9 @@ declare module "littlejs.esm" {
      *  @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 "littlejs.esm" {
      *  @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 "littlejs.esm" {
      *  @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 "littlejs.esm" {
      *  @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 "littlejs.esm" {
      *  @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 "littlejs.esm" {
      *  @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 "littlejs.esm" {
          *  @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
@@ -1637,7 +1646,11 @@ declare module "littlejs.esm" {
         collideSolidObjects: boolean;
         /** @property {Boolean} - Object collides with and blocks other objects */
         isSolid: boolean;
-        /** Update the object transform and physics, called automatically by engine once each frame */
+        /** @property {Boolean} - Object collides with raycasts */
+        collideRaycast: boolean;
+        /** 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 */
@@ -1650,11 +1663,6 @@ declare module "littlejs.esm" {
          *  @param {Vector2} pos      - tile where the collision occured
          *  @return {Boolean}         - true if the collision should be resolved */
         collideWithTile(tileData: number, pos: Vector2): boolean;
-        /** Called to check if a tile raycast hit
-         *  @param {Number}  tileData - the value of the tile at the position
-         *  @param {Vector2} pos      - tile where the raycast is
-         *  @return {Boolean}         - true if the raycast should hit */
-        collideWithTileRaycast(tileData: number, pos: Vector2): boolean;
         /** Called to check if a object collision should be resolved
          *  @param {EngineObject} object - the object to test against
          *  @return {Boolean}            - true if the collision should be resolved
@@ -1681,10 +1689,11 @@ declare module "littlejs.esm" {
          *  @param {EngineObject} child */
         removeChild(child: EngineObject): void;
         /** Set how this object collides
-         *  @param {Boolean} [collideSolidObjects] - Does it collide with solid objects
-         *  @param {Boolean} [isSolid]             - Does it collide with and block other objects (expensive in large numbers)
-         *  @param {Boolean} [collideTiles]        - Does it collide with the tile collision */
-        setCollision(collideSolidObjects?: boolean, isSolid?: boolean, collideTiles?: boolean): void;
+         *  @param {Boolean} [collideSolidObjects] - Does it collide with solid objects?
+         *  @param {Boolean} [isSolid]             - Does it collide with and block other objects? (expensive in large numbers)
+         *  @param {Boolean} [collideTiles]        - Does it collide with the tile collision?
+         *  @param {Boolean} [collideRaycast]      - Does it collide with raycasts? */
+        setCollision(collideSolidObjects?: boolean, isSolid?: boolean, collideTiles?: boolean, collideRaycast?: boolean): void;
         /** Returns string containg info about this object for debugging
          *  @return {String} */
         toString(): string;
@@ -1729,7 +1738,7 @@ declare module "littlejs.esm" {
      *  @return {Boolean}
      *  @memberof TileCollision */
     export function tileCollisionTest(pos: Vector2, size?: Vector2, object?: EngineObject): boolean;
-    /** Return the center of tile if any that is hit (does not return the exact intersection)
+    /** Return the center of first tile hit (does not return the exact intersection)
      *  @param {Vector2}      posStart
      *  @param {Vector2}      posEnd
      *  @param {EngineObject} [object]
@@ -1787,22 +1796,13 @@ declare module "littlejs.esm" {
         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;
@@ -1810,8 +1810,6 @@ declare module "littlejs.esm" {
          *  - 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
@@ -1828,6 +1826,17 @@ declare module "littlejs.esm" {
          *  @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)]
@@ -1950,22 +1959,23 @@ declare module "littlejs.esm" {
      */
     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 */