littlejsengine 1.14.19 → 1.14.28

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
@@ -456,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
@@ -637,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 */
@@ -702,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 */
@@ -711,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]
@@ -842,6 +904,11 @@ declare module "littlejsengine" {
      *  @return {number}
      *  @memberof Random */
     export function randInt(valueA: number, valueB?: number): number;
+    /** Randomly returns true or false given the chance of true passed in
+     *  @param {number} [chance]
+     *  @return {boolean}
+     *  @memberof Random */
+    export function randBool(chance?: number): boolean;
     /** Randomly returns either -1 or 1
      *  @return {number}
      *  @memberof Random */
@@ -911,6 +978,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
@@ -1238,6 +1317,12 @@ declare module "littlejsengine" {
      * @return {boolean}
      * @memberof Utilities */
     export function isString(s: any): boolean;
+    /**
+     * Check if object is an array
+     * @param {any} a
+     * @return {boolean}
+     * @memberof Utilities */
+    export function isArray(a: any): boolean;
     /** Color - White #ffffff
      *  @type {Color}
      *  @memberof Utilities */
@@ -1442,6 +1527,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
@@ -1562,9 +1657,10 @@ declare module "littlejsengine" {
      *  @param {string}  [font=fontDefault]
      *  @param {string}  [fontStyle]
      *  @param {number}  [maxWidth]
+     *  @param {number}  [angle]
      *  @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, fontStyle?: 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, angle?: number, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Draw text on overlay canvas in world space
      *  Automatically splits new lines into rows
      *  @param {string}  text
@@ -1577,8 +1673,9 @@ declare module "littlejsengine" {
      *  @param {string}  [font=fontDefault]
      *  @param {string}  [fontStyle]
      *  @param {number}  [maxWidth]
+     *  @param {number}  [angle]
      *  @memberof Draw */
-    export function drawTextOverlay(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: CanvasTextAlign, font?: string, fontStyle?: 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, angle?: number): void;
     /** Draw text on overlay canvas in screen space
      *  Automatically splits new lines into rows
      *  @param {string}  text
@@ -1591,9 +1688,10 @@ declare module "littlejsengine" {
      *  @param {string}  [font=fontDefault]
      *  @param {string}  [fontStyle]
      *  @param {number}  [maxWidth]
+     *  @param {number}  [angle]
      *  @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, fontStyle?: 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, angle?: number, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Enable normal or additive blend mode
      *  @param {boolean} [additive]
      *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context]
@@ -1876,6 +1974,10 @@ declare module "littlejsengine" {
      *  @type {number}
      *  @memberof Input */
     export let mouseWheel: number;
+    /** True if mouse was inside the document window, set to false when mouse leaves
+     *  @type {boolean}
+     *  @memberof Input */
+    export let mouseInWindow: boolean;
     /** Returns true if user is using gamepad (has more recently pressed a gamepad button)
      *  @type {boolean}
      *  @memberof Input */
@@ -2297,6 +2399,8 @@ declare module "littlejsengine" {
         /** Update the object transform, called automatically by engine even when paused */
         updateTransforms(): void;
         /** Update the object physics, called automatically by engine once each frame */
+        updatePhysics(): void;
+        /** Update the object, called automatically by engine once each frame. Does nothing by default. */
         update(): void;
         /** Render the object, draws a tile by default, automatically called each frame, sorted by renderOrder */
         render(): void;
@@ -2325,9 +2429,20 @@ 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;
+        /** Get the speed of this object
+         *  @return {number} */
+        getSpeed(): number;
         /** Apply acceleration to this object (adjust velocity, not affected by mass)
          *  @param {Vector2} acceleration */
         applyAcceleration(acceleration: Vector2): void;
@@ -2348,6 +2463,16 @@ declare module "littlejsengine" {
         /** Removes a child from this one
          *  @param {EngineObject} child */
         removeChild(child: EngineObject): void;
+        /** Check if overlapping another engine object
+         *  Collisions are resoloved to prevent overlaps
+         *  @param {EngineObject} object
+         *  @return {boolean} */
+        isOverlappingObject(object: EngineObject): boolean;
+        /** Check if overlapping a point or aligned bounding box
+         *  @param {Vector2} pos          - Center of box
+         *  @param {Vector2} [size=(0,0)] - Size of box, uses a point if undefined
+         *  @return {boolean} */
+        isOverlapping(pos: Vector2, size?: Vector2): boolean;
         /** Set how this object collides
          *  @param {boolean} [collideSolidObjects] - Does it collide with solid objects?
          *  @param {boolean} [isSolid]             - Does it collide with and block other objects? (expensive in large numbers)
@@ -2385,15 +2510,16 @@ 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.
+     *  The point will be inside the colliding tile if it hits (may have a tiny shift)
      *  @param {Vector2}      posStart
      *  @param {Vector2}      posEnd
      *  @param {EngineObject} [object] - An object or undefined for generic test
+     *  @param {Vector2}      [normal] - Optional normal of the surface hit
      *  @param {boolean}      [solidOnly=true] - Only check solid layers if true
-     *  @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
@@ -2456,6 +2582,8 @@ declare module "littlejsengine" {
         /** @property {OffscreenCanvasRenderingContext2D} - The 2D canvas context used by this layer */
         context: OffscreenCanvasRenderingContext2D;
         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
@@ -2494,8 +2622,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
@@ -2574,13 +2704,14 @@ 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.
+        *  The point will be inside the colliding tile if it hits (may have a tiny shift)
         *  @param {Vector2}      posStart
         *  @param {Vector2}      posEnd
-        *  @param {EngineObject} [object]
-        *  @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
@@ -2685,6 +2816,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;
@@ -3018,11 +3153,11 @@ declare module "littlejsengine" {
         /** 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]
-        *  @param {Color}   [gradientColor=uiSystem.defaultGradientColor] */
+        *  @param {Color}   [color]
+        *  @param {number}  [lineWidth]
+        *  @param {Color}   [lineColor]
+        *  @param {number}  [cornerRadius]
+        *  @param {Color}   [gradientColor] */
         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
@@ -3048,8 +3183,10 @@ declare module "littlejsengine" {
         *  @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, fontStyle?: string, applyMaxWidth?: boolean): void;
+        *  @param {boolean} [applyMaxWidth=true]
+        *  @param {Vector2} [textShadow]
+         */
+        drawText(text: string, pos: Vector2, size: Vector2, color?: Color, lineWidth?: number, lineColor?: Color, align?: string, font?: string, fontStyle?: string, applyMaxWidth?: boolean, textShadow?: Vector2): void;
         /**
          * @callback DragAndDropCallback - Callback for drag and drop events
          * @param {DragEvent} event - The drag event
@@ -3062,6 +3199,11 @@ declare module "littlejsengine" {
         *  @param {DragAndDropCallback} [onDragLeave] - when a file is dragged off the window
         *  @param {DragAndDropCallback} [onDragOver] - continously when dragging over */
         setupDragAndDrop(onDrop?: (event: DragEvent) => any, onDragEnter?: (event: DragEvent) => any, onDragLeave?: (event: DragEvent) => any, onDragOver?: (event: DragEvent) => any): void;
+        /** Convert a screen space position to native UI position
+         *  @param {Vector2} pos
+         *  @return {Vector2}
+         */
+        screenToNative(pos: Vector2): Vector2;
     }
     /**
      * UI Object - Base level object for all UI elements
@@ -3130,6 +3272,8 @@ declare module "littlejsengine" {
         dragActivate: boolean;
         /** @property {boolean} - True if this can be a hover object */
         canBeHover: boolean;
+        /** @property {Vector2} - How much to offset the text shadow or undefined */
+        textShadow: any;
         /** Add a child UIObject to this object
          *  @param {UIObject} child
          */
@@ -3156,6 +3300,8 @@ declare module "littlejsengine" {
         isHoverObject(): boolean;
         /** @return {boolean} - Is the mouse held onto this element */
         isActiveObject(): boolean;
+        /** Called each frame when object updates */
+        onUpdate(): void;
         /** Called when the mouse enters the object */
         onEnter(): void;
         /** Called when the mouse leaves the object */
@@ -3265,9 +3411,9 @@ declare module "littlejsengine" {
     /**
      * LittleJS Box2D Physics Plugin
      * - Box2dObject extends EngineObject with Box2D physics
-     * - Call box2dInit() before engineInit() to enable
+     * - Call box2dInit() to enable
      * - You will also need to include box2d.wasm.js
-     * - Uses a super fast web assembly port of Box2D
+     * - Uses a super fast web assembly port of Box2D v2.3.1
      * - More info: https://github.com/kripken/box2d.js
      * - Functions to create polygon, circle, and edge shapes
      * - Contact begin and end callbacks
@@ -3307,6 +3453,7 @@ declare module "littlejsengine" {
         constructor(instance: any);
         instance: any;
         world: any;
+        objects: any[];
         /** @property {number} - Velocity iterations per update*/
         velocityIterations: number;
         /** @property {number} - Position iterations per update*/
@@ -3362,7 +3509,7 @@ declare module "littlejsengine" {
         vec2From(v: any): Vector2;
         /** converts a box2d vec2 pointer to a Vector2
          *  @param {Object} v */
-        vec2FromPointer(v: any): Vector2;
+        vec2FromPointer(vp: any): Vector2;
         /** converts a Vector2 to a box2 vec2
          *  @param {Vector2} v */
         vec2dTo(v: Vector2): any;
@@ -3375,9 +3522,9 @@ declare module "littlejsengine" {
     }
     /**
      * Box2D Object - extend with your own custom physics objects
-     * - A LittleJS object with Box2D physics
-     * - Each object has a Box2D body which can have multiple fixtures and joints
+     * - A LittleJS object with Box2D physics, dynamic by default
      * - Provides interface for Box2D body and fixture functions
+     * - Each object can have multiple fixtures and joints
      * @extends EngineObject
      * @memberof Box2D
      */
@@ -3393,6 +3540,8 @@ declare module "littlejsengine" {
         constructor(pos?: Vector2, size?: Vector2, tileInfo?: TileInfo, angle?: number, color?: Color, bodyType?: number, renderOrder?: number);
         body: any;
         lineColor: Color;
+        edgeLists: any[];
+        edgeLoops: any[];
         /** Draws all this object's fixtures
          *  @param {Color}  [color]
          *  @param {Color}  [lineColor]
@@ -3459,20 +3608,20 @@ declare module "littlejsengine" {
          *  @param {number}  [restitution]
          *  @param {boolean} [isSensor] */
         addEdge(point1: Vector2, point2: Vector2, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any;
-        /** Add an edge loop to the body, an edge loop connects the end points
+        /** Add an edge list to the body
          *  @param {Array<Vector2>} points
          *  @param {number}  [density]
          *  @param {number}  [friction]
          *  @param {number}  [restitution]
          *  @param {boolean} [isSensor] */
-        addEdgeLoop(points: Array<Vector2>, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any[];
-        /** Add an edge list to the body
+        addEdgeList(points: Array<Vector2>, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any[];
+        /** Add an edge loop to the body, an edge loop connects the end points
          *  @param {Array<Vector2>} points
          *  @param {number}  [density]
          *  @param {number}  [friction]
          *  @param {number}  [restitution]
          *  @param {boolean} [isSensor] */
-        addEdgeList(points: Array<Vector2>, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any[];
+        addEdgeLoop(points: Array<Vector2>, density?: number, friction?: number, restitution?: number, isSensor?: boolean): any[];
         /** Gets the center of mass
          *  @return {Vector2} */
         getCenterOfMass(): Vector2;
@@ -3519,7 +3668,7 @@ declare module "littlejsengine" {
         /** Sets the gravity scale
          *  @param {number} [scale] */
         setGravityScale(scale?: number): void;
-        /** Should this body be treated like a bullet for continuous collision detection?
+        /** Should be like a bullet for continuous collision detection?
          *  @param {boolean} [isBullet] */
         setBullet(isBullet?: boolean): void;
         /** Set the sleep state of the body
@@ -3582,6 +3731,36 @@ declare module "littlejsengine" {
          *  @return {Array<Object>} */
         getJointList(): Array<any>;
     }
+    /**
+     * Box2D Static Object - Box2d with a static physics body
+     * @extends Box2dObject
+     * @memberof Box2D
+     */
+    export class Box2dStaticObject extends Box2dObject {
+        /** Create a LittleJS object with Box2d physics
+         *  @param {Vector2}  [pos]
+         *  @param {Vector2}  [size]
+         *  @param {TileInfo} [tileInfo]
+         *  @param {number}   [angle]
+         *  @param {Color}    [color]
+         *  @param {number}   [renderOrder] */
+        constructor(pos?: Vector2, size?: Vector2, tileInfo?: TileInfo, angle?: number, color?: Color, renderOrder?: number);
+    }
+    /**
+     * Box2D Kiematic Object - Box2d with a kinematic physics body
+     * @extends Box2dObject
+     * @memberof Box2D
+     */
+    export class Box2dKiematicObject extends Box2dObject {
+        /** Create a LittleJS object with Box2d physics
+         *  @param {Vector2}  [pos]
+         *  @param {Vector2}  [size]
+         *  @param {TileInfo} [tileInfo]
+         *  @param {number}   [angle]
+         *  @param {Color}    [color]
+         *  @param {number}   [renderOrder] */
+        constructor(pos?: Vector2, size?: Vector2, tileInfo?: TileInfo, angle?: number, color?: Color, renderOrder?: number);
+    }
     /**
      * Box2D Raycast Result
      * - Holds results from a box2d raycast queries