littlejsengine 1.14.19 → 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
@@ -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]
@@ -911,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
@@ -1442,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
@@ -2325,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;
@@ -2385,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
@@ -2456,6 +2548,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 +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
@@ -2574,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
@@ -2685,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;