littlejsengine 1.7.21 → 1.8.3

package/build/littlejs.d.ts

@@ -1,160 +1,188 @@
 declare module "littlejs.esm" {
     /**
-     * LittleJS Module Export
-     * - Export engine as a module with functions where necessary
+     * LittleJS - The Tiny JavaScript Game Engine That Can!
+     * MIT License - Copyright 2021 Frank Force
+     *
+     * Engine Features
+     * - Object oriented system with base class engine object
+     * - Base class object handles update, physics, collision, rendering, etc
+     * - Engine helper classes and functions like Vector2, Color, and Timer
+     * - Super fast rendering system for tile sheets
+     * - Sound effects audio with zzfx and music with zzfxm
+     * - Input processing system with gamepad and touchscreen support
+     * - Tile layer rendering and collision system
+     * - Particle effect system
+     * - Medal system tracks and displays achievements
+     * - Debug tools and debug rendering system
+     * - Post processing effects
+     * - Call engineInit() to start it up!
+     * @namespace Engine
      */
-    /** Set position of camera in world space
+    /** Name of engine
+     *  @type {String}
+     *  @default
+     *  @memberof Engine */
+    export const engineName: string;
+    /** Version of engine
+     *  @type {String}
+     *  @default
+     *  @memberof Engine */
+    export const engineVersion: string;
+    /** Frames per second to update objects
+     *  @type {Number}
+     *  @default
+     *  @memberof Engine */
+    export const frameRate: number;
+    /** How many seconds each frame lasts, engine uses a fixed time step
+     *  @type {Number}
+     *  @default 1/60
+     *  @memberof Engine */
+    export const timeDelta: number;
+    /** Array containing all engine objects
+     *  @type {Array}
+     *  @memberof Engine */
+    export let engineObjects: any[];
+    /** Current update frame, used to calculate time
+     *  @type {Number}
+     *  @memberof Engine */
+    export let frame: number;
+    /** Current engine time since start in seconds, derived from frame
+     *  @type {Number}
+     *  @memberof Engine */
+    export let time: number;
+    /** Actual clock time since start in seconds (not affected by pause or frame rate clamping)
+     *  @type {Number}
+     *  @memberof Engine */
+    export let timeReal: number;
+    /** Is the game paused? Causes time and objects to not be updated
+     *  @type {Boolean}
+     *  @default 0
+     *  @memberof Engine */
+    export let paused: boolean;
+    /** Set if game is paused
+     *  @param {Boolean} paused
+     *  @memberof Engine */
+    export function setPaused(_paused: any): void;
+    /** Start up LittleJS engine with your callback functions
+     *  @param {Function} gameInit        - Called once after the engine starts up, setup the game
+     *  @param {Function} gameUpdate      - Called every frame at 60 frames per second, handle input and update the game state
+     *  @param {Function} gameUpdatePost  - Called after physics and objects are updated, setup camera and prepare for render
+     *  @param {Function} gameRender      - Called before objects are rendered, draw any background effects that appear behind objects
+     *  @param {Function} gameRenderPost  - Called after objects are rendered, draw effects or hud that appear above all objects
+     *  @param {Array} [imageSources=['tiles.png']] - Image to load
+     *  @memberof Engine */
+    export function engineInit(gameInit: Function, gameUpdate: Function, gameUpdatePost: Function, gameRender: Function, gameRenderPost: Function, imageSources?: any[]): void;
+    /** Update each engine object, remove destroyed objects, and update time
+     *  @memberof Engine */
+    export function engineObjectsUpdate(): void;
+    /** Destroy and remove all objects
+     *  @memberof Engine */
+    export function engineObjectsDestroy(): void;
+    /** Triggers a callback for each object within a given area
+     *  @param {Vector2} [pos]                 - Center of test area
+     *  @param {Number} [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
+     *  @memberof Engine */
+    export function engineObjectsCallback(pos?: Vector2, size?: number, callbackFunction?: Function, objects?: any[]): void;
+    /**
+     * LittleJS Debug System
+     * - Press Esc to show debug overlay with mouse pick
+     * - Number keys toggle debug functions
+     * - +/- apply time scale
+     * - Debug primitive rendering
+     * - Save a 2d canvas as a png image
+     * @namespace Debug
+     */
+    /** True if debug is enabled
+     *  @type {Boolean}
+     *  @default
+     *  @memberof Debug */
+    export const debug: boolean;
+    /** True if watermark with FPS should be shown, false in release builds
+     *  @type {Boolean}
+     *  @default
+     *  @memberof Debug */
+    export let showWatermark: boolean;
+    /** Asserts if the experssion is false, does not do anything in release builds
+     *  @param {Boolean} assertion
+     *  @param {Object}  output
+     *  @memberof Debug */
+    export function ASSERT(...assert: any[]): void;
+    /** Draw a debug rectangle in world space
      *  @param {Vector2} pos
-     *  @memberof Settings */
-    export function setCameraPos(pos: Vector2): void;
-    /** Set scale of camera in world space
-     *  @param {Number} scale
-     *  @memberof Settings */
-    export function setCameraScale(scale: number): void;
-    /** Set max size of the canvas
-     *  @param {Vector2} size
-     *  @memberof Settings */
-    export function setCanvasMaxSize(size: Vector2): void;
-    /** Set fixed size of the canvas
-     *  @param {Vector2} size
-     *  @memberof Settings */
-    export function setCanvasFixedSize(size: Vector2): void;
-    /** Disables anti aliasing for pixel art if true
-     *  @param {Boolean} pixelated
-     *  @memberof Settings */
-    export function setCanvasPixelated(pixelated: boolean): void;
-    /** Set default font used for text rendering
-     *  @param {String} font
-     *  @memberof Settings */
-    export function setFontDefault(font: string): void;
-    /** Set if webgl rendering is enabled
-     *  @param {Boolean} enable
-     *  @memberof Settings */
-    export function setGlEnable(enable: boolean): void;
-    /** Set to not composite the WebGL canvas
-     *  @param {Boolean} overlay
-     *  @memberof Settings */
-    export function setGlOverlay(overlay: boolean): void;
-    /** Set default size of tiles in pixels
-     *  @param {Vector2} size
-     *  @memberof Settings */
-    export function setTileSizeDefault(size: Vector2): void;
-    /** Set to prevent tile bleeding from neighbors in pixels
-     *  @param {Number} scale
-     *  @memberof Settings */
-    export function setTileFixBleedScale(scale: number): void;
-    /** Set if collisions between objects are enabled
-     *  @param {Boolean} enable
-     *  @memberof Settings */
-    export function setEnablePhysicsSolver(enable: boolean): void;
-    /** Set default object mass for collison calcuations
-     *  @param {Number} mass
-     *  @memberof Settings */
-    export function setObjectDefaultMass(mass: number): void;
-    /** Set how much to slow velocity by each frame
-     *  @param {Number} damping
-     *  @memberof Settings */
-    export function setObjectDefaultDamping(damp: any): void;
-    /** Set how much to slow angular velocity each frame
-     *  @param {Number} damping
-     *  @memberof Settings */
-    export function setObjectDefaultAngleDamping(damp: any): void;
-    /** Set how much to bounce when a collision occur
-     *  @param {Number} elasticity
-     *  @memberof Settings */
-    export function setObjectDefaultElasticity(elasticity: number): void;
-    /** Set how much to slow when touching
-     *  @param {Number} friction
-     *  @memberof Settings */
-    export function setObjectDefaultFriction(friction: number): void;
-    /** Set max speed to avoid fast objects missing collisions
-     *  @param {Number} speed
-     *  @memberof Settings */
-    export function setObjectMaxSpeed(speed: number): void;
-    /** Set how much gravity to apply to objects along the Y axis
-     *  @param {Number} gravity
-     *  @memberof Settings */
-    export function setGravity(g: any): void;
-    /** Set to scales emit rate of particles
-     *  @param {Number} scale
-     *  @memberof Settings */
-    export function setParticleEmitRateScale(scale: number): void;
-    /** Set if gamepads are enabled
-     *  @param {Boolean} enable
-     *  @memberof Settings */
-    export function setGamepadsEnable(enable: boolean): void;
-    /** Set if the dpad input is also routed to the left analog stick
-     *  @param {Boolean} enable
-     *  @memberof Settings */
-    export function setGamepadDirectionEmulateStick(enable: boolean): void;
-    /** Set if true the WASD keys are also routed to the direction keys
-     *  @param {Boolean} enable
-     *  @memberof Settings */
-    export function setInputWASDEmulateDirection(enable: boolean): void;
-    /** Set if touch gamepad should appear on mobile devices
-     *  @param {Boolean} enable
-     *  @memberof Settings */
-    export function setTouchGamepadEnable(enable: boolean): void;
-    /** Set if touch gamepad should be analog stick or 8 way dpad
-     *  @param {Boolean} analog
-     *  @memberof Settings */
-    export function setTouchGamepadAnalog(analog: boolean): void;
-    /** Set size of virutal gamepad for touch devices in pixels
-     *  @param {Number} size
-     *  @memberof Settings */
-    export function setTouchGamepadSize(size: number): void;
-    /** Set transparency of touch gamepad overlay
-     *  @param {Number} alpha
-     *  @memberof Settings */
-    export function setTouchGamepadAlpha(alpha: number): void;
-    /** Set to allow vibration hardware if it exists
-     *  @param {Boolean} enable
-     *  @memberof Settings */
-    export function setVibrateEnable(enable: boolean): void;
-    /** Set to disable all audio code
-     *  @param {Boolean} enable
-     *  @memberof Settings */
-    export function setSoundEnable(enable: boolean): void;
-    /** Set volume scale to apply to all sound, music and speech
-     *  @param {Number} volume
-     *  @memberof Settings */
-    export function setSoundVolume(volume: number): void;
-    /** Set default range where sound no longer plays
-     *  @param {Number} range
-     *  @memberof Settings */
-    export function setSoundDefaultRange(range: number): void;
-    /** Set default range percent to start tapering off sound
-     *  @param {Number} taper
-     *  @memberof Settings */
-    export function setSoundDefaultTaper(taper: number): void;
-    /** Set how long to show medals for in seconds
-     *  @param {Number} time
-     *  @memberof Settings */
-    export function setMedalDisplayTime(time: number): void;
-    /** Set how quickly to slide on/off medals in seconds
-     *  @param {Number} time
-     *  @memberof Settings */
-    export function setMedalDisplaySlideTime(time: number): void;
-    /** Set size of medal display
-     *  @param {Vector2} size
-     *  @memberof Settings */
-    export function setMedalDisplaySize(size: Vector2): void;
-    /** Set size of icon in medal display
-     *  @param {Number} size
-     *  @memberof Settings */
-    export function setMedalDisplayIconSize(size: number): void;
-    /** Set to stop medals from being unlockable
-     *  @param {Boolean} preventUnlock
-     *  @memberof Settings */
-    export function setMedalsPreventUnlock(preventUnlock: boolean): void;
-    /** Set if watermark with FPS should be shown
-     *  @param {Boolean} show
+     *  @param {Vector2} [size=Vector2()]
+     *  @param {String}  [color='#fff']
+     *  @param {Number}  [time=0]
+     *  @param {Number}  [angle=0]
+     *  @param {Boolean} [fill=false]
      *  @memberof Debug */
-    export function setShowWatermark(show: boolean): void;
-    /** Set key code used to toggle debug mode, Esc by default
-     *  @param {Number} key
+    export function debugRect(pos: Vector2, size?: Vector2, color?: string, time?: number, angle?: number, fill?: boolean): void;
+    /** Draw a debug circle in world space
+     *  @param {Vector2} pos
+     *  @param {Number}  [radius=0]
+     *  @param {String}  [color='#fff']
+     *  @param {Number}  [time=0]
+     *  @param {Boolean} [fill=false]
      *  @memberof Debug */
-    export function setDebugKey(key: number): void;
+    export function debugCircle(pos: Vector2, radius?: number, color?: string, time?: number, fill?: boolean): void;
+    /** Draw a debug point in world space
+     *  @param {Vector2} pos
+     *  @param {String}  [color='#fff']
+     *  @param {Number}  [time=0]
+     *  @param {Number}  [angle=0]
+     *  @memberof Debug */
+    export function debugPoint(pos: Vector2, color?: string, time?: number, angle?: number): void;
+    /** Draw a debug line in world space
+     *  @param {Vector2} posA
+     *  @param {Vector2} posB
+     *  @param {String}  [color='#fff']
+     *  @param {Number}  [thickness=.1]
+     *  @param {Number}  [time=0]
+     *  @memberof Debug */
+    export function debugLine(posA: Vector2, posB: Vector2, color?: string, thickness?: number, time?: number): void;
+    /** Draw a debug axis aligned bounding box in world space
+     *  @param {Vector2} posA
+     *  @param {Vector2} sizeA
+     *  @param {Vector2} posB
+     *  @param {Vector2} sizeB
+     *  @param {String}  [color='#fff']
+     *  @memberof Debug */
+    export function debugAABB(pA: any, sA: any, pB: any, sB: any, color?: string): void;
+    /** Draw a debug axis aligned bounding box in world space
+     *  @param {String}  text
+     *  @param {Vector2} pos
+     *  @param {Number}  [size=1]
+     *  @param {String}  [color='#fff']
+     *  @param {Number}  [time=0]
+     *  @param {Number}  [angle=0]
+     *  @param {String}  [font='monospace']
+     *  @memberof Debug */
+    export function debugText(text: string, pos: Vector2, size?: number, color?: string, time?: number, angle?: number, font?: string): void;
+    /** Clear all debug primitives in the list
+     *  @memberof Debug */
+    export function debugClear(): void;
+    /** Save a canvas to disk
+     *  @param {HTMLCanvasElement} canvas
+     *  @param {String}            [filename]
+     *  @param {String}            [type='image/png']
+     *  @memberof Debug */
+    export function debugSaveCanvas(canvas: HTMLCanvasElement, filename?: string, type?: string): void;
+    /**
+     * LittleJS Engine Settings
+     * - All settings for the engine are here
+     * @namespace Settings
+     */
+    /** Position of camera in world space
+     *  @type {Vector2}
+     *  @default Vector2()
+     *  @memberof Settings */
+    export let cameraPos: Vector2;
+    /** Scale of camera in world space
+     *  @type {Number}
+     *  @default
+     *  @memberof Settings */
+    export let cameraScale: number;
     /** The max size of the canvas, centered if window is larger
      *  @type {Vector2}
      *  @default Vector2(1920,1200)
@@ -181,7 +209,7 @@ declare module "littlejs.esm" {
      *  @default Vector2(16,16)
      *  @memberof Settings */
     export let tileSizeDefault: Vector2;
-    /** Prevent tile bleeding from neighbors in pixels
+    /** How many pixels smaller to draw tiles to prevent bleeding from neighbors
      *  @type {Number}
      *  @default
      *  @memberof Settings */
@@ -231,21 +259,6 @@ declare module "littlejs.esm" {
      *  @default
      *  @memberof Settings */
     export let particleEmitRateScale: number;
-    /**
-     * LittleJS Engine Settings
-     * - All settings for the engine are here
-     * @namespace Settings
-     */
-    /** Position of camera in world space
-     *  @type {Vector2}
-     *  @default Vector2()
-     *  @memberof Settings */
-    export let cameraPos: Vector2;
-    /** Scale of camera in world space
-     *  @type {Number}
-     *  @default
-     *  @memberof Settings */
-    export let cameraScale: number;
     /** Enable webgl rendering, webgl can be disabled and removed from build (with some features disabled)
      *  @type {Boolean}
      *  @default
@@ -327,100 +340,169 @@ declare module "littlejs.esm" {
      *  @type {Number}
      *  @default
      *  @memberof Settings */
-    export let medalDisplaySlideTime: number;
-    /** Size of medal display
-     *  @type {Vector2}
-     *  @default Vector2(640,80)
+    export let medalDisplaySlideTime: number;
+    /** Size of medal display
+     *  @type {Vector2}
+     *  @default Vector2(640,80)
+     *  @memberof Settings */
+    export let medalDisplaySize: Vector2;
+    /** Size of icon in medal display
+     *  @type {Number}
+     *  @default
+     *  @memberof Settings */
+    export let medalDisplayIconSize: number;
+    /** Set position of camera in world space
+     *  @param {Vector2} pos
+     *  @memberof Settings */
+    export function setCameraPos(pos: Vector2): void;
+    /** Set scale of camera in world space
+     *  @param {Number} scale
+     *  @memberof Settings */
+    export function setCameraScale(scale: number): void;
+    /** Set max size of the canvas
+     *  @param {Vector2} size
+     *  @memberof Settings */
+    export function setCanvasMaxSize(size: Vector2): void;
+    /** Set fixed size of the canvas
+     *  @param {Vector2} size
+     *  @memberof Settings */
+    export function setCanvasFixedSize(size: Vector2): void;
+    /** Disables anti aliasing for pixel art if true
+     *  @param {Boolean} pixelated
+     *  @memberof Settings */
+    export function setCanvasPixelated(pixelated: boolean): void;
+    /** Set default font used for text rendering
+     *  @param {String} font
+     *  @memberof Settings */
+    export function setFontDefault(font: string): void;
+    /** Set if webgl rendering is enabled
+     *  @param {Boolean} enable
+     *  @memberof Settings */
+    export function setGlEnable(enable: boolean): void;
+    /** Set to not composite the WebGL canvas
+     *  @param {Boolean} overlay
+     *  @memberof Settings */
+    export function setGlOverlay(overlay: boolean): void;
+    /** Set default size of tiles in pixels
+     *  @param {Vector2} size
+     *  @memberof Settings */
+    export function setTileSizeDefault(size: Vector2): void;
+    /** Set to prevent tile bleeding from neighbors in pixels
+     *  @param {Number} scale
+     *  @memberof Settings */
+    export function setTileFixBleedScale(scale: number): void;
+    /** Set if collisions between objects are enabled
+     *  @param {Boolean} enable
+     *  @memberof Settings */
+    export function setEnablePhysicsSolver(enable: boolean): void;
+    /** Set default object mass for collison calcuations
+     *  @param {Number} mass
+     *  @memberof Settings */
+    export function setObjectDefaultMass(mass: number): void;
+    /** Set how much to slow velocity by each frame
+     *  @param {Number} damping
+     *  @memberof Settings */
+    export function setObjectDefaultDamping(damp: any): void;
+    /** Set how much to slow angular velocity each frame
+     *  @param {Number} damping
+     *  @memberof Settings */
+    export function setObjectDefaultAngleDamping(damp: any): void;
+    /** Set how much to bounce when a collision occur
+     *  @param {Number} elasticity
+     *  @memberof Settings */
+    export function setObjectDefaultElasticity(elasticity: number): void;
+    /** Set how much to slow when touching
+     *  @param {Number} friction
+     *  @memberof Settings */
+    export function setObjectDefaultFriction(friction: number): void;
+    /** Set max speed to avoid fast objects missing collisions
+     *  @param {Number} speed
+     *  @memberof Settings */
+    export function setObjectMaxSpeed(speed: number): void;
+    /** Set how much gravity to apply to objects along the Y axis
+     *  @param {Number} gravity
+     *  @memberof Settings */
+    export function setGravity(g: any): void;
+    /** Set to scales emit rate of particles
+     *  @param {Number} scale
+     *  @memberof Settings */
+    export function setParticleEmitRateScale(scale: number): void;
+    /** Set if gamepads are enabled
+     *  @param {Boolean} enable
+     *  @memberof Settings */
+    export function setGamepadsEnable(enable: boolean): void;
+    /** Set if the dpad input is also routed to the left analog stick
+     *  @param {Boolean} enable
+     *  @memberof Settings */
+    export function setGamepadDirectionEmulateStick(enable: boolean): void;
+    /** Set if true the WASD keys are also routed to the direction keys
+     *  @param {Boolean} enable
+     *  @memberof Settings */
+    export function setInputWASDEmulateDirection(enable: boolean): void;
+    /** Set if touch gamepad should appear on mobile devices
+     *  @param {Boolean} enable
+     *  @memberof Settings */
+    export function setTouchGamepadEnable(enable: boolean): void;
+    /** Set if touch gamepad should be analog stick or 8 way dpad
+     *  @param {Boolean} analog
+     *  @memberof Settings */
+    export function setTouchGamepadAnalog(analog: boolean): void;
+    /** Set size of virutal gamepad for touch devices in pixels
+     *  @param {Number} size
+     *  @memberof Settings */
+    export function setTouchGamepadSize(size: number): void;
+    /** Set transparency of touch gamepad overlay
+     *  @param {Number} alpha
+     *  @memberof Settings */
+    export function setTouchGamepadAlpha(alpha: number): void;
+    /** Set to allow vibration hardware if it exists
+     *  @param {Boolean} enable
+     *  @memberof Settings */
+    export function setVibrateEnable(enable: boolean): void;
+    /** Set to disable all audio code
+     *  @param {Boolean} enable
+     *  @memberof Settings */
+    export function setSoundEnable(enable: boolean): void;
+    /** Set volume scale to apply to all sound, music and speech
+     *  @param {Number} volume
+     *  @memberof Settings */
+    export function setSoundVolume(volume: number): void;
+    /** Set default range where sound no longer plays
+     *  @param {Number} range
+     *  @memberof Settings */
+    export function setSoundDefaultRange(range: number): void;
+    /** Set default range percent to start tapering off sound
+     *  @param {Number} taper
+     *  @memberof Settings */
+    export function setSoundDefaultTaper(taper: number): void;
+    /** Set how long to show medals for in seconds
+     *  @param {Number} time
+     *  @memberof Settings */
+    export function setMedalDisplayTime(time: number): void;
+    /** Set how quickly to slide on/off medals in seconds
+     *  @param {Number} time
+     *  @memberof Settings */
+    export function setMedalDisplaySlideTime(time: number): void;
+    /** Set size of medal display
+     *  @param {Vector2} size
      *  @memberof Settings */
-    export let medalDisplaySize: Vector2;
-    /** Size of icon in medal display
-     *  @type {Number}
-     *  @default
+    export function setMedalDisplaySize(size: Vector2): void;
+    /** Set size of icon in medal display
+     *  @param {Number} size
      *  @memberof Settings */
-    export let medalDisplayIconSize: number;
-    /**
-     * LittleJS Debug System
-     * - Press Esc to show debug overlay with mouse pick
-     * - Number keys toggle debug functions
-     * - +/- apply time scale
-     * - Debug primitive rendering
-     * - Save a 2d canvas as a png image
-     * @namespace Debug
-     */
-    /** True if debug is enabled
-     *  @type {Boolean}
-     *  @default
-     *  @memberof Debug */
-    export const debug: boolean;
-    /** True if watermark with FPS should be shown, false in release builds
-     *  @type {Boolean}
-     *  @default
-     *  @memberof Debug */
-    export let showWatermark: boolean;
-    /** Asserts if the experssion is false, does not do anything in release builds
-     *  @param {Boolean} assertion
-     *  @param {Object}  output
-     *  @memberof Debug */
-    export function ASSERT(...assert: any[]): void;
-    /** Draw a debug rectangle in world space
-     *  @param {Vector2} pos
-     *  @param {Vector2} [size=Vector2()]
-     *  @param {String}  [color='#fff']
-     *  @param {Number}  [time=0]
-     *  @param {Number}  [angle=0]
-     *  @param {Boolean} [fill=false]
-     *  @memberof Debug */
-    export function debugRect(pos: Vector2, size?: Vector2, color?: string, time?: number, angle?: number, fill?: boolean): void;
-    /** Draw a debug circle in world space
-     *  @param {Vector2} pos
-     *  @param {Number}  [radius=0]
-     *  @param {String}  [color='#fff']
-     *  @param {Number}  [time=0]
-     *  @param {Boolean} [fill=false]
-     *  @memberof Debug */
-    export function debugCircle(pos: Vector2, radius?: number, color?: string, time?: number, fill?: boolean): void;
-    /** Draw a debug point in world space
-     *  @param {Vector2} pos
-     *  @param {String}  [color='#fff']
-     *  @param {Number}  [time=0]
-     *  @param {Number}  [angle=0]
-     *  @memberof Debug */
-    export function debugPoint(pos: Vector2, color?: string, time?: number, angle?: number): void;
-    /** Draw a debug line in world space
-     *  @param {Vector2} posA
-     *  @param {Vector2} posB
-     *  @param {String}  [color='#fff']
-     *  @param {Number}  [thickness=.1]
-     *  @param {Number}  [time=0]
-     *  @memberof Debug */
-    export function debugLine(posA: Vector2, posB: Vector2, color?: string, thickness?: number, time?: number): void;
-    /** Draw a debug axis aligned bounding box in world space
-     *  @param {Vector2} posA
-     *  @param {Vector2} sizeA
-     *  @param {Vector2} posB
-     *  @param {Vector2} sizeB
-     *  @param {String}  [color='#fff']
-     *  @memberof Debug */
-    export function debugAABB(pA: any, sA: any, pB: any, sB: any, color?: string): void;
-    /** Draw a debug axis aligned bounding box in world space
-     *  @param {String}  text
-     *  @param {Vector2} pos
-     *  @param {Number}  [size=1]
-     *  @param {String}  [color='#fff']
-     *  @param {Number}  [time=0]
-     *  @param {Number}  [angle=0]
-     *  @param {String}  [font='monospace']
-     *  @memberof Debug */
-    export function debugText(text: string, pos: Vector2, size?: number, color?: string, time?: number, angle?: number, font?: string): void;
-    /** Clear all debug primitives in the list
+    export function setMedalDisplayIconSize(size: number): void;
+    /** Set to stop medals from being unlockable
+     *  @param {Boolean} preventUnlock
+     *  @memberof Settings */
+    export function setMedalsPreventUnlock(preventUnlock: boolean): void;
+    /** Set if watermark with FPS should be shown
+     *  @param {Boolean} show
      *  @memberof Debug */
-    export function debugClear(): void;
-    /** Save a canvas to disk
-     *  @param {HTMLCanvasElement} canvas
-     *  @param {String}            [filename]
-     *  @param {String}            [type='image/png']
+    export function setShowWatermark(show: boolean): void;
+    /** Set key code used to toggle debug mode, Esc by default
+     *  @param {Number} key
      *  @memberof Debug */
-    export function debugSaveCanvas(canvas: HTMLCanvasElement, filename?: string, type?: string): void;
+    export function setDebugKey(key: number): void;
     /**
      * LittleJS Utility Classes and Functions
      * - General purpose math library
@@ -583,10 +665,10 @@ declare module "littlejs.esm" {
      * - Can be used to create a deterministic random number sequence
      * @example
      * let r = new RandomGenerator(123); // random number generator with seed 123
-     * let a = r.rand();                 // random value between 0 and 1
-     * let b = r.randInt(10);            // random integer between 0 and 9
+     * let a = r.float();                // random value between 0 and 1
+     * let b = r.int(10);                // random integer between 0 and 9
      * r.seed = 123;                     // reset the seed
-     * let c = r.rand();                 // the same value as a
+     * let c = r.float();                // the same value as a
      */
     export class RandomGenerator {
         /** Create a random number generator with the seed passed in
@@ -844,7 +926,7 @@ declare module "littlejs.esm" {
     }
     /**
      * Create a 2d vector, can take another Vector2 to copy, 2 scalars, or 1 scalar
-     * @param {Number} [x=0]
+     * @param {(Number|Vector2)} [x=0]
      * @param {Number} [y=0]
      * @return {Vector2}
      * @example
@@ -854,7 +936,7 @@ declare module "littlejs.esm" {
      * b = vec2();         // set b to (0, 0)
      * @memberof Utilities
      */
-    export function vec2(x?: number, y?: number): Vector2;
+    export function vec2(x?: (number | Vector2), y?: number): Vector2;
     /**
      * Create a color object with RGBA values
      * @param {Number} [r=1] - red
@@ -875,136 +957,64 @@ declare module "littlejs.esm" {
      * @memberof Utilities
      */
     export function hsl(h?: number, s?: number, l?: number, a?: number): Color;
+    /** Array containing texture info for batch rendering system
+     *  @type {Array}
+     *  @memberof Draw */
+    export let textureInfos: any[];
     /**
-     * LittleJS Object System
+     * Create a tile info object
+     * - This can take vecs or floats for easier use and conversion
+     * - If an index is passed in, the tile size and index will determine the position
+     * @param {(Number|Vector2)} [pos=Vector2()]         - Top left corner of tile in pixels or index
+     * @param {(Number|Vector2)} [size=tileSizeDefault]  - Size of tile in pixels
+     * @param {Number} [textureIndex=0]                  - Texture index to use
+     * @return {TileInfo}
+     * @example
+     * tile(2)                       // a tile at index 2 using the default tile size of 16
+     * tile(5, 8)                    // a tile at index 5 using a tile size of 8
+     * tile(1, 16, 3)                // a tile at index 1 of size 16 on texture 3
+     * tile(vec2(4,8), vec2(30,10))  // a tile at pixel location (4,8) with a size of (30,10)
+     * @memberof Draw
      */
+    export function tile(pos?: (number | Vector2), size?: (number | Vector2), textureIndex?: number): TileInfo;
     /**
-     * LittleJS Object Base Object Class
-     * - Top level object class used by the engine
-     * - Automatically adds self to object list
-     * - Will be updated and rendered each frame
-     * - Renders as a sprite from a tilesheet by default
-     * - Can have color and addtive color applied
-     * - 2D Physics and collision system
-     * - Sorted by renderOrder
-     * - Objects can have children attached
-     * - Parents are updated before children, and set child transform
-     * - Call destroy() to get rid of objects
-     *
-     * The physics system used by objects is simple and fast with some caveats...
-     * - Collision uses the axis aligned size, the object's rotation angle is only for rendering
-     * - Objects are guaranteed to not intersect tile collision from physics
-     * - If an object starts or is moved inside tile collision, it will not collide with that tile
-     * - Collision for objects can be set to be solid to block other objects
-     * - Objects may get pushed into overlapping other solid objects, if so they will push away
-     * - Solid objects are more performance intensive and should be used sparingly
-     * @example
-     * // create an engine object, normally you would first extend the class with your own
-     * const pos = vec2(2,3);
-     * const object = new EngineObject(pos);
+     * Tile Info - Stores info about how to draw a tile
      */
-    export class EngineObject {
-        /** Create an engine object and adds it to the list of objects
-         *  @param {Vector2} [position=Vector2()]        - World space position of the object
-         *  @param {Vector2} [size=Vector2(1,1)]         - World space size of the object
-         *  @param {Number}  [tileIndex=-1]              - Tile to use to render object (-1 is untextured)
-         *  @param {Vector2} [tileSize=tileSizeDefault]  - Size of tile in source pixels
-         *  @param {Number}  [angle=0]                   - Angle the object is rotated by
-         *  @param {Color}   [color=Color()]             - Color to apply to tile when rendered
-         *  @param {Number}  [renderOrder=0]             - Objects sorted by renderOrder before being rendered
+    export class TileInfo {
+        /** Create a tile info object
+         *  @param {Vector2} [pos=Vector2()]        - Top left corner of tile in pixels
+         *  @param {Vector2} [size=tileSizeDefault] - Size of tile in pixels
+         *  @param {Number}  [textureIndex=0]       - Texture index to use
          */
-        constructor(pos?: Vector2, size?: Vector2, tileIndex?: number, tileSize?: Vector2, angle?: number, color?: Color, renderOrder?: number);
-        /** @property {Vector2} - World space position of the object */
+        constructor(pos?: Vector2, size?: Vector2, textureIndex?: number);
+        /** @property {Vector2} - Top left corner of tile in pixels */
         pos: Vector2;
-        /** @property {Vector2} - World space width and height of the object */
+        /** @property {Vector2} - Size of tile in pixels */
         size: Vector2;
-        /** @property {Number}  - Tile to use to render object (-1 is untextured) */
-        tileIndex: number;
-        /** @property {Vector2} - Size of tile in source pixels */
-        tileSize: Vector2;
-        /** @property {Number}  - Angle to rotate the object */
-        angle: number;
-        /** @property {Color}   - Color to apply when rendered */
-        color: Color;
-        /** @property {Number} [mass=objectDefaultMass]                 - How heavy the object is, static if 0 */
-        mass: number;
-        /** @property {Number} [damping=objectDefaultDamping]           - 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) */
-        angleDamping: number;
-        /** @property {Number} [elasticity=objectDefaultElasticity]     - How bouncy the object is when colliding (0-1) */
-        elasticity: number;
-        /** @property {Number} [friction=objectDefaultFriction]         - How much friction to apply when sliding (0-1) */
-        friction: number;
-        /** @property {Number} [gravityScale=1]                         - How much to scale gravity by for this object */
-        gravityScale: number;
-        /** @property {Number} [renderOrder=0]                          - Objects are sorted by render order */
-        renderOrder: number;
-        /** @property {Vector2} [velocity=Vector2()]                    - Velocity of the object */
-        velocity: Vector2;
-        /** @property {Number} [angleVelocity=0]                        - Angular velocity of the object */
-        angleVelocity: number;
-        spawnTime: number;
-        children: any[];
-        collideTiles: number;
-        /** Update the object transform and 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 */
-        render(): void;
-        /** Destroy this object, destroy it's children, detach it's parent, and mark it for removal */
-        destroy(): void;
-        destroyed: number;
-        /** Called to check if a tile collision should be resolved
-         *  @param {Number}  tileData - the value of the tile at the position
-         *  @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
-         */
-        collideWithObject(object: EngineObject): boolean;
-        /** How long since the object was created
-         *  @return {Number} */
-        getAliveTime(): number;
-        /** Apply acceleration to this object (adjust velocity, not affected by mass)
-         *  @param {Vector2} acceleration */
-        applyAcceleration(acceleration: Vector2): void;
-        /** Apply force to this object (adjust velocity, affected by mass)
-         *  @param {Vector2} force */
-        applyForce(force: Vector2): void;
-        /** Get the direction of the mirror
-         *  @return {Number} -1 if this.mirror is true, or 1 if not mirrored */
-        getMirrorSign(): number;
-        /** Attaches a child to this with a given local transform
-         *  @param {EngineObject} child
-         *  @param {Vector2}      [localPos=Vector2()]
-         *  @param {Number}       [localAngle=0] */
-        addChild(child: EngineObject, localPos?: Vector2, localAngle?: number): void;
-        /** Removes a child from this one
-         *  @param {EngineObject} child */
-        removeChild(child: EngineObject): void;
-        /** Set how this object collides
-         *  @param {Boolean} [collideSolidObjects=1] - Does it collide with solid objects
-         *  @param {Boolean} [isSolid=1]             - Does it collide with and block other objects (expensive in large numbers)
-         *  @param {Boolean} [collideTiles=1]        - Does it collide with the tile collision */
-        setCollision(collideSolidObjects?: boolean, isSolid?: boolean, collideTiles?: boolean): void;
-        collideSolidObjects: boolean;
-        isSolid: boolean;
-        /** Returns string containg info about this object for debugging
-         *  @return {String} */
-        toString(): string;
+        /** @property {Number} - Texture index to use */
+        textureIndex: number;
+        /** Returns an offset copy of this tile, useful for animation
+        *  @param {Vector2} offset - Offset to apply in pixels
+        *  @return {TileInfo}
+        */
+        offset(offset: Vector2): TileInfo;
+        /** Returns the texture info for this tile
+        *  @return {TextureInfo}
+        */
+        getTextureInfo(): TextureInfo;
+    }
+    /** Texture Info - Stores info about each texture */
+    export class TextureInfo {
+        constructor(image: any);
+        /** @property {CanvasImageSource} - image source */
+        image: any;
+        /** @property {Vector2} - size of the image */
+        size: Vector2;
+        /** @property {WebGLTexture} - webgl texture */
+        glTexture: WebGLTexture;
+        /** @property {Vector2} - size to adjust tile to fix bleeding */
+        fixBleedSize: Vector2;
     }
-    /** Tile sheet for batch rendering system
-     *  @type {CanvasImageSource}
-     *  @memberof Draw */
-    export const tileImage: CanvasImageSource;
     /**
      * LittleJS Drawing System
      * - Hybrid system with both Canvas2D and WebGL available
@@ -1059,7 +1069,7 @@ declare module "littlejs.esm" {
     /** Draw textured tile centered in world space, with color applied if using WebGL
      *  @param {Vector2} pos                            - Center of the tile in world space
      *  @param {Vector2} [size=Vector2(1,1)]            - Size of the tile in world space
-     *  @param {Number}  [tileIndex=-1]                 - Tile index to use, negative is untextured
+     *  @param {TileInfo}[tileInfo]                     - Tile info to use, untextured if undefined
      *  @param {Vector2} [tileSize=tileSizeDefault]     - Tile size in source pixels
      *  @param {Color}   [color=Color()]                - Color to modulate with
      *  @param {Number}  [angle=0]                      - Angle to rotate by
@@ -1067,8 +1077,9 @@ declare module "littlejs.esm" {
      *  @param {Color}   [additiveColor=Color(0,0,0,0)] - Additive color to be applied
      *  @param {Boolean} [useWebGL=glEnable]            - Use accelerated WebGL rendering
      *  @param {Boolean} [screenSpace=0]                - If true the pos and size are in screen space
+     *  @param {CanvasRenderingContext2D} [context]     - Canvas 2D context to draw to
      *  @memberof Draw */
-    export function drawTile(pos: Vector2, size?: Vector2, tileIndex?: number, tileSize?: Vector2, color?: Color, angle?: number, mirror?: boolean, additiveColor?: Color, useWebGL?: boolean, screenSpace?: boolean): void;
+    export function drawTile(pos: Vector2, size?: Vector2, tileInfo?: TileInfo, color?: Color, angle?: number, mirror?: boolean, additiveColor?: Color, useWebGL?: boolean, screenSpace?: boolean, context?: CanvasRenderingContext2D): void;
     /** Draw colored rect centered on pos
      *  @param {Vector2} pos
      *  @param {Vector2} [size=Vector2(1,1)]
@@ -1076,8 +1087,9 @@ declare module "littlejs.esm" {
      *  @param {Number}  [angle=0]
      *  @param {Boolean} [useWebGL=glEnable]
      *  @param {Boolean} [screenSpace=0]
+     *  @param {CanvasRenderingContext2D} [context]
      *  @memberof Draw */
-    export function drawRect(pos: Vector2, size?: Vector2, color?: Color, angle?: number, useWebGL?: boolean, screenSpace?: boolean): void;
+    export function drawRect(pos: Vector2, size?: Vector2, color?: Color, angle?: number, useWebGL?: boolean, screenSpace?: boolean, context?: CanvasRenderingContext2D): void;
     /** Draw colored line between two points
      *  @param {Vector2} posA
      *  @param {Vector2} posB
@@ -1085,23 +1097,25 @@ declare module "littlejs.esm" {
      *  @param {Color}   [color=Color()]
      *  @param {Boolean} [useWebGL=glEnable]
      *  @param {Boolean} [screenSpace=0]
+     *  @param {CanvasRenderingContext2D} [context]
      *  @memberof Draw */
-    export function drawLine(posA: Vector2, posB: Vector2, thickness?: number, color?: Color, useWebGL?: boolean, screenSpace?: boolean): void;
+    export function drawLine(posA: Vector2, posB: Vector2, thickness?: number, color?: Color, useWebGL?: boolean, screenSpace?: boolean, context?: CanvasRenderingContext2D): void;
     /** Draw directly to a 2d canvas context in world space
      *  @param {Vector2}  pos
      *  @param {Vector2}  size
      *  @param {Number}   angle
      *  @param {Boolean}  mirror
      *  @param {Function} drawFunction
-     *  @param {CanvasRenderingContext2D} [context=mainContext]
      *  @param {Boolean} [screenSpace=0]
+     *  @param {CanvasRenderingContext2D} [context=mainContext]
      *  @memberof Draw */
-    export function drawCanvas2D(pos: Vector2, size: Vector2, angle: number, mirror: boolean, drawFunction: Function, context?: CanvasRenderingContext2D, screenSpace?: boolean): void;
+    export function drawCanvas2D(pos: Vector2, size: Vector2, angle: number, mirror: boolean, drawFunction: Function, screenSpace?: boolean, context?: CanvasRenderingContext2D): void;
     /** Enable normal or additive blend mode
      *  @param {Boolean} [additive=0]
      *  @param {Boolean} [useWebGL=glEnable]
+     *  @param {CanvasRenderingContext2D} [context=mainContext]
      *  @memberof Draw */
-    export function setBlendMode(additive?: boolean, useWebGL?: boolean): void;
+    export function setBlendMode(additive?: boolean, useWebGL?: boolean, context?: CanvasRenderingContext2D): void;
     /** Draw text on overlay canvas in screen space
      *  Automatically splits new lines into rows
      *  @param {String}  text
@@ -1146,14 +1160,12 @@ declare module "littlejs.esm" {
          *  @param {HTMLImageElement} [image] - Image for the font, if undefined default font is used
          *  @param {Vector2} [tileSize=vec2(8)] - Size of the font source tiles
          *  @param {Vector2} [paddingSize=vec2(0,1)] - How much extra space to add between characters
-         *  @param {Number}  [startTileIndex=0] - Tile index in image where font starts
          *  @param {CanvasRenderingContext2D} [context=overlayContext] - context to draw to
          */
-        constructor(image?: HTMLImageElement, tileSize?: Vector2, paddingSize?: Vector2, startTileIndex?: number, context?: CanvasRenderingContext2D);
+        constructor(image?: HTMLImageElement, tileSize?: Vector2, paddingSize?: Vector2, context?: CanvasRenderingContext2D);
         image: any;
         tileSize: Vector2;
         paddingSize: Vector2;
-        startTileIndex: number;
         context: CanvasRenderingContext2D;
         /** Draw text in world space using the image font
          *  @param {String}  text
@@ -1177,6 +1189,52 @@ declare module "littlejs.esm" {
     /** Toggle fullsceen mode
      *  @memberof Draw */
     export function toggleFullscreen(): void;
+    /**
+     * LittleJS WebGL Interface
+     * - All webgl used by the engine is wrapped up here
+     * - For normal stuff you won't need to see or call anything in this file
+     * - For advanced stuff there are helper functions to create shaders, textures, etc
+     * - Can be disabled with glEnable to revert to 2D canvas rendering
+     * - Batches sprite rendering on GPU for incredibly fast performance
+     * - Sprite transform math is done in the shader where possible
+     * - Supports shadertoy style post processing shaders
+     * @namespace WebGL
+     */
+    /** The WebGL canvas which appears above the main canvas and below the overlay canvas
+     *  @type {HTMLCanvasElement}
+     *  @memberof WebGL */
+    export let glCanvas: HTMLCanvasElement;
+    /** 2d context for glCanvas
+     *  @type {WebGLRenderingContext}
+     *  @memberof WebGL */
+    export let glContext: WebGLRenderingContext;
+    /** Set the WebGl texture, called automatically if using multiple textures
+     *  - This may also flush the gl buffer resulting in more draw calls and worse performance
+     *  @param {WebGLTexture} texture
+     *  @memberof WebGL */
+    export function glSetTexture(texture: WebGLTexture): void;
+    /** Compile WebGL shader of the given type, will throw errors if in debug mode
+     *  @param {String} source
+     *  @param          type
+     *  @return {WebGLShader}
+     *  @memberof WebGL */
+    export function glCompileShader(source: string, type: any): WebGLShader;
+    /** Create WebGL program with given shaders
+     *  @param {WebGLShader} vsSource
+     *  @param {WebGLShader} fsSource
+     *  @return {WebGLProgram}
+     *  @memberof WebGL */
+    export function glCreateProgram(vsSource: WebGLShader, fsSource: WebGLShader): WebGLProgram;
+    /** Create WebGL texture from an image and set the texture settings
+     *  @param {Image} image
+     *  @return {WebGLTexture}
+     *  @memberof WebGL */
+    export function glCreateTexture(image: new (width?: number, height?: number) => HTMLImageElement): WebGLTexture;
+    /** Set up a post processing shader
+     *  @param {String} shaderCode
+     *  @param {Boolean} includeOverlay
+     *  @memberof WebGL */
+    export function glInitPostProcess(shaderCode: string, includeOverlay: boolean): void;
     /**
      * LittleJS Input System
      * - Tracks keyboard down, pressed, and released
@@ -1444,6 +1502,129 @@ declare module "littlejs.esm" {
      *  @return {AudioBufferSourceNode} - The audio node of the sound played
      *  @memberof Audio */
     export function zzfx(...zzfxSound: any[]): AudioBufferSourceNode;
+    /**
+     * LittleJS Object System
+     */
+    /**
+     * LittleJS Object Base Object Class
+     * - Top level object class used by the engine
+     * - Automatically adds self to object list
+     * - Will be updated and rendered each frame
+     * - Renders as a sprite from a tilesheet by default
+     * - Can have color and addtive color applied
+     * - 2D Physics and collision system
+     * - Sorted by renderOrder
+     * - Objects can have children attached
+     * - Parents are updated before children, and set child transform
+     * - Call destroy() to get rid of objects
+     *
+     * The physics system used by objects is simple and fast with some caveats...
+     * - Collision uses the axis aligned size, the object's rotation angle is only for rendering
+     * - Objects are guaranteed to not intersect tile collision from physics
+     * - If an object starts or is moved inside tile collision, it will not collide with that tile
+     * - Collision for objects can be set to be solid to block other objects
+     * - Objects may get pushed into overlapping other solid objects, if so they will push away
+     * - Solid objects are more performance intensive and should be used sparingly
+     * @example
+     * // create an engine object, normally you would first extend the class with your own
+     * const pos = vec2(2,3);
+     * const object = new EngineObject(pos);
+     */
+    export class EngineObject {
+        /** Create an engine object and adds it to the list of objects
+         *  @param {Vector2} [pos=Vector2()]            - World space position of the object
+         *  @param {Vector2} [size=Vector2(1,1)]        - World space size of the object
+         *  @param {TileInfo} [tileInfo]                - Tile info to render object (undefined is untextured)
+         *  @param {Number}  [angle=0]                  - Angle the object is rotated by
+         *  @param {Color}   [color=Color()]            - Color to apply to tile when rendered
+         *  @param {Number}  [renderOrder=0]            - Objects sorted by renderOrder before being rendered
+         */
+        constructor(pos?: Vector2, size?: Vector2, tileInfo?: TileInfo, angle?: number, color?: Color, renderOrder?: number);
+        /** @property {Vector2} - World space position of the object */
+        pos: Vector2;
+        /** @property {Vector2} - World space width and height of the object */
+        size: Vector2;
+        /** @property {TileInfo} - Tile info to render object (undefined is untextured) */
+        tileInfo: TileInfo;
+        /** @property {Number}  - Angle to rotate the object */
+        angle: number;
+        /** @property {Color}   - Color to apply when rendered */
+        color: Color;
+        /** @property {Number} [mass=objectDefaultMass]                 - How heavy the object is, static if 0 */
+        mass: number;
+        /** @property {Number} [damping=objectDefaultDamping]           - 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) */
+        angleDamping: number;
+        /** @property {Number} [elasticity=objectDefaultElasticity]     - How bouncy the object is when colliding (0-1) */
+        elasticity: number;
+        /** @property {Number} [friction=objectDefaultFriction]         - How much friction to apply when sliding (0-1) */
+        friction: number;
+        /** @property {Number} [gravityScale=1]                         - How much to scale gravity by for this object */
+        gravityScale: number;
+        /** @property {Number} [renderOrder=0]                          - Objects are sorted by render order */
+        renderOrder: number;
+        /** @property {Vector2} [velocity=Vector2()]                    - Velocity of the object */
+        velocity: Vector2;
+        /** @property {Number} [angleVelocity=0]                        - Angular velocity of the object */
+        angleVelocity: number;
+        spawnTime: number;
+        children: any[];
+        collideTiles: number;
+        /** Update the object transform and 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 */
+        render(): void;
+        /** Destroy this object, destroy it's children, detach it's parent, and mark it for removal */
+        destroy(): void;
+        destroyed: number;
+        /** Called to check if a tile collision should be resolved
+         *  @param {Number}  tileData - the value of the tile at the position
+         *  @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
+         */
+        collideWithObject(object: EngineObject): boolean;
+        /** How long since the object was created
+         *  @return {Number} */
+        getAliveTime(): number;
+        /** Apply acceleration to this object (adjust velocity, not affected by mass)
+         *  @param {Vector2} acceleration */
+        applyAcceleration(acceleration: Vector2): void;
+        /** Apply force to this object (adjust velocity, affected by mass)
+         *  @param {Vector2} force */
+        applyForce(force: Vector2): void;
+        /** Get the direction of the mirror
+         *  @return {Number} -1 if this.mirror is true, or 1 if not mirrored */
+        getMirrorSign(): number;
+        /** Attaches a child to this with a given local transform
+         *  @param {EngineObject} child
+         *  @param {Vector2}      [localPos=Vector2()]
+         *  @param {Number}       [localAngle=0] */
+        addChild(child: EngineObject, localPos?: Vector2, localAngle?: number): void;
+        /** Removes a child from this one
+         *  @param {EngineObject} child */
+        removeChild(child: EngineObject): void;
+        /** Set how this object collides
+         *  @param {Boolean} [collideSolidObjects=1] - Does it collide with solid objects
+         *  @param {Boolean} [isSolid=1]             - Does it collide with and block other objects (expensive in large numbers)
+         *  @param {Boolean} [collideTiles=1]        - Does it collide with the tile collision */
+        setCollision(collideSolidObjects?: boolean, isSolid?: boolean, collideTiles?: boolean): void;
+        collideSolidObjects: boolean;
+        isSolid: boolean;
+        /** Returns string containg info about this object for debugging
+         *  @return {String} */
+        toString(): string;
+    }
     /**
      * LittleJS Tile Layer System
      * - Caches arrays of tiles to off screen canvas for fast rendering
@@ -1520,7 +1701,7 @@ declare module "littlejs.esm" {
         clear(): void;
     }
     /**
-     * Tile layer object - cached rendering system for tile layers
+     * Tile Layer - cached rendering system for tile layers
      * - Each Tile layer is rendered to an off screen canvas
      * - To allow dynamic modifications, layers are rendered using canvas 2d
      * - Some devices like mobile phones are limited to 4k texture resolution
@@ -1535,11 +1716,11 @@ declare module "littlejs.esm" {
         /** Create a tile layer object
             *  @param {Vector2} [position=Vector2()]       - World space position
             *  @param {Vector2} [size=tileCollisionSize]   - World space size
-            *  @param {Vector2} [tileSize=tileSizeDefault] - Size of tiles in source pixels
+            *  @param {TileInfo} [tileInfo]                - Tile info for layer
             *  @param {Vector2} [scale=Vector2(1,1)]       - How much to scale this layer when rendered
             *  @param {Number}  [renderOrder=0]            - Objects sorted by renderOrder before being rendered
             */
-        constructor(pos: any, size?: Vector2, tileSize?: Vector2, scale?: Vector2, renderOrder?: number);
+        constructor(pos: any, 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 */
@@ -1581,12 +1762,11 @@ declare module "littlejs.esm" {
         /** Draw a tile directly onto the layer canvas
          *  @param {Vector2} pos
          *  @param {Vector2} [size=Vector2(1,1)]
-         *  @param {Number}  [tileIndex=-1]
-         *  @param {Vector2} [tileSize=tileSizeDefault]
+         *  @param {TileInfo} [tileInfo]
          *  @param {Color}   [color=Color()]
          *  @param {Number}  [angle=0]
          *  @param {Boolean} [mirror=0] */
-        drawTile(pos: Vector2, size?: Vector2, tileIndex?: number, tileSize?: Vector2, color?: Color, angle?: number, mirror?: boolean): void;
+        drawTile(pos: Vector2, size?: Vector2, tileInfo?: TileInfo, color?: Color, angle?: number, mirror?: boolean): void;
         /** Draw a rectangle directly onto the layer canvas
          *  @param {Vector2} pos
          *  @param {Vector2} [size=Vector2(1,1)]
@@ -1606,7 +1786,7 @@ declare module "littlejs.esm" {
      * let particleEmiter = new ParticleEmitter
      * (
      *     pos, 0, 1, 0, 500, PI,  // pos, angle, emitSize, emitTime, emitRate, emiteCone
-     *     0, vec2(16),                            // tileIndex, tileSize
+     *     tile(0, 16),            // tileInfo
      *     new Color(1,1,1),   new Color(0,0,0),   // colorStartA, colorStartB
      *     new Color(1,1,1,0), new Color(0,0,0,0), // colorEndA, colorEndB
      *     2, .2, .2, .1, .05,  // particleTime, sizeStart, sizeEnd, particleSpeed, particleAngleSpeed
@@ -1622,8 +1802,7 @@ declare module "littlejs.esm" {
          *  @param {Number}  [emitTime=0]       - How long to stay alive (0 is forever)
          *  @param {Number}  [emitRate=100]     - How many particles per second to spawn, does not emit if 0
          *  @param {Number}  [emitConeAngle=PI] - Local angle to apply velocity to particles from emitter
-         *  @param {Number}  [tileIndex=-1]     - Index into tile sheet, if <0 no texture is applied
-         *  @param {Vector2} [tileSize=tileSizeDefault] - Tile size for particles
+         *  @param {TileInfo} [tileInfo]         - Tile info to render particles (undefined is untextured)
          *  @param {Color}   [colorStartA=Color()] - Color at start of life 1, randomized between start colors
          *  @param {Color}   [colorStartB=Color()] - Color at start of life 2, randomized between start colors
          *  @param {Color}   [colorEndA=Color(1,1,1,0)] - Color at end of life 1, randomized between end colors
@@ -1645,7 +1824,7 @@ declare module "littlejs.esm" {
          *  @param {Number}  [renderOrder=0]        - Render order for particles (additive is above other stuff by default)
          *  @param {Boolean}  [localSpace=0]        - Should it be in local space of emitter (world space is default)
          */
-        constructor(pos: any, angle?: number, emitSize?: number, emitTime?: number, emitRate?: number, emitConeAngle?: number, tileIndex?: number, tileSize?: Vector2, 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: any, angle?: number, emitSize?: number, 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 {Number} - World space size of the emitter (float for circle diameter, vec2 for rect) */
         emitSize: number;
         /** @property {Number} - How long to stay alive (0 is forever) */
@@ -1701,11 +1880,10 @@ declare module "littlejs.esm" {
         /**
          * Create a particle with the given settings
          * @param {Vector2} position                   - World space position of the particle
-         * @param {Number}  [tileIndex=-1]             - Tile to use to render, untextured if -1
-         * @param {Vector2} [tileSize=tileSizeDefault] - Size of tile in source pixels
+         * @param {TileInfo} [tileInfo]                - Tile info to render particles (undefined is untextured)
          * @param {Number}  [angle=0]                  - Angle to rotate the particle
          */
-        constructor(pos: any, tileIndex?: number, tileSize?: Vector2, angle?: number);
+        constructor(pos: any, tileInfo?: TileInfo, angle?: number);
     }
     /**
      * LittleJS Medal System
@@ -1732,10 +1910,11 @@ declare module "littlejs.esm" {
     /** This can used to enable Newgrounds functionality
      *  @param {Number} app_id   - The newgrounds App ID
      *  @param {String} [cipher] - The encryption Key (AES-128/Base64)
+     *  @param {Object} [cryptoJS] - An instance of CryptoJS, if there is a cipher
      *  @memberof Medals */
-    export function newgroundsInit(app_id: number, cipher?: string): void;
+    export function newgroundsInit(app_id: number, cipher?: string, cryptoJS?: any): void;
     /**
-     * Medal Object - Tracks an unlockable medal
+     * Medal - Tracks an unlockable medal
      * @example
      * // create a medal
      * const medal_example = new Medal(0, 'Example Medal', 'More info about the medal goes here.', '🎖️');
@@ -1747,7 +1926,7 @@ declare module "littlejs.esm" {
      * medal_example.unlock();
      */
     export class Medal {
-        /** Create an medal object and adds it to the list of medals
+        /** Create a medal object and adds it to the list of medals
          *  @param {Number} id            - The unique identifier of the medal
          *  @param {String} name          - Name of the medal
          *  @param {String} [description] - Description of the medal
@@ -1778,20 +1957,20 @@ declare module "littlejs.esm" {
     /**
      * Newgrounds API wrapper object
      * @example
-     * // create a newgrounds object, replace the app id and cipher with your own
+     * // create a newgrounds object, replace the app id with your own
      * const app_id = '53123:1ZuSTQ9l';
-     * const cipher = 'enF0vGH@Mj/FRASKL23Q==';
-     * newgrounds = new Newgrounds(app_id, cipher);
+     * newgrounds = new Newgrounds(app_id);
      */
     export class Newgrounds {
         /** Create a newgrounds object
          *  @param {Number} app_id   - The newgrounds App ID
-         *  @param {String} [cipher] - The encryption Key (AES-128/Base64) */
-        constructor(app_id: number, cipher?: string);
+         *  @param {String} [cipher] - The encryption Key (AES-128/Base64)
+         *  @param {Object} [cryptoJS] - An instance of CryptoJS, if there is a cipher */
+        constructor(app_id: number, cipher?: string, cryptoJS?: any);
         app_id: number;
         cipher: string;
-        host: string;
         cryptoJS: any;
+        host: string;
         session_id: string;
         medals: any;
         scoreboards: any;
@@ -1820,141 +1999,5 @@ declare module "littlejs.esm" {
          * @return {Object}                - The response JSON object
          */
         call(component: string, parameters?: any, async?: boolean): any;
-        CryptoJS(): any;
     }
-    /**
-     * LittleJS WebGL Interface
-     * - All webgl used by the engine is wrapped up here
-     * - For normal stuff you won't need to see or call anything in this file
-     * - For advanced stuff there are helper functions to create shaders, textures, etc
-     * - Can be disabled with glEnable to revert to 2D canvas rendering
-     * - Batches sprite rendering on GPU for incredibly fast performance
-     * - Sprite transform math is done in the shader where possible
-     * @namespace WebGL
-     */
-    /** The WebGL canvas which appears above the main canvas and below the overlay canvas
-     *  @type {HTMLCanvasElement}
-     *  @memberof WebGL */
-    export let glCanvas: HTMLCanvasElement;
-    /** 2d context for glCanvas
-     *  @type {WebGLRenderingContext}
-     *  @memberof WebGL */
-    export let glContext: WebGLRenderingContext;
-    /** Set the WebGl blend mode, normally you should call setBlendMode instead
-     *  @param {Boolean} [additive=0]
-     *  @memberof WebGL */
-    export function glSetBlendMode(additive?: boolean): void;
-    /** Set the WebGl texture, not normally necessary unless multiple tile sheets are used
-     *  - This may also flush the gl buffer resulting in more draw calls and worse performance
-     *  @param {WebGLTexture} [texture=glTileTexture]
-     *  @memberof WebGL */
-    export function glSetTexture(texture?: WebGLTexture): void;
-    /** Compile WebGL shader of the given type, will throw errors if in debug mode
-     *  @param {String} source
-     *  @param          type
-     *  @return {WebGLShader}
-     *  @memberof WebGL */
-    export function glCompileShader(source: string, type: any): WebGLShader;
-    /** Create WebGL program with given shaders
-     *  @param {WebGLShader} vsSource
-     *  @param {WebGLShader} fsSource
-     *  @return {WebGLProgram}
-     *  @memberof WebGL */
-    export function glCreateProgram(vsSource: WebGLShader, fsSource: WebGLShader): WebGLProgram;
-    /** Create WebGL texture from an image and set the texture settings
-     *  @param {Image} image
-     *  @return {WebGLTexture}
-     *  @memberof WebGL */
-    export function glCreateTexture(image: new (width?: number, height?: number) => HTMLImageElement): WebGLTexture;
-    /** Set up a post processing shader
-     *  @param {String} shaderCode
-     *  @param {Boolean} includeOverlay
-     *  @memberof WebGL */
-    export function glInitPostProcess(shaderCode: string, includeOverlay: boolean): void;
-    /**
-     * LittleJS - The Tiny JavaScript Game Engine That Can!
-     * MIT License - Copyright 2021 Frank Force
-     *
-     * Engine Features
-     * - Object oriented system with base class engine object
-     * - Base class object handles update, physics, collision, rendering, etc
-     * - Engine helper classes and functions like Vector2, Color, and Timer
-     * - Super fast rendering system for tile sheets
-     * - Sound effects audio with zzfx and music with zzfxm
-     * - Input processing system with gamepad and touchscreen support
-     * - Tile layer rendering and collision system
-     * - Particle effect system
-     * - Medal system tracks and displays achievements
-     * - Debug tools and debug rendering system
-     * - Post processing effects
-     * - Call engineInit() to start it up!
-     * @namespace Engine
-     */
-    /** Name of engine
-     *  @type {String}
-     *  @default
-     *  @memberof Engine */
-    export const engineName: string;
-    /** Version of engine
-     *  @type {String}
-     *  @default
-     *  @memberof Engine */
-    export const engineVersion: string;
-    /** Frames per second to update objects
-     *  @type {Number}
-     *  @default
-     *  @memberof Engine */
-    export const frameRate: number;
-    /** How many seconds each frame lasts, engine uses a fixed time step
-     *  @type {Number}
-     *  @default 1/60
-     *  @memberof Engine */
-    export const timeDelta: number;
-    /** Array containing all engine objects
-     *  @type {Array}
-     *  @memberof Engine */
-    export let engineObjects: any[];
-    /** Current update frame, used to calculate time
-     *  @type {Number}
-     *  @memberof Engine */
-    export let frame: number;
-    /** Current engine time since start in seconds, derived from frame
-     *  @type {Number}
-     *  @memberof Engine */
-    export let time: number;
-    /** Actual clock time since start in seconds (not affected by pause or frame rate clamping)
-     *  @type {Number}
-     *  @memberof Engine */
-    export let timeReal: number;
-    /** Is the game paused? Causes time and objects to not be updated
-     *  @type {Boolean}
-     *  @default 0
-     *  @memberof Engine */
-    export let paused: boolean;
-    /** Set if game is paused
-     *  @param {Boolean} paused
-     *  @memberof Engine */
-    export function setPaused(_paused: any): void;
-    /** Start up LittleJS engine with your callback functions
-     *  @param {Function} gameInit        - Called once after the engine starts up, setup the game
-     *  @param {Function} gameUpdate      - Called every frame at 60 frames per second, handle input and update the game state
-     *  @param {Function} gameUpdatePost  - Called after physics and objects are updated, setup camera and prepare for render
-     *  @param {Function} gameRender      - Called before objects are rendered, draw any background effects that appear behind objects
-     *  @param {Function} gameRenderPost  - Called after objects are rendered, draw effects or hud that appear above all objects
-     *  @param {String} [tileImageSource] - Tile image to use, everything starts when the image is finished loading
-     *  @memberof Engine */
-    export function engineInit(gameInit: Function, gameUpdate: Function, gameUpdatePost: Function, gameRender: Function, gameRenderPost: Function, tileImageSource?: string): void;
-    /** Update each engine object, remove destroyed objects, and update time
-     *  @memberof Engine */
-    export function engineObjectsUpdate(): void;
-    /** Destroy and remove all objects
-     *  @memberof Engine */
-    export function engineObjectsDestroy(): void;
-    /** Triggers a callback for each object within a given area
-     *  @param {Vector2} [pos]                 - Center of test area
-     *  @param {Number} [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
-     *  @memberof Engine */
-    export function engineObjectsCallback(pos?: Vector2, size?: number, callbackFunction?: Function, objects?: any[]): void;
 }