littlejsengine 1.14.28 → 1.15.3

package/dist/littlejs.d.ts

@@ -105,7 +105,7 @@ declare module "littlejsengine" {
     export function setPaused(isPaused?: boolean): void;
     /**
      * @callback GameInitCallback - Called after the engine starts, can be async
-     * @returns {void|Promise<void>}
+     * @return {void|Promise<void>}
      * @memberof Engine
      */
     /**
@@ -139,10 +139,10 @@ declare module "littlejsengine" {
      *  @memberof Engine */
     export function engineObjectsDestroy(): void;
     /** Collects all object within a given area
-     *  @param {Vector2} [pos]                 - Center of test area, or undefined for all objects
-     *  @param {Vector2|number} [size]         - Radius of circle if float, rectangle size if Vector2
+     *  @param {Vector2} [pos] - Center of test area, or undefined for all objects
+     *  @param {Vector2|number} [size] - Radius of circle if float, rectangle size if Vector2
      *  @param {Array<EngineObject>} [objects=engineObjects] - List of objects to check
-     *  @return {Array<EngineObject>}                        - List of collected objects
+     *  @return {Array<EngineObject>} - List of collected objects
      *  @memberof Engine */
     export function engineObjectsCollect(pos?: Vector2, size?: Vector2 | number, objects?: Array<EngineObject>): Array<EngineObject>;
     /**
@@ -216,8 +216,9 @@ declare module "littlejsengine" {
      *  @param {number} [time]
      *  @param {number} [angle]
      *  @param {boolean} [fill]
+     *  @param {boolean} [screenSpace]
      *  @memberof Debug */
-    export function debugRect(pos: Vector2, size?: Vector2, color?: Color | string, time?: number, angle?: number, fill?: boolean): void;
+    export function debugRect(pos: Vector2, size?: Vector2, color?: Color | string, time?: number, angle?: number, fill?: boolean, screenSpace?: boolean): void;
     /** Draw a debug poly in world space
      *  @param {Vector2} pos
      *  @param {Array<Vector2>} points
@@ -225,39 +226,45 @@ declare module "littlejsengine" {
      *  @param {number} [time]
      *  @param {number} [angle]
      *  @param {boolean} [fill]
+     *  @param {boolean} [screenSpace]
      *  @memberof Debug */
-    export function debugPoly(pos: Vector2, points: Array<Vector2>, color?: Color | string, time?: number, angle?: number, fill?: boolean): void;
+    export function debugPoly(pos: Vector2, points: Array<Vector2>, color?: Color | string, time?: number, angle?: number, fill?: boolean, screenSpace?: boolean): void;
     /** Draw a debug circle in world space
      *  @param {Vector2} pos
      *  @param {number} [size] - diameter
      *  @param {Color|string} [color]
      *  @param {number} [time]
      *  @param {boolean} [fill]
+     *  @param {boolean} [screenSpace]
      *  @memberof Debug */
-    export function debugCircle(pos: Vector2, size?: number, color?: Color | string, time?: number, fill?: boolean): void;
+    export function debugCircle(pos: Vector2, size?: number, color?: Color | string, time?: number, fill?: boolean, screenSpace?: boolean): void;
     /** Draw a debug point in world space
      *  @param {Vector2} pos
      *  @param {Color|string} [color]
      *  @param {number} [time]
      *  @param {number} [angle]
+     *  @param {boolean} [screenSpace]
      *  @memberof Debug */
-    export function debugPoint(pos: Vector2, color?: Color | string, time?: number, angle?: number): void;
+    export function debugPoint(pos: Vector2, color?: Color | string, time?: number, angle?: number, screenSpace?: boolean): void;
     /** Draw a debug line in world space
      *  @param {Vector2} posA
      *  @param {Vector2} posB
      *  @param {Color|string} [color]
      *  @param {number} [width]
      *  @param {number} [time]
+     *  @param {boolean} [screenSpace]
      *  @memberof Debug */
-    export function debugLine(posA: Vector2, posB: Vector2, color?: Color | string, width?: number, time?: number): void;
+    export function debugLine(posA: Vector2, posB: Vector2, color?: Color | string, width?: number, time?: number, screenSpace?: boolean): void;
     /** Draw a debug combined axis aligned bounding box in world space
      *  @param {Vector2} posA
      *  @param {Vector2} sizeA
      *  @param {Vector2} posB
      *  @param {Vector2} sizeB
      *  @param {Color|string} [color]
+     *  @param {number} [time]
+     *  @param {boolean} [screenSpace]
      *  @memberof Debug */
-    export function debugOverlap(posA: Vector2, sizeA: Vector2, posB: Vector2, sizeB: Vector2, color?: Color | string): void;
+    export function debugOverlap(posA: Vector2, sizeA: Vector2, posB: Vector2, sizeB: Vector2, color?: Color | string, time?: number, screenSpace?: boolean): void;
     /** Draw a debug axis aligned bounding box in world space
      *  @param {string} text
      *  @param {Vector2} pos
@@ -266,8 +273,9 @@ declare module "littlejsengine" {
      *  @param {number} [time]
      *  @param {number} [angle]
      *  @param {string} [font]
+     *  @param {boolean} [screenSpace]
      *  @memberof Debug */
-    export function debugText(text: string, pos: Vector2, size?: number, color?: Color | string, time?: number, angle?: number, font?: string): void;
+    export function debugText(text: string, pos: Vector2, size?: number, color?: Color | string, time?: number, angle?: number, font?: string, screenSpace?: boolean): void;
     /** Clear all debug primitives in the list
      *  @memberof Debug */
     export function debugClear(): void;
@@ -813,7 +821,7 @@ declare module "littlejsengine" {
      *  @param {number} valueA
      *  @param {number} valueB
      *  @param {number} [wrapSize]
-     *  @returns {number}
+     *  @return {number}
      *  @memberof Utilities */
     export function distanceWrap(valueA: number, valueB: number, wrapSize?: number): number;
     /** Linearly interpolates between values passed in with wrapping
@@ -821,20 +829,20 @@ declare module "littlejsengine" {
      *  @param {number} valueB
      *  @param {number} percent
      *  @param {number} [wrapSize]
-     *  @returns {number}
+     *  @return {number}
      *  @memberof Utilities */
     export function lerpWrap(valueA: number, valueB: number, percent: number, wrapSize?: number): number;
     /** Returns signed wrapped distance between the two angles passed in
      *  @param {number} angleA
      *  @param {number} angleB
-     *  @returns {number}
+     *  @return {number}
      *  @memberof Utilities */
     export function distanceAngle(angleA: number, angleB: number): number;
     /** Linearly interpolates between the angles passed in with wrapping
      *  @param {number} angleA
      *  @param {number} angleB
      *  @param {number} percent
-     *  @returns {number}
+     *  @return {number}
      *  @memberof Utilities */
     export function lerpAngle(angleA: number, angleB: number, percent: number): number;
     /** Linearly interpolates between values passed in using percent
@@ -1229,13 +1237,18 @@ declare module "littlejsengine" {
      */
     export class Timer {
         /** Create a timer object set time passed in
-         *  @param {number} [timeLeft] - How much time left before the timer elapses in seconds */
-        constructor(timeLeft?: number);
+         *  @param {number} [timeLeft] - How much time left before the timer
+         *  @param {boolean} [useRealTime] - Should the timer keep running even when the game is paused? (useful for UI) */
+        constructor(timeLeft?: number, useRealTime?: boolean);
+        useRealTime: boolean;
         time: number;
         setTime: number;
         /** Set the timer with seconds passed in
          *  @param {number} [timeLeft] - How much time left before the timer is elapsed in seconds */
         set(timeLeft?: number): void;
+        /** Set if the timer should keep running even when the game is paused
+         *  @param {boolean} [useRealTime] */
+        setUseRealTime(useRealTime?: boolean): void;
         /** Unset the timer */
         unset(): void;
         /** Returns true if set
@@ -1256,6 +1269,9 @@ declare module "littlejsengine" {
         /** Get the time this timer was set to, returns 0 if not set
          * @return {number} */
         getSetTime(): number;
+        /** Get the current global time this timer is based on
+         * @return {number} */
+        getGlobalTime(): number;
         /** Returns this timer expressed as a string
          * @return {string} */
         toString(): string;
@@ -3138,6 +3154,12 @@ declare module "littlejsengine" {
         defaultSoundRelease: any;
         /** @property {Sound} - Default sound when interactive UI element is clicked */
         defaultSoundClick: any;
+        /** @property {Color} - Color for shadow */
+        defaultShadowColor: Color;
+        /** @property {number} - Size of shadow blur */
+        defaultShadowBlur: number;
+        /** @property {Vector2} - Offset of shadow blur */
+        defaultShadowOffset: Vector2;
         /** @property {Array<UIObject>} - List of all UI elements */
         uiObjects: any[];
         /** @property {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} - Context to render UI elements to */
@@ -3157,8 +3179,11 @@ declare module "littlejsengine" {
         *  @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;
+        *  @param {Color}   [gradientColor]
+        *  @param {Color}   [shadowColor]
+        *  @param {number}  [shadowBlur]
+        *  @param {Color}   [shadowOffset] */
+        drawRect(pos: Vector2, size: Vector2, color?: Color, lineWidth?: number, lineColor?: Color, cornerRadius?: number, gradientColor?: Color, shadowColor?: Color, shadowBlur?: number, shadowOffset?: Color): void;
         /** Draw a line to the UI context
         *  @param {Vector2} posA
         *  @param {Vector2} posB
@@ -3204,6 +3229,9 @@ declare module "littlejsengine" {
          *  @return {Vector2}
          */
         screenToNative(pos: Vector2): Vector2;
+        /** Destroy and remove all objects
+        *  @memberof Engine */
+        destroyObjects(): void;
     }
     /**
      * UI Object - Base level object for all UI elements
@@ -3272,6 +3300,12 @@ declare module "littlejsengine" {
         dragActivate: boolean;
         /** @property {boolean} - True if this can be a hover object */
         canBeHover: boolean;
+        /** @property {Color} - Color for shadow, undefined if no shadow */
+        shadowColor: Color;
+        /** @property {number} - Size of shadow blur */
+        shadowBlur: number;
+        /** @property {Vector2} - Offset of shadow blur */
+        shadowOffset: Vector2;
         /** @property {Vector2} - How much to offset the text shadow or undefined */
         textShadow: any;
         /** Add a child UIObject to this object
@@ -3282,6 +3316,9 @@ declare module "littlejsengine" {
          *  @param {UIObject} child
          */
         removeChild(child: UIObject): void;
+        /** Destroy this object, destroy its children, detach its parent, and mark it for removal */
+        destroy(): void;
+        destroyed: number;
         /** Check if the mouse is overlapping a box in screen space
          *  @return {boolean} - True if overlapping
          */
@@ -3408,6 +3445,67 @@ declare module "littlejsengine" {
         handleColor: Color;
         text: string;
     }
+    /**
+     * VideoPlayerUIObject - A UI object that plays video
+     * @extends UIObject
+     * @example
+     * // Create a video player UI object
+     * const video = new VideoPlayerUIObject(vec2(400, 300), vec2(320, 240), 'cutscene.mp4', true);
+     * video.play();
+     * @memberof UISystem
+     */
+    export class UIVideo extends UIObject {
+        /** Create a video player UI object
+         *  @param {Vector2} [pos]
+         *  @param {Vector2} [size]
+         *  @param {string} src - Video file path or URL
+         *  @param {boolean} [autoplay=false] - Start playing immediately?
+         *  @param {boolean} [loop=false] - Loop the video?
+         *  @param {number} [volume=1] - Volume percent scaled by global volume (0-1)
+         */
+        constructor(pos?: Vector2, size?: Vector2, src: string, autoplay?: boolean, loop?: boolean, volume?: number);
+        /** @property {float} - The video volume */
+        volume: number;
+        /** @property {HTMLVideoElement} - The video player */
+        video: HTMLVideoElement;
+        /** Play or resume the video
+         *  @return {Promise} Promise that resolves when playback starts */
+        play(): Promise<any>;
+        /** Pause the video */
+        pause(): void;
+        /** Stop and reset the video */
+        stop(): void;
+        /** Check if video is currently loading
+         *  @return {boolean} */
+        isLoadng(): boolean;
+        /** Check if video is currently paused
+         *  @return {boolean} */
+        isPaused(): boolean;
+        /** Check if video is currently playing
+         *  @return {boolean} */
+        isPlaying(): boolean;
+        /** Check if video has ended playing
+         *  @return {boolean} */
+        hasEnded(): boolean;
+        /** Set volume (0-1)
+         *  @param {number} volume - Volume level (0-1) */
+        setVolume(volume: number): void;
+        /** Set playback speed
+         *  @param {number} rate - Playback rate multiplier */
+        setPlaybackRate(rate: number): void;
+        /** Get current time in seconds
+         *  @return {number} Current playback time */
+        getCurrentTime(): number;
+        /** Get duration in seconds
+         *  @return {number} Total video duration */
+        getDuration(): number;
+        /** Get the native video dimensions
+         *  @return {Vector2} Video dimensions (may be 0,0 if metadata not loaded) */
+        getVideoSize(): Vector2;
+        /** Seek to time in seconds
+         *  @param {number} time - Time in seconds to seek to */
+        setTime(time: number): void;
+    }
     /**
      * LittleJS Box2D Physics Plugin
      * - Box2dObject extends EngineObject with Box2D physics