littlejsengine 1.14.16 → 1.14.23

package/dist/littlejs.d.ts

@@ -14,7 +14,11 @@ declare module "littlejsengine" {
     /**
      * - Function that processes an object
      */
-    export type ObjectCallbackFunction = (uiObjects: EngineObject) => any;
+    export type ObjectCallbackFunction = (object: EngineObject) => any;
+    /**
+     * - Checks if a position is colliding
+     */
+    export type LineTestFunction = (pos: Vector2) => any;
     /**
      * - A function that draws to a 2D canvas context
      */
@@ -143,7 +147,7 @@ declare module "littlejsengine" {
     export function engineObjectsCollect(pos?: Vector2, size?: Vector2 | number, objects?: Array<EngineObject>): Array<EngineObject>;
     /**
      * @callback ObjectCallbackFunction - Function that processes an object
-     * @param {EngineObject} uiObjects
+     * @param {EngineObject} object
      *  @memberof Engine
      */
     /** Triggers a callback for each object within a given area
@@ -165,10 +169,12 @@ declare module "littlejsengine" {
      * @memberof Engine
      */
     /** Add a new update function for a plugin
-     *  @param {PluginCallback} [updateFunction]
-     *  @param {PluginCallback} [renderFunction]
+     *  @param {PluginCallback} [update]
+     *  @param {PluginCallback} [render]
+     *  @param {PluginCallback} [glContextLost]
+     *  @param {PluginCallback} [glContextRestored]
      *  @memberof Engine */
-    export function engineAddPlugin(updateFunction?: PluginCallback, renderFunction?: PluginCallback): void;
+    export function engineAddPlugin(update?: PluginCallback, render?: PluginCallback, glContextLost?: PluginCallback, glContextRestored?: PluginCallback): void;
     /**
      * LittleJS Debug System
      * - Press Esc to show debug overlay with mouse pick
@@ -454,6 +460,13 @@ declare module "littlejsengine" {
      *  @default
      *  @memberof Settings */
     export let touchGamepadEnable: boolean;
+    /** True if touch gamepad should have start button in the center
+     *  - When the game is paused, any touch will press the button
+     *  - This can function as a way to pause/unpause the game
+     *  @type {boolean}
+     *  @default
+     *  @memberof Settings */
+    export let touchGamepadCenterButton: boolean;
     /** True if touch gamepad should be analog stick or false to use if 8 way dpad
      *  @type {boolean}
      *  @default
@@ -635,6 +648,11 @@ declare module "littlejsengine" {
      *  @param {boolean} enable
      *  @memberof Settings */
     export function setTouchGamepadEnable(enable: boolean): void;
+    /** True if touch gamepad should have start button in the center
+     *  - This can function as a way to pause/unpause the game
+     *  @param {boolean} enable
+     *  @memberof Settings */
+    export function setTouchGamepadCenterButton(enable: boolean): void;
     /** Set if touch gamepad should be analog stick or 8 way dpad
      *  @param {boolean} analog
      *  @memberof Settings */
@@ -700,7 +718,7 @@ declare module "littlejsengine" {
      * - RandomGenerator - seeded random number generator
      * @namespace Utilities
      */
-    /** A shortcut to get Math.PI
+    /** The value of PI
      *  @type {number}
      *  @default Math.PI
      *  @memberof Utilities */
@@ -709,22 +727,68 @@ declare module "littlejsengine" {
      *  @param {number} value
      *  @return {number}
      *  @memberof Utilities */
-    export function abs(value: number): number;
+    export const abs: (x: number) => number;
+    /** Returns floored value of value passed in
+     *  @param {number} value
+     *  @return {number}
+     *  @memberof Utilities */
+    export const floor: (x: number) => number;
+    /** Returns ceiled value of value passed in
+     *  @param {number} value
+     *  @return {number}
+     *  @memberof Utilities */
+    export const ceil: (x: number) => number;
+    /** Returns rounded value passed in
+     *  @param {number} value
+     *  @return {number}
+     *  @memberof Utilities */
+    export const round: (x: number) => number;
     /** Returns lowest value passed in
      *  @param {...number} values
      *  @return {number}
      *  @memberof Utilities */
-    export function min(...values: number[]): number;
+    export const min: (...values: number[]) => number;
     /** Returns highest value passed in
      *  @param {...number} values
      *  @return {number}
      *  @memberof Utilities */
-    export function max(...values: number[]): number;
+    export const max: (...values: number[]) => number;
     /** Returns the sign of value passed in
      *  @param {number} value
      *  @return {number}
      *  @memberof Utilities */
-    export function sign(value: number): number;
+    export const sign: (x: number) => number;
+    /** Returns hypotenuse of values passed in
+     *  @param {...number} values
+     *  @return {number}
+     *  @memberof Utilities */
+    export const hypot: (...values: number[]) => number;
+    /** Returns log2 of value passed in
+     *  @param {number} value
+     *  @return {number}
+     *  @memberof Utilities */
+    export const log2: (x: number) => number;
+    /** Returns sin of value passed in
+     *  @param {number} value
+     *  @return {number}
+     *  @memberof Utilities */
+    export const sin: (x: number) => number;
+    /** Returns cos of value passed in
+     *  @param {number} value
+     *  @return {number}
+     *  @memberof Utilities */
+    export const cos: (x: number) => number;
+    /** Returns tan of value passed in
+     *  @param {number} value
+     *  @return {number}
+     *  @memberof Utilities */
+    export const tan: (x: number) => number;
+    /** Returns atan2 of values passed in
+     *  @param {number} y
+     *  @param {number} x
+     *  @return {number}
+     *  @memberof Utilities */
+    export const atan2: (y: number, x: number) => number;
     /** Returns first parm modulo the second param, but adjusted so negative numbers work as expected
      *  @param {number} dividend
      *  @param {number} [divisor]
@@ -909,6 +973,18 @@ declare module "littlejsengine" {
         *  @param {number} [valueB]
         *  @return {Vector2} */
         vec2(valueA?: number, valueB?: number): Vector2;
+        /** Returns a random color between the two passed in colors, combine components if linear
+        *  @param {Color}   [colorA=(1,1,1,1)]
+        *  @param {Color}   [colorB=(0,0,0,1)]
+        *  @param {boolean} [linear]
+        *  @return {Color} */
+        randColor(colorA?: Color, colorB?: Color, linear?: boolean): Color;
+        /** Returns a new color that has each component randomly adjusted
+         * @param {Color} color
+         * @param {number} [amount]
+         * @param {number} [alphaAmount]
+         * @return {Color} */
+        mutateColor(color: Color, amount?: number, alphaAmount?: number): Color;
     }
     /**
      * 2D Vector object with vector math library
@@ -1340,12 +1416,11 @@ declare module "littlejsengine" {
         */
         frame(frame: number): TileInfo;
         /**
-         * Set this tile to use a full image
-         * @param {HTMLImageElement|OffscreenCanvas} image
-         * @param {WebGLTexture} [glTexture] - WebGL texture
+         * Set this tile to use a full image in a texture info
+         * @param {TextureInfo} textureInfo
          * @return {TileInfo}
          */
-        setFullImage(image: HTMLImageElement | OffscreenCanvas, glTexture?: WebGLTexture): TileInfo;
+        setFullImage(textureInfo: TextureInfo): TileInfo;
     }
     /**
      * Tile Info - Stores info about each texture
@@ -1355,18 +1430,24 @@ declare module "littlejsengine" {
         /**
          * Create a TextureInfo, called automatically by the engine
          * @param {HTMLImageElement|OffscreenCanvas} image
-         * @param {WebGLTexture} [glTexture] - WebGL texture
+         * @param {boolean} [useWebGL] - Should use WebGL if available?
          */
-        constructor(image: HTMLImageElement | OffscreenCanvas, glTexture?: WebGLTexture);
-        /** @property {HTMLImageElement} - image source */
+        constructor(image: HTMLImageElement | OffscreenCanvas, useWebGL?: boolean);
+        /** @property {HTMLImageElement|OffscreenCanvas} - image source */
         image: OffscreenCanvas | HTMLImageElement;
         /** @property {Vector2} - size of the image */
         size: Vector2;
         /** @property {Vector2} - inverse of the size, cached for rendering */
         sizeInverse: Vector2;
         /** @property {WebGLTexture} - WebGL texture */
-        glTexture: WebGLTexture;
+        glTexture: any;
+        /** Creates the WebGL texture, updates if already created */
         createWebGLTexture(): void;
+        /** Destroys the WebGL texture */
+        destroyWebGLTexture(): void;
+        /** Check if the texture is webgl enabled
+         * @return {boolean} */
+        hasWebGL(): boolean;
     }
     /**
      * LittleJS Drawing System
@@ -1435,6 +1516,16 @@ declare module "littlejsengine" {
      *  @return {Vector2}
      *  @memberof Draw */
     export function worldToScreen(worldPos: Vector2): Vector2;
+    /** Convert from screen to world space coordinates for a directional vector (no translation)
+     *  @param {Vector2} screenDelta
+     *  @return {Vector2}
+     *  @memberof Draw */
+    export function screenToWorldDelta(screenDelta: Vector2): Vector2;
+    /** Convert from screen to world space coordinates for a directional vector (no translation)
+     *  @param {Vector2} worldDelta
+     *  @return {Vector2}
+     *  @memberof Draw */
+    export function worldToScreenDelta(worldDelta: Vector2): Vector2;
     /** 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=(1,1)]        - Size of the tile in world space
@@ -1553,10 +1644,11 @@ declare module "littlejsengine" {
      *  @param {Color}   [lineColor=(0,0,0,1)]
      *  @param {CanvasTextAlign}  [textAlign='center']
      *  @param {string}  [font=fontDefault]
+     *  @param {string}  [fontStyle]
      *  @param {number}  [maxWidth]
      *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=drawContext]
      *  @memberof Draw */
-    export function drawText(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: CanvasTextAlign, font?: string, maxWidth?: number, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
+    export function drawText(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: CanvasTextAlign, font?: string, fontStyle?: string, maxWidth?: number, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Draw text on overlay canvas in world space
      *  Automatically splits new lines into rows
      *  @param {string}  text
@@ -1567,9 +1659,10 @@ declare module "littlejsengine" {
      *  @param {Color}   [lineColor=(0,0,0,1)]
      *  @param {CanvasTextAlign}  [textAlign='center']
      *  @param {string}  [font=fontDefault]
+     *  @param {string}  [fontStyle]
      *  @param {number}  [maxWidth]
      *  @memberof Draw */
-    export function drawTextOverlay(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: CanvasTextAlign, font?: string, maxWidth?: number): void;
+    export function drawTextOverlay(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: CanvasTextAlign, font?: string, fontStyle?: string, maxWidth?: number): void;
     /** Draw text on overlay canvas in screen space
      *  Automatically splits new lines into rows
      *  @param {string}  text
@@ -1580,10 +1673,11 @@ declare module "littlejsengine" {
      *  @param {Color}   [lineColor=(0,0,0,1)]
      *  @param {CanvasTextAlign}  [textAlign]
      *  @param {string}  [font=fontDefault]
+     *  @param {string}  [fontStyle]
      *  @param {number}  [maxWidth]
      *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=overlayContext]
      *  @memberof Draw */
-    export function drawTextScreen(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: CanvasTextAlign, font?: string, maxWidth?: number, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
+    export function drawTextScreen(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: CanvasTextAlign, font?: string, fontStyle?: string, maxWidth?: number, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Enable normal or additive blend mode
      *  @param {boolean} [additive]
      *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context]
@@ -1609,11 +1703,11 @@ declare module "littlejsengine" {
      */
     export class FontImage {
         /** Create an image font
-         *  @param {HTMLImageElement} [image]    - Image for the font, if undefined default font is used
-         *  @param {Vector2} [tileSize=(8,8)]    - Size of the font source tiles
-         *  @param {Vector2} [paddingSize=(0,1)] - How much extra space to add between characters
+         *  @param {HTMLImageElement} [image] - Image for the font, default if undefined
+         *  @param {Vector2} [tileSize=(8,8)] - Size of the font source tiles
+         *  @param {Vector2} [paddingSize=(0,1)] - How much space between characters
          */
-        constructor(image?: HTMLImageElement, tileSize?: Vector2, paddingSize?: Vector2, context?: CanvasRenderingContext2D);
+        constructor(image?: HTMLImageElement, tileSize?: Vector2, paddingSize?: Vector2);
         image: any;
         tileSize: Vector2;
         paddingSize: Vector2;
@@ -2154,7 +2248,7 @@ declare module "littlejsengine" {
      *  @param {GainNode} [gainNode] - Optional gain node for volume control while playing
      *  @param {number}   [offset] - Offset in seconds to start playback from
      *  @param {AudioEndedCallback} [onended] - Callback for when the sound ends
-     *  @return {AudioBufferSourceNode} - The audio node of the sound played
+     *  @return {AudioBufferSourceNode} - The source node of the sound played, may be undefined if play fails
      *  @memberof Audio */
     export function playSamples(sampleChannels: any[], volume?: number, rate?: number, pan?: number, loop?: boolean, sampleRate?: number, gainNode?: GainNode, offset?: number, onended?: AudioEndedCallback): AudioBufferSourceNode;
     /** Generate and play a ZzFX sound
@@ -2315,6 +2409,14 @@ declare module "littlejsengine" {
          *  @return {boolean}            - true if the collision should be resolved
          */
         collideWithObject(object: EngineObject): boolean;
+        /** Get this object's up vector
+         *  @param {number} [scale] - length of the vector
+         *  @return {Vector2} */
+        getUp(scale?: number): Vector2;
+        /** Get this object's right vector
+         *  @param {number} [scale] - length of the vector
+         *  @return {Vector2} */
+        getRight(scale?: number): Vector2;
         /** How long since the object was created
          *  @return {number} */
         getAliveTime(): number;
@@ -2375,15 +2477,15 @@ declare module "littlejsengine" {
      *  @return {TileCollisionLayer}
      *  @memberof TileLayers */
     export function tileCollisionTest(pos: Vector2, size?: Vector2, object?: EngineObject, solidOnly?: boolean): TileCollisionLayer;
-    /** Return the center of first tile hit, undefined if nothing was hit.
-     *  This does not return the exact intersection, but the center of the tile hit.
+    /** Return the exact position of the boudnary of first tile hit, undefined if nothing was hit.
      *  @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
-     *  @return {Vector2}
+     *  @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, solidOnly?: boolean): Vector2;
+    export function tileCollisionRaycast(posStart: Vector2, posEnd: Vector2, object?: EngineObject, normal?: Vector2, solidOnly?: boolean): Vector2 | undefined;
     /**
      * Load tile layers from exported data
      *  @param {Object}   tileMapData - Level data from exported data
@@ -2445,8 +2547,9 @@ declare module "littlejsengine" {
         canvas: OffscreenCanvas;
         /** @property {OffscreenCanvasRenderingContext2D} - The 2D canvas context used by this layer */
         context: OffscreenCanvasRenderingContext2D;
-        /** @property {WebGLTexture} - Texture if using WebGL for this layer, call useWebGL to enable */
-        glTexture: WebGLTexture;
+        textureInfo: TextureInfo;
+        /** @property {boolean} - True if WebGL texture needs to be refreshed */
+        refreshWebGL: boolean;
         /** 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
@@ -2485,8 +2588,10 @@ declare module "littlejsengine" {
          *  @param {number}  [angle=0] */
         drawRect(pos: Vector2, size?: Vector2, color?: Color, angle?: number): void;
         /** Create or update the WebGL texture for this layer
-         *  @param {boolean} [enable] - enable WebGL rendering and update the texture */
-        useWebGL(enable?: boolean): void;
+         *  @param {boolean} [enable] - enable WebGL rendering and update the texture
+         *  @param {boolean} [immediate] - shoulkd the texture be updated immediately
+         */
+        useWebGL(enable?: boolean, immediate?: boolean): void;
     }
     /**
      * Tile Layer - cached rendering system for tile layers
@@ -2506,9 +2611,8 @@ declare module "littlejsengine" {
         *  @param {Vector2}  size          - World space size
         *  @param {TileInfo} [tileInfo]    - Default tile info for layer (used for size and texture)
         *  @param {number}   [renderOrder] - Objects are sorted by renderOrder
-        *  @param {boolean}  [useWebGL=glEnable] - Use accelerated WebGL rendering
         */
-        constructor(position: Vector2, size: Vector2, tileInfo?: TileInfo, renderOrder?: number, useWebGL?: boolean);
+        constructor(position: Vector2, size: Vector2, tileInfo?: TileInfo, renderOrder?: number);
         data: TileLayerData[];
         /** Draw all the tile data to an offscreen canvas
          *  - This may be slow in some browsers but only needs to be done once */
@@ -2566,13 +2670,13 @@ declare module "littlejsengine" {
         *  @param {EngineObject} [object]
         *  @return {boolean} */
         collisionTest(pos: Vector2, size?: Vector2, object?: EngineObject): boolean;
-        /** Return the center of first tile hit, undefined if nothing was hit.
-        *  This does not return the exact intersection, but the center of the tile hit.
+        /** Return the exact position of the boudnary of first tile hit, undefined if nothing was hit.
         *  @param {Vector2}      posStart
         *  @param {Vector2}      posEnd
-        *  @param {EngineObject} [object]
-        *  @return {Vector2} */
-        collisionRaycast(posStart: Vector2, posEnd: Vector2, object?: EngineObject): Vector2;
+        *  @param {EngineObject} [object] - An object or undefined for generic test
+        *  @param {Vector2}      [normal] - Optional normal of the surface hit
+        *  @return {Vector2|undefined} */
+        collisionRaycast(posStart: Vector2, posEnd: Vector2, object?: EngineObject, normal?: Vector2): Vector2 | undefined;
     }
     /**
      * LittleJS Particle System
@@ -2595,7 +2699,7 @@ declare module "littlejsengine" {
      *     tile(0, 16),                // tileInfo
      *     rgb(1,1,1,1), rgb(0,0,0,1), // colorStartA, colorStartB
      *     rgb(1,1,1,0), rgb(0,0,0,0), // colorEndA, colorEndB
-     *     2, .2, .2, .1, .05,  // particleTime, sizeStart, sizeEnd, particleSpeed, particleAngleSpeed
+     *     1, .2, .2, .1, .05,  // particleTime, sizeStart, sizeEnd, particleSpeed, particleAngleSpeed
      *     .99, 1, 1, PI, .05,  // damping, angleDamping, gravityScale, particleCone, fadeRate,
      *     .5, 1                // randomness, collide, additive, randomColorLinear, renderOrder
      * );
@@ -2677,6 +2781,10 @@ declare module "littlejsengine" {
         particleCreateCallback: any;
         /** @property {number} - Track particle emit time */
         emitTimeBuffer: number;
+        /** @property {number} - Percentage of velocity to pass to particles (0-1) */
+        velocityInheritance: number;
+        previousAngle: number;
+        previousPos: Vector2;
         /** Spawn one particle
          *  @return {Particle} */
         emitParticle(): Particle;
@@ -2881,17 +2989,16 @@ declare module "littlejsengine" {
         /** Create global post processing shader
         *  @param {string} shaderCode
         *  @param {boolean} [includeOverlay]
+        *  @param {boolean} [includeMainCanvas]
          *  @example
          *  // create the post process plugin object
          *  new PostProcessPlugin(shaderCode);
          */
-        constructor(shaderCode: string, includeOverlay?: boolean);
+        constructor(shaderCode: string, includeOverlay?: boolean, includeMainCanvas?: boolean);
         /** @property {WebGLProgram} - Shader for post processing */
-        shader: WebGLProgram;
+        shader: any;
         /** @property {WebGLTexture} - Texture for post processing */
-        texture: WebGLTexture;
-        /** @property {boolean} - Should overlay canvas be included in post processing */
-        includeOverlay: boolean;
+        texture: any;
     }
     /**
      * LittleJS ZzFXM Plugin
@@ -2980,6 +3087,8 @@ declare module "littlejsengine" {
         defaultHoverColor: Color;
         /** @property {Color} - Default color for disabled UI elements */
         defaultDisabledColor: Color;
+        /** @property {Color} - Uses a gradient fill combined with color */
+        defaultGradientColor: any;
         /** @property {number} - Default line width for UI elements */
         defaultLineWidth: number;
         /** @property {number} - Default rounded rect corner radius for UI elements */
@@ -3004,14 +3113,17 @@ declare module "littlejsengine" {
         hoverObject: any;
         /** @property {UIObject} - Hover object at start of update */
         lastHoverObject: any;
+        /** @property {number} - If set ui coords will be renormalized to this canvas height */
+        nativeHeight: number;
         /** Draw a rectangle to the UI context
         *  @param {Vector2} pos
         *  @param {Vector2} size
         *  @param {Color}   [color=uiSystem.defaultColor]
         *  @param {number}  [lineWidth=uiSystem.defaultLineWidth]
         *  @param {Color}   [lineColor=uiSystem.defaultLineColor]
-        *  @param {number}  [cornerRadius=uiSystem.defaultCornerRadius] */
-        drawRect(pos: Vector2, size: Vector2, color?: Color, lineWidth?: number, lineColor?: Color, cornerRadius?: number): void;
+        *  @param {number}  [cornerRadius=uiSystem.defaultCornerRadius]
+        *  @param {Color}   [gradientColor=uiSystem.defaultGradientColor] */
+        drawRect(pos: Vector2, size: Vector2, color?: Color, lineWidth?: number, lineColor?: Color, cornerRadius?: number, gradientColor?: Color): void;
         /** Draw a line to the UI context
         *  @param {Vector2} posA
         *  @param {Vector2} posB
@@ -3035,8 +3147,9 @@ declare module "littlejsengine" {
         *  @param {Color}   [lineColor=uiSystem.defaultLineColor]
         *  @param {string}  [align]
         *  @param {string}  [font=uiSystem.defaultFont]
+        *  @param {string}  [fontStyle]
         *  @param {boolean} [applyMaxWidth=true] */
-        drawText(text: string, pos: Vector2, size: Vector2, color?: Color, lineWidth?: number, lineColor?: Color, align?: string, font?: string, applyMaxWidth?: boolean): void;
+        drawText(text: string, pos: Vector2, size: Vector2, color?: Color, lineWidth?: number, lineColor?: Color, align?: string, font?: string, fontStyle?: string, applyMaxWidth?: boolean): void;
         /**
          * @callback DragAndDropCallback - Callback for drag and drop events
          * @param {DragEvent} event - The drag event
@@ -3081,12 +3194,16 @@ declare module "littlejsengine" {
         hoverColor: Color;
         /** @property {Color} - Color for line drawing */
         lineColor: Color;
+        /** @property {Color} - Uses a gradient fill combined with color */
+        gradientColor: any;
         /** @property {number} - Width for line drawing */
         lineWidth: number;
         /** @property {number} - Corner radius for rounded rects */
         cornerRadius: number;
         /** @property {string} - Font for this objecct */
         font: string;
+        /** @property {string} - Font style for this object or undefined */
+        fontStyle: any;
         /** @property {number} - Override for text width */
         textWidth: any;
         /** @property {number} - Override for text height */
@@ -3111,6 +3228,8 @@ declare module "littlejsengine" {
         interactive: boolean;
         /** @property {boolean} - Activate when dragged over with mouse held down */
         dragActivate: boolean;
+        /** @property {boolean} - True if this can be a hover object */
+        canBeHover: boolean;
         /** Add a child UIObject to this object
          *  @param {UIObject} child
          */
@@ -3119,6 +3238,10 @@ declare module "littlejsengine" {
          *  @param {UIObject} child
          */
         removeChild(child: UIObject): void;
+        /** Check if the mouse is overlapping a box in screen space
+         *  @return {boolean} - True if overlapping
+         */
+        isMouseOverlapping(): boolean;
         /** Update the object, called automatically by plugin once each frame */
         update(): void;
         /** Render the object, called automatically by plugin once each frame */