littlejsengine 1.6.6 → 1.6.92

package/README.md

@@ -1,7 +1,12 @@
 # ![LittleJS Logo](examples/favicon.png) LittleJS - The Tiny JavaScript Game Engine That Can
 
-## All aboard!
+[![NPM Package][npm]][npm-url]
+[![Build Size][build-size]][build-size-url]
+[![NPM Downloads][npm-downloads]][npmtrends-url]
+[![DeepScan][deepscan]][deepscan-url]
+[![Discord][discord]][discord-url]
 
+## All aboard!
 
 LittleJS is a super lightweight JavaScript game engine designed for modern web development. With its fast hybrid rendering system, it offers a comprehensive suite of game development tools from rendering to sound effects. The code is very clean and well documented with a variety of examples to get you started. Choo-Choo! 🚂
 <div align="center">
@@ -26,7 +31,7 @@ LittleJS is a small but powerful game engine with many features and no depenenci
 
 ### Graphics
 
-- Fast sprite and tile map rendering engine with WebGL
+- Super fast sprite and tile map rendering engine with WebGL
 - Update and render 10,000+ objects at 60fps, often many times more
 - Apply [Shadertoy](https://www.shadertoy.com) compatible shaders for post processinge effects
 
@@ -42,21 +47,21 @@ LittleJS is a small but powerful game engine with many features and no depenenci
 
 ### Physics
 
-- Kinematic physics object update 
 - 2D physics engine with collision handling for axis aligned boxes
-- Very fast collision handling for tile maps
+- Very fast collision handling and raycasting for tile maps
 
 ### Flexability
 
 - Designed to work with all modern web bowsers and mobile devices
 - Compatible with TypeScript and includes [an example TS project](https://killedbyapixel.github.io/LittleJS/examples/typescript)
-- For size coding competitions like [js13kGames](https://js13kgames.com/), starter project builds to a 7KB zip file
-- Build to a Windows executable with [Electron](https://www.electronjs.org/) for distribution on platforms like Steam
+- For size coding competitions like [js13kGames](https://js13kgames.com/), [a special example project builds to a 7KB zip file](https://killedbyapixel.github.io/LittleJS/examples/js13k)
+- Builds to a Windows executable with [Electron](https://www.electronjs.org/) for distribution on platforms like Steam
 - Open Source with the [MIT license](https://github.com/KilledByAPixel/LittleJS/blob/main/LICENSE) so it can be used for anything you want
 
-### Extra Systems
+### And more...
 
-- Debug rendering system
+- Node.js build system
+- Debug primitives rendering system
 - Particle effects system and design tool
 - Bitmap font rendering and includes a built in engine font
 - Medal system tracks and displays achievements with Newgrounds integration
@@ -65,13 +70,11 @@ LittleJS is a small but powerful game engine with many features and no depenenci
 
 To use LittleJS download the latest package from GitHub or call ```npm install littlejsengine```. This package contains the engine and several small examples.
 
-[You can use the empty example template as a starting point.](https://github.com/KilledByAPixel/LittleJS/blob/main/examples/empty/game.js) This file contians just the minimal setup to start the engine. You can also download and include [littlejs.js](https://github.com/KilledByAPixel/LittleJS/blob/main/build/littlejs.js) or [littlejs.min.js](https://github.com/KilledByAPixel/LittleJS/blob/main/build/littlejs.min.js).
-
-If your game loads any files like images you will need to run a local web server. I recommend an editor that does this automatically like [Visual Studio Code](https://code.visualstudio.com/) with the [Live Server plugin](https://marketplace.visualstudio.com/items?itemName=ritwickdey.LiveServer). You can also use [http-server](https://www.npmjs.com/package/http-server) via npm.
+[You can use the empty example template as a starting point.](https://github.com/KilledByAPixel/LittleJS/blob/main/examples/empty/game.js) This file contains just the minimal setup to start the engine. You can also download and include [littlejs.js](https://github.com/KilledByAPixel/LittleJS/blob/main/build/littlejs.js) or [littlejs.min.js](https://github.com/KilledByAPixel/LittleJS/blob/main/build/littlejs.min.js).
 
-## Tutorial
+If your game loads any files like images you will need to run a local web server. Some editors can do this automatically like [Visual Studio Code](https://code.visualstudio.com/) with the [Live Server plugin](https://marketplace.visualstudio.com/items?itemName=ritwickdey.LiveServer). You can also use [http-server](https://www.npmjs.com/package/http-server) via npm.
 
-- [Breakout Tutorial](https://github.com/KilledByAPixel/LittleJS/blob/main/examples/breakoutTutorial) - Shows how to make a simple game from scatch with LittleJS.
+[The Breakout Tutorial](https://github.com/KilledByAPixel/LittleJS/blob/main/examples/breakoutTutorial) is provided to demonstrate how to make a simple game from scratch. [The tutorial is also available on YouTube.](https://youtu.be/tSwDx-NWTXE?si=bkjMa8-7AN2Wg5MO)
 
 ## Builds
 
@@ -88,7 +91,29 @@ LittleJS can also be imported as a module. There are two module flavors that are
 
 To rebuild the engine you must first run ```npm install``` to setup the necessary npm dependencies. Then call ```npm run build``` to build the engine.
 
-The starter project example also includes a batch file [build.bat](https://github.com/KilledByAPixel/LittleJS/blob/main/examples/starter/build.bat) that compresses everything into a tiny zip file using Google Closure, UglifyJS, Roadroller, and ECT.
+The starter example project also includes a node js file [build.js](https://github.com/KilledByAPixel/LittleJS/blob/main/examples/starter/build.js) that compresses everything into a tiny zip file using Google Closure, UglifyJS, and ECT Zip.
+
+## Engine Source Code
+
+This engine is made with simplicity in mind using clean easy to read code. There are only a few files used by the entire engine.
+
+- [engine.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engine.js) - Top level engine init, update, and render
+- [engineSettings.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineSettings.js) - Global engine settings
+- [engineObject.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineObject.js) - Base object class and physics
+- [engineDraw.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineDraw.js) - Code for canvas drawing and text
+- [engineAudio.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineAudio.js) - Spacial sound effects, and zzfx sound generator
+- [engineInput.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineInput.js) - Input for keyboard, mouse, touch, and gamepad
+- [engineUtilities.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineUtilities.js) - Vector2, Color, and Timer clases and math functions
+
+Optional Components, these components are built to synergize with the rest of the engine but are not necessary.
+
+- [engineTileLayer.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineTileLayer.js) - Tile layer rendering and collision
+- [engineParticles.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineParticles.js) - Particle system with fast rendering and collision
+- [engineWebGL.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineWebGL.js) - Super fast rendering with WebGL and post processing
+- [engineMedals.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineMedals.js) - Achievement tracker with Newgrounds integration
+- [engineDebug.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineDebug.js) - Debug rendering system and information overlay
+- [engineExport.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineExport.js) - Included when exporting engine as a module
+- [engineBuild.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineBuild.js) - Node script used to build the engine
 
 ## LittleJS Setup
 
@@ -157,26 +182,6 @@ class MyObject extends EngineObject
 }
 ```
 
-## Engine Source Code
-
-This engine is made with simplicity in mind using clean easy to read code. There are only a few files used by the entire engine.
-
-- [engine.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engine.js) - Top level engine init, update, and render
-- [engineSettings.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineSettings.js) - Global engine settings
-- [engineObject.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineObject.js) - Base object class and physics
-- [engineDraw.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineDraw.js) - Code for canvas drawing and text
-- [engineAudio.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineAudio.js) - Spacial sound effects, and zzfx sound generator
-- [engineInput.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineInput.js) - Input for keyboard, mouse, touch, and gamepad
-- [engineUtilities.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineUtilities.js) - Vector2, Color, and Timer clases and math functions
-
-Optional Components, these components are built to synergize with the rest of the engine but are not necessary.
-
-- [engineTileLayer.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineTileLayer.js) - Tile layer rendering and collision
-- [engineParticles.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineParticles.js) - Particle system with fast rendering and collision
-- [engineWebGL.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineWebGL.js) - Super fast rendering with WebGL and post processing
-- [engineMedals.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineMedals.js) - Achievement tracker with Newgrounds integration
-- [engineDebug.js](https://github.com/KilledByAPixel/LittleJS/blob/main/src/engineDebug.js) - Debug rendering system and information overlay
-
 ## Debugging
 
 Debug builds of LittleJS have a special menu that can be opened by pressing the Esc key.
@@ -185,7 +190,7 @@ Debug builds of LittleJS have a special menu that can be opened by pressing the
 - 1: Debug Physics
 - 2: Debug Particles
 - 3: Debug Gamepads
-- 4: God Mode
+- 4: Debug Raycasts
 - 5: Save Screenshot
 
 ## Games Made With LittleJS
@@ -205,3 +210,14 @@ Here are a few of the amazing games people are making with LittleJS.
 - Send me your games!
 
 ![LittleJS Logo](examples/favicon.png)
+
+[npm]: https://img.shields.io/npm/v/littlejsengine
+[npm-url]: https://www.npmjs.com/package/littlejsengine
+[build-size]: https://badgen.net/bundlephobia/minzip/littlejsengine?1
+[build-size-url]: https://bundlephobia.com/result?p=littlejsengine
+[npm-downloads]: https://img.shields.io/npm/dw/littlejsengine
+[npmtrends-url]: https://www.npmtrends.com/littlejsengine
+[deepscan]: https://deepscan.io/api/teams/22950/projects/26229/branches/831487/badge/grade.svg
+[deepscan-url]: https://deepscan.io/dashboard#view=project&tid=22950&pid=26229&bid=831487
+[discord]: https://img.shields.io/discord/939926111469568050
+[discord-url]: https://discord.gg/zb7hcGkyZe

package/build/littlejs.d.ts

@@ -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
@@ -424,69 +415,69 @@ 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;
+    export function clamp(value: number, min?: number, max?: number): number;
     /** Returns what percentage the value is between max and min
      *  @param {Number} value
      *  @param {Number} [min=0]
      *  @param {Number} [max=1]
      *  @return {Number}
      *  @memberof Utilities */
-    export function percent(v: any, min?: number, max?: number): number;
+    export function percent(value: number, min?: number, max?: number): number;
     /** Linearly interpolates the percent value between max and min
      *  @param {Number} percent
      *  @param {Number} [min=0]
      *  @param {Number} [max=1]
      *  @return {Number}
      *  @memberof Utilities */
-    export function lerp(p: any, min?: number, max?: number): number;
+    export function lerp(percent: number, min?: number, max?: 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 +497,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} [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,7 +525,7 @@ declare module "littlejs.esm" {
      *  @param {Boolean} [linear]
      *  @return {Color}
      *  @memberof Random */
-    export function randColor(cA?: Color, cB?: Color, linear?: boolean): Color;
+    export function randColor(colorA?: Color, colorB?: Color, linear?: boolean): Color;
     /** Seed used by the randSeeded function
      *  @type {Number}
      *  @default
@@ -549,7 +540,7 @@ declare module "littlejs.esm" {
      *  @param {Number} [valueB=0]
      *  @return {Number}
      *  @memberof Random */
-    export function randSeeded(a?: number, b?: number): number;
+    export function randSeeded(valueA?: number, valueB?: number): number;
     /**
      * 2D Vector object with vector math library
      * - Functions do not change this so they can be chained together
@@ -572,25 +563,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 +589,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 +605,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 +619,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 +637,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 +660,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 +678,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,20 +790,20 @@ 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
      */
@@ -908,13 +899,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;
@@ -1371,7 +1362,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]