littlejsengine 1.17.5 → 1.17.11

package/LICENSE

@@ -1,6 +1,6 @@
-MIT License
+LittleJS Engine License (MIT License)
 
-Copyright (c) 2021 Frank Force
+Copyright (c) 2021 Frank Force http://www.frankforce.com
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -22,12 +22,12 @@ SOFTWARE.
 
 -------------------------------------------------------------------------------
 
-This project uses the Box2D physics engine, which is licensed under the zlib license.
-Copyright (c) 2006 Erin Catto (Box2D)
-Copyright (c) 2011 The box2d.js contributors
+Box2D License
+
+Copyright (c) 2006-2013 Erin Catto http://www.gphysics.com
 
 This software is provided 'as-is', without any express or implied
-warranty. In no event will the authors be held liable for any damages
+warranty.  In no event will the authors be held liable for any damages
 arising from the use of this software.
 
 Permission is granted to anyone to use this software for any purpose,
@@ -35,9 +35,9 @@ including commercial applications, and to alter it and redistribute it
 freely, subject to the following restrictions:
 
 1. The origin of this software must not be misrepresented; you must not
-   claim that you wrote the original software. If you use this software
-   in a product, an acknowledgment in the product documentation would be
-   appreciated but is not required.
+claim that you wrote the original software. If you use this software
+in a product, an acknowledgment in the product documentation would be
+appreciated but is not required.
 2. Altered source versions must be plainly marked as such, and must not be
-   misrepresented as being the original software.
+misrepresented as being the original software.
 3. This notice may not be removed or altered from any source distribution.

package/dist/littlejs.d.ts

@@ -27,6 +27,10 @@ declare module "littlejsengine" {
      * - Function called when a sound ends
      */
     export type AudioEndedCallback = (source: AudioBufferSourceNode) => any;
+    /**
+     * - Function to handle a tile collision test
+     */
+    export type TileCollisionCallback = (tileData: number, pos: Vector2) => any;
     /**
      * - Function that processes a medal
      */
@@ -34,7 +38,11 @@ declare module "littlejsengine" {
     /**
      * - Function that processes a particle
      */
-    export type ParticleCallbackFunction = (particle: Particle) => any;
+    export type ParticleCallback = (particle: Particle) => any;
+    /**
+     * - Collide callback for particles
+     */
+    export type ParticleCollideCallback = (particle: Particle, tileData: number, pos: Vector2) => any;
     /**
      * LittleJS - The Tiny Fast JavaScript Game Engine
      * MIT License - Copyright 2021 Frank Force
@@ -137,8 +145,11 @@ declare module "littlejsengine" {
      *  @memberof Engine */
     export function engineObjectsUpdate(): void;
     /** Destroy and remove all objects
+     *  - This can be used to clear out all objects when restarting a level
+     *  - Objects can override their destroy function to do cleanup or stick around
+     *  @param {boolean} [immediate] - should attached effects be allowed to die off?
      *  @memberof Engine */
-    export function engineObjectsDestroy(): void;
+    export function engineObjectsDestroy(immediate?: boolean): void;
     /** Collects all object within a given area
      *  @param {Vector2} [pos] - Center of test area, or undefined for all objects
      *  @param {Vector2|number} [size] - Radius of circle if float, rectangle size if Vector2
@@ -889,12 +900,6 @@ declare module "littlejsengine" {
      *  @return {number}            - Value waving between 0 and amplitude
      *  @memberof Math */
     export function wave(frequency?: number, amplitude?: number, t?: number, offset?: number): number;
-    /**
-     * LittleJS Utility Classes and Functions
-     * - General purpose utilities
-     * - Timer - tracks time automatically
-     * @namespace Utilities
-     */
     /** Formats seconds to mm:ss style for display purposes
      *  @param {number} t - time in seconds
      *  @return {string}
@@ -929,6 +934,17 @@ declare module "littlejsengine" {
      *  @param {Function} [callback] - Called when share is complete
      *  @memberof Utilities */
     export function shareURL(title: string, url: string, callback?: Function): void;
+    /** Read save data from local storage
+     *  @param {string} saveName - unique name for the game/save
+     *  @param {Object} [defaultSaveData] - default values for save
+     *  @return {Object}
+     *  @memberof Utilities */
+    export function readSaveData(saveName: string, defaultSaveData?: any): any;
+    /** Write save data to local storage
+     *  @param {string} saveName - unique name for the game/save
+     *  @param {Object} saveData - object containing data to be saved
+     *  @memberof Utilities */
+    export function writeSaveData(saveName: string, saveData: any): void;
     /** Random global functions
      *  @namespace Random */
     /** Returns a random value between the two values passed in
@@ -1265,6 +1281,12 @@ declare module "littlejsengine" {
          * @return {boolean} */
         isValid(): boolean;
     }
+    /**
+     * LittleJS Utility Classes and Functions
+     * - General purpose utilities
+     * - Timer - tracks time automatically
+     * @namespace Utilities
+     */
     /**
      * Timer object tracks how long has passed since it was set
      * @memberof Engine
@@ -1368,7 +1390,9 @@ declare module "littlejsengine" {
      * @memberof Math */
     export function isNumber(n: any): boolean;
     /**
-     * Check if object is a valid string or can be converted to one
+     * Check if object can be converted to a string (has a toString method)
+     * - Returns true for strings, numbers, and most objects
+     * - Returns false for null and undefined
      * @param {any} s
      * @return {boolean}
      * @memberof Math */
@@ -1383,7 +1407,7 @@ declare module "littlejsengine" {
      *  @type {Color}
      *  @memberof Math */
     export const WHITE: Color;
-    /** Color - Clear White #757474ff with 0 alpha
+    /** Color - Clear White #ffffff00 with 0 alpha
      *  @type {Color}
      *  @memberof Math */
     export const CLEAR_WHITE: Color;
@@ -1391,7 +1415,7 @@ declare module "littlejsengine" {
      *  @type {Color}
      *  @memberof Math */
     export const BLACK: Color;
-    /** Color - Clear Black #000000 with 0 alpha
+    /** Color - Clear Black #00000000 with 0 alpha
      *  @type {Color}
      *  @memberof Math */
     export const CLEAR_BLACK: Color;
@@ -1488,7 +1512,7 @@ declare module "littlejsengine" {
          */
         setFullImage(textureInfo?: TextureInfo): TileInfo;
         /**
-         * Returns a tile info for an index using this tile as refrence
+         * Returns a tile info for an index using this tile as reference
          * @param {Vector2|number} [index=0]
          * @return {TileInfo}
          */
@@ -1778,7 +1802,7 @@ declare module "littlejsengine" {
      */
     export class FontImage {
         /** Create an image font
-         *  @param {TileInfo} tileInfo - Tile info of first characeter in font
+         *  @param {TileInfo} tileInfo - Tile info of first character in font
          */
         constructor(tileInfo: TileInfo);
         /** @property {TileInfo} - Tile info for the font */
@@ -2213,8 +2237,8 @@ declare module "littlejsengine" {
         isLoaded(): boolean;
         /** Loads a sound from a URL and decodes it into sample data.
         *  @param {string} filename
-        *  @return {Promise<void>} */
-        loadSound(filename: string): Promise<void>;
+        *  @return {Promise} */
+        loadSound(filename: string): Promise<any>;
     }
     /**
      * Sound Instance - Wraps an AudioBufferSourceNode for individual sound control
@@ -2228,7 +2252,7 @@ declare module "littlejsengine" {
      * // Control the individual instance
      * instance.setVolume(.5);
      * instance.pause();
-     * instance.unpause();
+     * instance.resume();
      * instance.stop();
      */
     export class SoundInstance {
@@ -2270,14 +2294,14 @@ declare module "littlejsengine" {
         stop(fadeTime?: number): void;
         /** Pause this sound instance */
         pause(): void;
-        /** Unpauses this sound instance */
+        /** Resume this sound instance */
         resume(): void;
         /** Check if this instance is currently playing
          *  @return {boolean} - True if playing
          */
         isPlaying(): boolean;
-        /** Check if this instance is paused and was not stopped
-         *  @return {boolean} - True if paused
+        /** Check if this instance is paused or stopped (not currently playing)
+         *  @return {boolean} - True if not playing
          */
         isPaused(): boolean;
         /** Get the current playback time in seconds
@@ -2416,15 +2440,17 @@ declare module "littlejsengine" {
         additiveColor: any;
         /** @property {boolean} - Should it flip along y axis when rendered */
         mirror: boolean;
-        /** @property {number} [mass=objectDefaultMass] - How heavy the object is, static if 0 */
+        /** @property {boolean} - Has object been destroyed? */
+        destroyed: boolean;
+        /** @property {number} - How heavy the object is, static if 0 */
         mass: number;
-        /** @property {number} [damping=objectDefaultDamping] - How much to slow down velocity each frame (0-1) */
+        /** @property {number} - How much to slow down velocity each frame (0-1) */
         damping: number;
-        /** @property {number} [angleDamping=objectDefaultAngleDamping] - How much to slow down rotation each frame (0-1) */
+        /** @property {number} - How much to slow down rotation each frame (0-1) */
         angleDamping: number;
-        /** @property {number} [restitution=objectDefaultRestitution] - How bouncy the object is when colliding (0-1) */
+        /** @property {number} - How bouncy the object is when colliding (0-1) */
         restitution: number;
-        /** @property {number} [friction=objectDefaultFriction] - How much friction to apply when sliding (0-1) */
+        /** @property {number} - How much friction to apply when sliding (0-1) */
         friction: number;
         /** @property {number} - How much to scale gravity by for this object */
         gravityScale: number;
@@ -2464,9 +2490,9 @@ declare module "littlejsengine" {
         update(): void;
         /** Render the object, draws a tile by default, automatically called each frame, sorted by renderOrder */
         render(): void;
-        /** Destroy this object, destroy its children, detach its parent, and mark it for removal */
-        destroy(): void;
-        destroyed: number;
+        /** Destroy this object, destroy its children, detach its parent, and mark it for removal
+         *  @param {boolean} [immediate] - should attached effects be allowed to die off? */
+        destroy(immediate?: boolean): void;
         /** Convert from local space to world space
          *  @param {Vector2} pos - local space point */
         localToWorld(pos: Vector2): Vector2;
@@ -2525,7 +2551,7 @@ declare module "littlejsengine" {
          *  @param {EngineObject} child */
         removeChild(child: EngineObject): void;
         /** Check if overlapping another engine object
-         *  Collisions are resoloved to prevent overlaps
+         *  Collisions are resolved to prevent overlaps
          *  @param {EngineObject} object
          *  @return {boolean} */
         isOverlappingObject(object: EngineObject): boolean;
@@ -2560,27 +2586,34 @@ declare module "littlejsengine" {
     export const tileCollisionLayers: Array<TileCollisionLayer>;
     /** Get tile collision data for a given cell in the grid
     *  @param {Vector2} pos
+    *  @param {boolean} [solidOnly] - Only check solid layers?
     *  @return {number}
     *  @memberof TileLayers */
-    export function tileCollisionGetData(pos: Vector2): number;
+    export function tileCollisionGetData(pos: Vector2, solidOnly?: boolean): number;
     /** Check if a tile layer collides with another object
-     *  @param {Vector2}      pos
-     *  @param {Vector2}      [size=vec2()]
-     *  @param {EngineObject} [object] - An object or undefined for generic test
-     *  @param {boolean}      [solidOnly] - Only check solid layers if true
+     *  @param {Vector2} pos
+     *  @param {Vector2} [size=vec2()]
+     *  @param {EngineObject|TileCollisionCallback} [callbackObject] - Callback, engine object, or undefined
+     *  @param {boolean} [solidOnly] - Only check solid layers?
      *  @return {TileCollisionLayer}
      *  @memberof TileLayers */
-    export function tileCollisionTest(pos: Vector2, size?: Vector2, object?: EngineObject, solidOnly?: boolean): TileCollisionLayer;
+    export function tileCollisionTest(pos: Vector2, size?: Vector2, callbackObject?: EngineObject | TileCollisionCallback, solidOnly?: boolean): TileCollisionLayer;
+    /**
+     *  @callback TileCollisionCallback - Function to handle a tile collision test
+     *  @param {number} tileData - the value of the tile at the position
+     *  @param {Vector2} pos - world space position of tile where the collision occurred
+     *  @memberof TileLayers
+     */
     /** Return the exact position of the boundary of first tile hit, undefined if nothing was hit.
-     *  The point will be inside the colliding tile if it hits (may have a tiny shift)
-     *  @param {Vector2}      posStart
-     *  @param {Vector2}      posEnd
-     *  @param {EngineObject} [object] - An object or undefined for generic test
-     *  @param {Vector2}      [normal] - Optional normal of the surface hit
-     *  @param {boolean}      [solidOnly=true] - Only check solid layers if true
+     *  The point will be inside the colliding tile if it hits
+     *  @param {Vector2} posStart
+     *  @param {Vector2} posEnd
+     *  @param {EngineObject|TileCollisionCallback} [callbackObject] - Callback, engine object, or undefined
+     *  @param {Vector2} [normal] - Optional normal of the surface hit
+     *  @param {boolean} [solidOnly=true] - Only check solid layers?
      *  @return {Vector2|undefined} - position of the center of the tile hit or undefined if no hit
      *  @memberof TileLayers */
-    export function tileCollisionRaycast(posStart: Vector2, posEnd: Vector2, object?: EngineObject, normal?: Vector2, solidOnly?: boolean): Vector2 | undefined;
+    export function tileCollisionRaycast(posStart: Vector2, posEnd: Vector2, callbackObject?: EngineObject | TileCollisionCallback, normal?: Vector2, solidOnly?: boolean): Vector2 | undefined;
     /**
      * Load tile layers from exported data
      *  @param {Object}   tileMapData - Level data from exported data
@@ -2645,6 +2678,8 @@ declare module "littlejsengine" {
         context: OffscreenCanvasRenderingContext2D;
         /** @property {TextureInfo} - Texture info to use for this object rendering */
         textureInfo: TextureInfo;
+        /** Destroy this canvas layer */
+        destroy(): void;
         /** Draw this canvas layer centered in world space, with color applied if using WebGL
         *  @param {Vector2} pos - Center in world space
         *  @param {Vector2} [size] - Size in world space
@@ -2790,30 +2825,41 @@ declare module "littlejsengine" {
         /** Check if collision with another object should occur
         *  @param {Vector2}      pos
         *  @param {Vector2}      [size=vec2()]
-        *  @param {EngineObject} [object]
+        *  @param {EngineObject|TileCollisionCallback} [callbackObject] - Callback, engine object, or undefined
         *  @return {boolean} */
-        collisionTest(pos: Vector2, size?: Vector2, object?: EngineObject): boolean;
+        collisionTest(pos: Vector2, size?: Vector2, callbackObject?: EngineObject | TileCollisionCallback): boolean;
         /** Return the exact position of the boundary of first tile hit, undefined if nothing was hit.
         *  The point will be inside the colliding tile if it hits (may have a tiny shift)
-        *  @param {Vector2}      posStart
-        *  @param {Vector2}      posEnd
-        *  @param {EngineObject} [object] - An object or undefined for generic test
-        *  @param {Vector2}      [normal] - Optional normal of the surface hit
+        *  @param {Vector2} posStart
+        *  @param {Vector2} posEnd
+        *  @param {EngineObject|TileCollisionCallback} [callbackObject] - Callback, engine object, or undefined
+        *  @param {Vector2} [normal] - Optional normal of the surface hit
         *  @return {Vector2|undefined} */
-        collisionRaycast(posStart: Vector2, posEnd: Vector2, object?: EngineObject, normal?: Vector2): Vector2 | undefined;
+        collisionRaycast(posStart: Vector2, posEnd: Vector2, callbackObject?: EngineObject | TileCollisionCallback, normal?: Vector2): Vector2 | undefined;
     }
     /**
      * LittleJS Particle System
+     * - A simple but fast and flexible particle system
+     * - Lightweight Particles are created and managed by ParticleEmitters
+     * - The particle design tool can be used to help create emitters
+     * @namespace Particles
      */
     /**
-     *  @callback ParticleCallbackFunction - Function that processes a particle
+     *  @callback ParticleCallback - Function that processes a particle
      *  @param {Particle} particle
-     *  @memberof Engine
+     *  @memberof Particles
+     */
+    /**
+     *  @callback ParticleCollideCallback - Collide callback for particles
+     *  @param {Particle} particle
+     *  @param {number} tileData
+     *  @param {Vector2} pos
+     *  @memberof Particles
      */
     /**
      * Particle Emitter - Spawns particles with the given settings
      * @extends EngineObject
-     * @memberof Engine
+     * @memberof Particles
      * @example
      * // create a particle emitter
      * let pos = vec2(2,3);
@@ -2830,7 +2876,7 @@ declare module "littlejsengine" {
      */
     export class ParticleEmitter extends EngineObject {
         /** Create a particle system with the given settings
-         *  @param {Vector2} position - World space position of the emitter
+         *  @param {Vector2} pos - World space position of the emitter
          *  @param {number} [angle] - Angle to emit the particles
          *  @param {number|Vector2}  [emitSize] - World space size of the emitter (float for circle diameter, vec2 for rect)
          *  @param {number} [emitTime] - How long to stay alive (0 is forever)
@@ -2858,9 +2904,11 @@ declare module "littlejsengine" {
          *  @param {number} [renderOrder] - Render order for particles (additive is above other stuff by default)
          *  @param {boolean}  [localSpace] - Should it be in local space of emitter (world space is default)
          */
-        constructor(position: Vector2, angle?: number, emitSize?: number | Vector2, emitTime?: number, emitRate?: number, emitConeAngle?: number, tileInfo?: TileInfo, colorStartA?: Color, colorStartB?: Color, colorEndA?: Color, colorEndB?: Color, particleTime?: number, sizeStart?: number, sizeEnd?: number, speed?: number, angleSpeed?: number, damping?: number, angleDamping?: number, gravityScale?: number, particleConeAngle?: number, fadeRate?: number, randomness?: number, collideTiles?: boolean, additive?: boolean, randomColorLinear?: boolean, renderOrder?: number, localSpace?: boolean);
+        constructor(pos: Vector2, angle?: number, emitSize?: number | Vector2, emitTime?: number, emitRate?: number, emitConeAngle?: number, tileInfo?: TileInfo, colorStartA?: Color, colorStartB?: Color, colorEndA?: Color, colorEndB?: Color, particleTime?: number, sizeStart?: number, sizeEnd?: number, speed?: number, angleSpeed?: number, damping?: number, angleDamping?: number, gravityScale?: number, particleConeAngle?: number, fadeRate?: number, randomness?: number, collideTiles?: boolean, additive?: boolean, randomColorLinear?: boolean, renderOrder?: number, localSpace?: boolean);
+        /** @property {boolean} - Should particles be emitted in a circle */
+        emitCircle: boolean;
         /** @property {number|Vector2} - World space size of the emitter (float for circle diameter, vec2 for rect) */
-        emitSize: number | Vector2;
+        emitSize: Vector2;
         /** @property {number} - How long to stay alive (0 is forever) */
         emitTime: number;
         /** @property {number} - How many particles per second to spawn, does not emit if 0 */
@@ -2899,64 +2947,86 @@ declare module "littlejsengine" {
         localSpace: boolean;
         /** @property {number} - If non zero the particle is drawn as a trail, stretched in the direction of velocity */
         trailScale: number;
-        /** @property {ParticleCallbackFunction} - Callback when particle is destroyed */
-        particleDestroyCallback: any;
-        /** @property {ParticleCallbackFunction} - Callback when particle is created */
+        /** @property {ParticleCallback} - Callback when particle is created */
         particleCreateCallback: any;
-        /** @property {number} - Track particle emit time */
-        emitTimeBuffer: number;
+        /** @property {ParticleCallback} - Callback when particle is destroyed */
+        particleDestroyCallback: any;
+        /** @property {ParticleCollideCallback} - Callback when particle collides */
+        particleCollideCallback: any;
         /** @property {number} - Percentage of velocity to pass to particles (0-1) */
         velocityInheritance: number;
+        /** @property {number} - Track particle emit time */
+        emitTimeBuffer: number;
+        /** @property {Array<Particle>} - Array of particles for this emitter */
+        particles: any[];
         previousAngle: number;
         previousPos: Vector2;
         /** Spawn one particle
          *  @return {Particle} */
         emitParticle(): Particle;
+        /** is emitter actively spawning */
+        isActive(): boolean;
     }
     /**
      * Particle Object - Created automatically by Particle Emitters
-     * @extends EngineObject
-     * @memberof Engine
+     * @memberof Particles
      */
-    export class Particle extends EngineObject {
+    export class Particle {
         /**
          * 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 {ParticleCallbackFunction} [destroyCallback] - Callback when particle dies
+         * @param {ParticleEmitter} emitter - The emitter that created this particle
+         * @param {Vector2} pos             - World or local space position
+         * @param {number}  angle           - Angle of 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 {Vector2} [velocity]      - Velocity of the particle
+         * @param {number}  [angleVelocity] - Angular speed of the particle
          */
-        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?: ParticleCallbackFunction);
-        /** @property {Color} - Color at start of life */
+        constructor(emitter: ParticleEmitter, pos: Vector2, angle: number, colorStart: Color, colorEnd: Color, lifeTime: number, sizeStart: number, sizeEnd: number, velocity?: Vector2, angleVelocity?: number);
+        /** @property {ParticleEmitter} */
+        emitter: ParticleEmitter;
+        /** @property {Vector2} */
+        pos: Vector2;
+        /** @property {number} */
+        angle: number;
+        /** @property {Vector2} */
+        size: Vector2;
+        /** @property {Color} */
+        color: Color;
+        /** @property {Color} */
         colorStart: Color;
-        /** @property {Color} - Color at end of life */
+        /** @property {Color} */
         colorEnd: Color;
-        /** @property {number} - How long to live for */
+        /** @property {number} */
         lifeTime: number;
-        /** @property {number} - Size at start of life */
+        /** @property {number} */
         sizeStart: number;
-        /** @property {number} - Size at end of life */
+        /** @property {number} */
         sizeEnd: number;
-        /** @property {number} - How quick to fade in/out */
-        fadeRate: number;
-        /** @property {boolean} - Is it additive */
-        additive: boolean;
-        /** @property {number} - If a trail, how long to make it */
-        trailScale: number;
-        /** @property {ParticleEmitter} - Parent emitter if local space */
-        localSpaceEmitter: ParticleEmitter;
-        /** @property {ParticleCallbackFunction} - Called when particle dies */
-        destroyCallback: ParticleCallbackFunction;
+        /** @property {Vector2} */
+        velocity: Vector2;
+        /** @property {number} */
+        angleVelocity: number;
+        /** @property {number} */
+        spawnTime: number;
+        /** @property {boolean} */
+        mirror: boolean;
+        /** @property {EngineObject} */
+        groundObject: TileCollisionLayer;
+        /** @property {boolean} */
+        destroyed: boolean;
+        /** @property {TileInfo} */
+        tileInfo: TileInfo;
+        /** Update the particle */
+        update(): void;
+        /** Destroy this particle */
+        destroy(): void;
+        /** Render the particle, automatically called each frame */
+        render(): void;
     }
     /**
      * LittleJS Medal System
@@ -3112,7 +3182,7 @@ declare module "littlejsengine" {
     export class PostProcessPlugin {
         /** Create global post processing shader
         *  @param {string} shaderCode
-        *  @param {boolean} [includeMainCanvas] - combine mainCanvs onto glCanvas
+        *  @param {boolean} [includeMainCanvas] - combine mainCanvas onto glCanvas
         *  @param {boolean} [feedbackTexture] - use glCanvas from previous frame as the texture
         *  @example
         *  // create the post process plugin object
@@ -3255,7 +3325,7 @@ declare module "littlejsengine" {
         nativeHeight: number;
         /** @property {UIObject} - Object currently selected by navigation (gamepad or keyboard) */
         navigationObject: any;
-        /** @property {Timer} - Cooldown timer for navigation inputs */
+        /** @property {Timer} - Cool down timer for navigation inputs */
         navigationTimer: Timer;
         /** @property {number} - Time between navigation inputs in seconds */
         navigationDelay: number;
@@ -3399,7 +3469,7 @@ declare module "littlejsengine" {
         lineWidth: number;
         /** @property {number} - Corner radius for rounded rects */
         cornerRadius: number;
-        /** @property {string} - Font for this objecct */
+        /** @property {string} - Font for this object */
         font: string;
         /** @property {string} - Font style for this object or undefined */
         fontStyle: any;
@@ -3591,6 +3661,8 @@ declare module "littlejsengine" {
         value: number;
         /** @property {Color} - Color for the handle part of the scrollbar */
         handleColor: Color;
+        /** @property {boolean} - Should it fill up like a progress bar? */
+        fillMode: boolean;
         text: string;
     }
     /**
@@ -3598,7 +3670,7 @@ declare module "littlejsengine" {
      * @extends UIObject
      * @example
      * // Create a video player UI object
-     * const video = new VideoPlayerUIObject(vec2(400, 300), vec2(320, 240), 'cutscene.mp4', true);
+     * const video = new VideoPlayerUIObject(vec2(400, 300), vec2(320, 240), 'video.mp4', true);
      * video.play();
      * @memberof UISystem
      */
@@ -3797,6 +3869,8 @@ declare module "littlejsengine" {
         edgeLists: any[];
         /** @property {Array<Object>} - List of all edge loops for default box2d drawing */
         edgeLoops: any[];
+        /** Destroy this object and its physics body */
+        destroy(): void;
         /** Draws all this object's fixtures
          *  @param {Color}   [color]
          *  @param {Color}   [lineColor]
@@ -4008,11 +4082,11 @@ declare module "littlejsengine" {
         constructor(pos?: Vector2, size?: Vector2, tileInfo?: TileInfo, angle?: number, color?: Color, renderOrder?: number);
     }
     /**
-     * Box2D Kiematic Object - Box2d with a kinematic physics body
+     * Box2D Kinematic Object - Box2d with a kinematic physics body
      * @extends Box2dObject
      * @memberof Box2D
      */
-    export class Box2dKiematicObject extends Box2dObject {
+    export class Box2dKinematicObject extends Box2dObject {
         /** Create a LittleJS object with Box2d physics
          *  @param {Vector2}  [pos]
          *  @param {Vector2}  [size]
@@ -4022,6 +4096,24 @@ declare module "littlejsengine" {
          *  @param {number}   [renderOrder] */
         constructor(pos?: Vector2, size?: Vector2, tileInfo?: TileInfo, angle?: number, color?: Color, renderOrder?: number);
     }
+    /**
+     * Box2d Tile Layer
+     * - adds Box2d support to tile layers
+     * - creates static box2d fixtures for solid tiles
+     * @extends Box2dObject
+     * @memberof Box2D
+     */
+    export class Box2dTileLayer extends Box2dObject {
+        /** Create a Box2d tile layer object
+        *  @param {TileCollisionLayer} tileLayer - Tile layer for this object */
+        constructor(tileLayer: TileCollisionLayer);
+        /** @property {TileLayer} - The tile layer */
+        tileLayer: TileCollisionLayer;
+        /** Create box2d collision fixtures for solid tiles
+        *  @param {number} [friction]
+        *  @param {number} [restitution] */
+        buildCollision(friction?: number, restitution?: number): void;
+    }
     /**
      * Box2D Raycast Result
      * - Holds results from a box2d raycast queries