littlejsengine 1.6.6 → 1.7.1

package/build/littlejs.d.ts

@@ -1,7 +1,7 @@
 declare module "littlejs.esm" {
     /**
      * LittleJS Module Export
-     * - Export engine as a module with extra functions where necessary
+     * - Export engine as a module with functions where necessary
      */
     /** Set position of camera in world space
      *  @param {Vector2} pos
@@ -146,15 +146,11 @@ declare module "littlejs.esm" {
     /** Set to stop medals from being unlockable
      *  @param {Boolean} preventUnlock
      *  @memberof Settings */
-    export function setMedalsPreventUnlock(prevent: any): void;
+    export function setMedalsPreventUnlock(preventUnlock: boolean): void;
     /** Set if watermark with FPS should be shown
      *  @param {Boolean} show
      *  @memberof Debug */
     export function setShowWatermark(show: boolean): void;
-    /** Set if god mode is enabled
-     *  @param {Boolean} enable
-     *  @memberof Debug */
-    export function setGodMode(enable: boolean): void;
     /** Set key code used to toggle debug mode, Esc by default
      *  @param {Number} key
      *  @memberof Debug */
@@ -347,11 +343,6 @@ declare module "littlejs.esm" {
      *  @default
      *  @memberof Debug */
     export let showWatermark: boolean;
-    /** True if god mode is enabled, handle this however you want
-     *  @type {Boolean}
-     *  @default
-     *  @memberof Debug */
-    export let godMode: boolean;
     /** Asserts if the experssion is false, does not do anything in release builds
      *  @param {Boolean} assertion
      *  @param {Object}  output
@@ -413,8 +404,9 @@ declare module "littlejs.esm" {
     /** 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): void;
+    export function debugSaveCanvas(canvas: HTMLCanvasElement, filename?: string, type?: string): void;
     /** A shortcut to get Math.PI
      *  @type {Number}
      *  @default Math.PI
@@ -424,69 +416,97 @@ declare module "littlejs.esm" {
      *  @param {Number} value
      *  @return {Number}
      *  @memberof Utilities */
-    export function abs(a: any): number;
+    export function abs(value: number): number;
     /** Returns lowest of two values passed in
      *  @param {Number} valueA
      *  @param {Number} valueB
      *  @return {Number}
      *  @memberof Utilities */
-    export function min(a: any, b: any): number;
+    export function min(valueA: number, valueB: number): number;
     /** Returns highest of two values passed in
      *  @param {Number} valueA
      *  @param {Number} valueB
      *  @return {Number}
      *  @memberof Utilities */
-    export function max(a: any, b: any): number;
+    export function max(valueA: number, valueB: number): number;
     /** Returns the sign of value passed in (also returns 1 if 0)
      *  @param {Number} value
      *  @return {Number}
      *  @memberof Utilities */
-    export function sign(a: any): number;
+    export function sign(value: number): number;
     /** Returns first parm modulo the second param, but adjusted so negative numbers work as expected
      *  @param {Number} dividend
      *  @param {Number} [divisor=1]
      *  @return {Number}
      *  @memberof Utilities */
-    export function mod(a: any, b?: number): number;
+    export function mod(dividend: number, divisor?: number): number;
     /** Clamps the value beween max and min
      *  @param {Number} value
      *  @param {Number} [min=0]
      *  @param {Number} [max=1]
      *  @return {Number}
      *  @memberof Utilities */
-    export function clamp(v: any, min?: number, max?: number): number;
-    /** Returns what percentage the value is between max and min
+    export function clamp(value: number, min?: number, max?: number): number;
+    /** Returns what percentage the value is between valueA and valueB
      *  @param {Number} value
-     *  @param {Number} [min=0]
-     *  @param {Number} [max=1]
+     *  @param {Number} valueA
+     *  @param {Number} valueB
      *  @return {Number}
      *  @memberof Utilities */
-    export function percent(v: any, min?: number, max?: number): number;
-    /** Linearly interpolates the percent value between max and min
+    export function percent(value: number, valueA: number, valueB: number): number;
+    /** Returns signed wrapped distance between the two values passed in
+     *  @param {Number} valueA
+     *  @param {Number} valueB
+     *  @param {Number} [wrapSize=1]
+     *  @returns {Number}
+     *  @memberof Utilities */
+    export function distanceWrap(valueA: number, valueB: number, wrapSize?: number): number;
+    /** Linearly interpolates between values passed in with wrappping
      *  @param {Number} percent
-     *  @param {Number} [min=0]
-     *  @param {Number} [max=1]
+     *  @param {Number} valueA
+     *  @param {Number} valueB
+     *  @param {Number} [wrapSize=1]
+     *  @returns {Number}
+     *  @memberof Utilities */
+    export function lerpWrap(percent: number, valueA: number, valueB: number, wrapSize?: number): number;
+    /** Returns signed wrapped distance between the two angles passed in
+     *  @param {Number} angleA
+     *  @param {Number} angleB
+     *  @returns {Number}
+     *  @memberof Utilities */
+    export function distanceAngle(angleA: number, angleB: number): number;
+    /** Linearly interpolates between the angles passed in with wrappping
+     *  @param {Number} percent
+     *  @param {Number} angleA
+     *  @param {Number} angleB
+     *  @returns {Number}
+     *  @memberof Utilities */
+    export function lerpAngle(percent: number, angleA: number, angleB: number): number;
+    /** Linearly interpolates between values passed in using percent
+     *  @param {Number} percent
+     *  @param {Number} valueA
+     *  @param {Number} valueB
      *  @return {Number}
      *  @memberof Utilities */
-    export function lerp(p: any, min?: number, max?: number): number;
+    export function lerp(percent: number, valueA: number, valueB: number): number;
     /** Applies smoothstep function to the percentage value
-     *  @param {Number} value
+     *  @param {Number} percent
      *  @return {Number}
      *  @memberof Utilities */
-    export function smoothStep(p: any): number;
+    export function smoothStep(percent: number): number;
     /** Returns the nearest power of two not less then the value
      *  @param {Number} value
      *  @return {Number}
      *  @memberof Utilities */
-    export function nearestPowerOfTwo(v: any): number;
+    export function nearestPowerOfTwo(value: number): number;
     /** Returns true if two axis aligned bounding boxes are overlapping
      *  @param {Vector2} pointA  - Center of box A
      *  @param {Vector2} sizeA   - Size of box A
      *  @param {Vector2} pointB  - Center of box B
-     *  @param {Vector2} [sizeB] - Size of box B
+     *  @param {Vector2} sizeB   - Size of box B
      *  @return {Boolean}        - True if overlapping
      *  @memberof Utilities */
-    export function isOverlapping(pA: any, sA: any, pB: any, sB: any): boolean;
+    export function isOverlapping(pointA: Vector2, sizeA: Vector2, pointB: Vector2, sizeB: Vector2): boolean;
     /** Returns an oscillating wave between 0 and amplitude with frequency of 1 Hz by default
      *  @param {Number} [frequency=1] - Frequency of the wave in Hz
      *  @param {Number} [amplitude=1] - Amplitude (max height) of the wave
@@ -506,13 +526,13 @@ declare module "littlejs.esm" {
      *  @param {Number} [valueB=0]
      *  @return {Number}
      *  @memberof Random */
-    export function rand(a?: number, b?: number): number;
+    export function rand(valueA?: number, valueB?: number): number;
     /** Returns a floored random value the two values passed in
-     *  @param {Number} [valueA=1]
+     *  @param {Number} valueA
      *  @param {Number} [valueB=0]
      *  @return {Number}
      *  @memberof Random */
-    export function randInt(a?: number, b?: number): number;
+    export function randInt(valueA: number, valueB?: number): number;
     /** Randomly returns either -1 or 1
      *  @return {Number}
      *  @memberof Random */
@@ -534,22 +554,37 @@ declare module "littlejs.esm" {
      *  @param {Boolean} [linear]
      *  @return {Color}
      *  @memberof Random */
-    export function randColor(cA?: Color, cB?: Color, linear?: boolean): Color;
-    /** Seed used by the randSeeded function
-     *  @type {Number}
-     *  @default
-     *  @memberof Random */
-    export let randSeed: number;
-    /** Set seed used by the randSeeded function, should not be 0
-     *  @param {Number} seed
-     *  @memberof Random */
-    export function setRandSeed(seed: number): void;
-    /** Returns a seeded random value between the two values passed in using randSeed
-     *  @param {Number} [valueA=1]
-     *  @param {Number} [valueB=0]
-     *  @return {Number}
-     *  @memberof Random */
-    export function randSeeded(a?: number, b?: number): number;
+    export function randColor(colorA?: Color, colorB?: Color, linear?: boolean): Color;
+    /**
+     * Seeded random number generator
+     * - 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
+     * r.seed = 123;                     // reset the seed
+     * let c = r.rand();                 // the same value as a
+     */
+    export class RandomGenerator {
+        /** Create a random number generator with the seed passed in
+         *  @param {Number} seed - Starting seed */
+        constructor(seed: number);
+        /** @property {Number} - random seed */
+        seed: number;
+        /** Returns a seeded random value between the two values passed in
+        *  @param {Number} [valueA=1]
+        *  @param {Number} [valueB=0]
+        *  @return {Number} */
+        float(valueA?: number, valueB?: number): number;
+        /** Returns a floored seeded random value the two values passed in
+        *  @param {Number} valueA
+        *  @param {Number} [valueB=0]
+        *  @return {Number} */
+        int(valueA: number, valueB?: number): number;
+        /** Randomly returns either -1 or 1 deterministically
+        *  @return {Number} */
+        sign(): number;
+    }
     /**
      * 2D Vector object with vector math library
      * - Functions do not change this so they can be chained together
@@ -572,25 +607,25 @@ declare module "littlejs.esm" {
          *  @return {Vector2} */
         copy(): Vector2;
         /** Returns a copy of this vector plus the vector passed in
-         *  @param {Vector2} vector
+         *  @param {Vector2} v - other vector
          *  @return {Vector2} */
-        add(v: any): Vector2;
+        add(v: Vector2): Vector2;
         /** Returns a copy of this vector minus the vector passed in
-         *  @param {Vector2} vector
+         *  @param {Vector2} v - other vector
          *  @return {Vector2} */
-        subtract(v: any): Vector2;
+        subtract(v: Vector2): Vector2;
         /** Returns a copy of this vector times the vector passed in
-         *  @param {Vector2} vector
+         *  @param {Vector2} v - other vector
          *  @return {Vector2} */
-        multiply(v: any): Vector2;
+        multiply(v: Vector2): Vector2;
         /** Returns a copy of this vector divided by the vector passed in
-         *  @param {Vector2} vector
+         *  @param {Vector2} v - other vector
          *  @return {Vector2} */
-        divide(v: any): Vector2;
+        divide(v: Vector2): Vector2;
         /** Returns a copy of this vector scaled by the vector passed in
-         *  @param {Number} scale
+         *  @param {Number} s - scale
          *  @return {Vector2} */
-        scale(s: any): Vector2;
+        scale(s: number): Vector2;
         /** Returns the length of this vector
          * @return {Number} */
         length(): number;
@@ -598,13 +633,13 @@ declare module "littlejs.esm" {
          * @return {Number} */
         lengthSquared(): number;
         /** Returns the distance from this vector to vector passed in
-         * @param {Vector2} vector
+         * @param {Vector2} v - other vector
          * @return {Number} */
-        distance(v: any): number;
+        distance(v: Vector2): number;
         /** Returns the distance squared from this vector to vector passed in
-         * @param {Vector2} vector
+         * @param {Vector2} v - other vector
          * @return {Number} */
-        distanceSquared(v: any): number;
+        distanceSquared(v: Vector2): number;
         /** Returns a new vector in same direction as this one with the length passed in
          * @param {Number} [length=1]
          * @return {Vector2} */
@@ -614,13 +649,13 @@ declare module "littlejs.esm" {
          * @return {Vector2} */
         clampLength(length?: number): Vector2;
         /** Returns the dot product of this and the vector passed in
-         * @param {Vector2} vector
+         * @param {Vector2} v - other vector
          * @return {Number} */
-        dot(v: any): number;
+        dot(v: Vector2): number;
         /** Returns the cross product of this and the vector passed in
-         * @param {Vector2} vector
+         * @param {Vector2} v - other vector
          * @return {Number} */
-        cross(v: any): number;
+        cross(v: Vector2): number;
         /** Returns the angle of this vector, up is angle 0
          * @return {Number} */
         angle(): number;
@@ -628,11 +663,11 @@ declare module "littlejs.esm" {
          * @param {Number} [angle=0]
          * @param {Number} [length=1]
          * @return {Vector2} */
-        setAngle(a?: number, length?: number): Vector2;
+        setAngle(angle?: number, length?: number): Vector2;
         /** Returns copy of this vector rotated by the angle passed in
          * @param {Number} angle
          * @return {Vector2} */
-        rotate(a: any): Vector2;
+        rotate(angle: number): Vector2;
         /** Returns the integer direction of this vector, corrosponding to multiples of 90 degree rotation (0-3)
          * @return {Number} */
         direction(): number;
@@ -646,10 +681,10 @@ declare module "littlejs.esm" {
          * @return {Number} */
         area(): number;
         /** Returns a new vector that is p percent between this and the vector passed in
-         * @param {Vector2} vector
+         * @param {Vector2} v - other vector
          * @param {Number}  percent
          * @return {Vector2} */
-        lerp(v: any, p: any): Vector2;
+        lerp(v: Vector2, percent: number): Vector2;
         /** Returns true if this vector is within the bounds of an array size passed in
          * @param {Vector2} arraySize
          * @return {Boolean} */
@@ -669,11 +704,11 @@ declare module "littlejs.esm" {
      * let e = HSL(.3, 1, .5);         // green using hsl color
      */
     export class Color {
-        /** Create a color with the components passed in, white by default
-         *  @param {Number} [red=1]
-         *  @param {Number} [green=1]
-         *  @param {Number} [blue=1]
-         *  @param {Number} [alpha=1] */
+        /** Create a color with the rgba components passed in, white by default
+         *  @param {Number} [r=1] - red
+         *  @param {Number} [g=1] - green
+         *  @param {Number} [b=1] - blue
+         *  @param {Number} [a=1] - alpha*/
         constructor(r?: number, g?: number, b?: number, a?: number);
         /** @property {Number} - Red */
         r: number;
@@ -687,39 +722,39 @@ declare module "littlejs.esm" {
          * @return {Color} */
         copy(): Color;
         /** Returns a copy of this color plus the color passed in
-         * @param {Color} color
+         * @param {Color} c - other color
          * @return {Color} */
-        add(c: any): Color;
+        add(c: Color): Color;
         /** Returns a copy of this color minus the color passed in
-         * @param {Color} color
+         * @param {Color} c - other color
          * @return {Color} */
-        subtract(c: any): Color;
+        subtract(c: Color): Color;
         /** Returns a copy of this color times the color passed in
-         * @param {Color} color
+         * @param {Color} c - other color
          * @return {Color} */
-        multiply(c: any): Color;
+        multiply(c: Color): Color;
         /** Returns a copy of this color divided by the color passed in
-         * @param {Color} color
+         * @param {Color} c - other color
          * @return {Color} */
-        divide(c: any): Color;
+        divide(c: Color): Color;
         /** Returns a copy of this color scaled by the value passed in, alpha can be scaled separately
          * @param {Number} scale
          * @param {Number} [alphaScale=scale]
          * @return {Color} */
-        scale(s: any, a?: any): Color;
+        scale(scale: number, alphaScale?: number): Color;
         /** Returns a copy of this color clamped to the valid range between 0 and 1
          * @return {Color} */
         clamp(): Color;
         /** Returns a new color that is p percent between this and the color passed in
-         * @param {Color}  color
+         * @param {Color}  c - other color
          * @param {Number} percent
          * @return {Color} */
-        lerp(c: any, p: any): Color;
+        lerp(c: Color, percent: number): Color;
         /** Sets this color given a hue, saturation, lightness, and alpha
-         * @param {Number} [hue=0]
-         * @param {Number} [saturation=0]
-         * @param {Number} [lightness=1]
-         * @param {Number} [alpha=1]
+         * @param {Number} [h=0] - hue
+         * @param {Number} [s=0] - saturation
+         * @param {Number} [l=1] - lightness
+         * @param {Number} [a=1] - alpha
          * @return {Color} */
         setHSLA(h?: number, s?: number, l?: number, a?: number): Color;
         /** Returns this color expressed in hsla format
@@ -799,32 +834,32 @@ declare module "littlejs.esm" {
     export function vec2(x?: number, y?: number): Vector2;
     /**
      * Create a color object with RGBA values
-     * @param {Number} [r=1]
-     * @param {Number} [g=1]
-     * @param {Number} [b=1]
-     * @param {Number} [a=1]
+     * @param {Number} [r=1] - red
+     * @param {Number} [g=1] - green
+     * @param {Number} [b=1] - blue
+     * @param {Number} [a=1] - alpha
      * @return {Color}
      * @memberof Utilities
      */
     export function rgb(r?: number, g?: number, b?: number, a?: number): Color;
     /**
      * Create a color object with HSLA values
-     * @param {Number} [h=0]
-     * @param {Number} [s=0]
-     * @param {Number} [l=1]
-     * @param {Number} [a=1]
+     * @param {Number} [h=0] - hue
+     * @param {Number} [s=0] - saturation
+     * @param {Number} [l=1] - lightness
+     * @param {Number} [a=1] - alpha
      * @return {Color}
      * @memberof Utilities
      */
     export function hsl(h?: number, s?: number, l?: number, a?: number): Color;
     /**
      * LittleJS Object Base Object Class
-     * - Base object class used by the engine
+     * - 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
+     * - 2D Physics and collision system
      * - Sorted by renderOrder
      * - Objects can have children attached
      * - Parents are updated before children, and set child transform
@@ -908,13 +943,13 @@ declare module "littlejs.esm" {
          *  @param {EngineObject} object - the object to test against
          *  @return {Boolean}            - true if the collision should be resolved
          */
-        collideWithObject(o: any): boolean;
+        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(a: any): void;
+        applyAcceleration(acceleration: Vector2): void;
         /** Apply force to this object (adjust velocity, affected by mass)
          *  @param {Vector2} force */
         applyForce(force: Vector2): void;
@@ -965,13 +1000,11 @@ declare module "littlejs.esm" {
      *  @memberof Draw */
     export let mainCanvasSize: Vector2;
     /** Convert from screen to world space coordinates
-     *  - if calling outside of render, you may need to manually set mainCanvasSize
      *  @param {Vector2} screenPos
      *  @return {Vector2}
      *  @memberof Draw */
     export function screenToWorld(screenPos: Vector2): Vector2;
     /** Convert from world to screen space coordinates
-     *  - if calling outside of render, you may need to manually set mainCanvasSize
      *  @param {Vector2} worldPos
      *  @return {Vector2}
      *  @memberof Draw */
@@ -986,42 +1019,25 @@ declare module "littlejs.esm" {
      *  @param {Boolean} [mirror=0]                     - If true image is flipped along the Y axis
      *  @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
      *  @memberof Draw */
-    export function drawTile(pos: Vector2, size?: Vector2, tileIndex?: number, tileSize?: Vector2, color?: Color, angle?: number, mirror?: boolean, additiveColor?: Color, useWebGL?: boolean): void;
+    export function drawTile(pos: Vector2, size?: Vector2, tileIndex?: number, tileSize?: Vector2, color?: Color, angle?: number, mirror?: boolean, additiveColor?: Color, useWebGL?: boolean, screenSpace?: boolean): void;
     /** Draw colored rect centered on pos
      *  @param {Vector2} pos
      *  @param {Vector2} [size=Vector2(1,1)]
      *  @param {Color}   [color=Color()]
      *  @param {Number}  [angle=0]
      *  @param {Boolean} [useWebGL=glEnable]
+     *  @param {Boolean} [screenSpace=0]
      *  @memberof Draw */
-    export function drawRect(pos: Vector2, size?: Vector2, color?: Color, angle?: number, useWebGL?: boolean): void;
-    /** Draw textured tile centered on pos in screen space
-     *  @param {Vector2} pos                        - Center of the tile
-     *  @param {Vector2} [size=Vector2(1,1)]    - Size of the tile
-     *  @param {Number}  [tileIndex=-1]             - Tile index to use, negative is untextured
-     *  @param {Vector2} [tileSize=tileSizeDefault] - Tile size in source pixels
-     *  @param {Color}   [color=Color()]
-     *  @param {Number}  [angle=0]
-     *  @param {Boolean} [mirror=0]
-     *  @param {Color}   [additiveColor=Color(0,0,0,0)]
-     *  @param {Boolean} [useWebGL=glEnable]
-     *  @memberof Draw */
-    export function drawTileScreenSpace(pos: Vector2, size?: Vector2, tileIndex?: number, tileSize?: Vector2, color?: Color, angle?: number, mirror?: boolean, additiveColor?: Color, useWebGL?: boolean): void;
-    /** Draw colored rectangle in screen space
-     *  @param {Vector2} pos
-     *  @param {Vector2} [size=Vector2(1,1)]
-     *  @param {Color}   [color=Color()]
-     *  @param {Number}  [angle=0]
-     *  @param {Boolean} [useWebGL=glEnable]
-     *  @memberof Draw */
-    export function drawRectScreenSpace(pos: Vector2, size?: Vector2, color?: Color, angle?: number, useWebGL?: boolean): void;
+    export function drawRect(pos: Vector2, size?: Vector2, color?: Color, angle?: number, useWebGL?: boolean, screenSpace?: boolean): void;
     /** Draw colored line between two points
      *  @param {Vector2} posA
      *  @param {Vector2} posB
      *  @param {Number}  [thickness=.1]
      *  @param {Color}   [color=Color()]
      *  @param {Boolean} [useWebGL=glEnable]
+     *  @param {Boolean} [screenSpace=0]
      *  @memberof Draw */
     export function drawLine(posA: Vector2, posB: Vector2, thickness?: number, color?: Color, useWebGL?: boolean): void;
     /** Draw directly to a 2d canvas context in world space
@@ -1031,8 +1047,9 @@ declare module "littlejs.esm" {
      *  @param {Boolean}  mirror
      *  @param {Function} drawFunction
      *  @param {CanvasRenderingContext2D} [context=mainContext]
+     *  @param {Boolean} [screenSpace=0]
      *  @memberof Draw */
-    export function drawCanvas2D(pos: Vector2, size: Vector2, angle: number, mirror: boolean, drawFunction: Function, context?: CanvasRenderingContext2D): void;
+    export function drawCanvas2D(pos: Vector2, size: Vector2, angle: number, mirror: boolean, drawFunction: Function, context?: CanvasRenderingContext2D, screenSpace?: boolean): void;
     /** Enable normal or additive blend mode
      *  @param {Boolean} [additive=0]
      *  @param {Boolean} [useWebGL=glEnable]
@@ -1091,20 +1108,20 @@ declare module "littlejs.esm" {
         paddingSize: Vector2;
         startTileIndex: number;
         context: CanvasRenderingContext2D;
-        /** Draw text in screen space using the image font
+        /** Draw text in world space using the image font
          *  @param {String}  text
          *  @param {Vector2} pos
-         *  @param {Number}  [scale=4]
+         *  @param {Number}  [scale=.25]
          *  @param {Boolean} [center]
          */
-        drawTextScreen(text: string, pos: Vector2, scale?: number, center?: boolean): void;
-        /** Draw text in world space using the image font
+        drawText(text: string, pos: Vector2, scale?: number, center?: boolean): void;
+        /** Draw text in screen space using the image font
          *  @param {String}  text
          *  @param {Vector2} pos
-         *  @param {Number}  [scale=.25]
+         *  @param {Number}  [scale=4]
          *  @param {Boolean} [center]
          */
-        drawText(text: string, pos: Vector2, scale?: number, center?: boolean): void;
+        drawTextScreen(text: string, pos: Vector2, scale?: number, center?: boolean): void;
     }
     /** Returns true if fullscreen mode is active
      *  @return {Boolean}
@@ -1230,6 +1247,7 @@ declare module "littlejs.esm" {
         range: number;
         /** @property {Number} - At what percentage of range should it start tapering off */
         taper: number;
+        /** @property {Number} - How much to randomize frequency each time sound plays */
         randomness: any;
         cachedSamples: any[];
         /** Play the sound
@@ -1371,7 +1389,7 @@ declare module "littlejs.esm" {
      *  @return {Boolean}
      *  @memberof TileCollision */
     export function tileCollisionTest(pos: Vector2, size?: Vector2, object?: EngineObject): boolean;
-    /** Return the center of tile if any that is hit (this does not return the exact hit point)
+    /** Return the center of tile if any that is hit (does not return the exact intersection)
      *  @param {Vector2}      posStart
      *  @param {Vector2}      posEnd
      *  @param {EngineObject} [object]