littlejsengine 1.16.2 → 1.17.1

package/src/engineInput.js

@@ -55,6 +55,10 @@ let inputPreventDefault = true;
  *  @memberof Input */
 let gamepadPrimary = 0;
 
+/** True if a touch device has been detected
+ *  @memberof Input */
+const isTouchDevice = !headlessMode && window.ontouchstart !== undefined;
+
 /** Prevents input continuing to the default browser handling
  *  This is useful to disable for html menus so the browser can handle input normally
  *  @param {boolean} preventDefault
@@ -253,10 +257,6 @@ function gamepadStickCount(gamepad=gamepadPrimary)
     return gamepadStickData[gamepad]?.length ?? 0;
 }
 
-/** True if a touch device has been detected
- *  @memberof Input */
-const isTouchDevice = !headlessMode && window.ontouchstart !== undefined;
-
 ///////////////////////////////////////////////////////////////////////////////
 
 /** Pulse the vibration hardware if it exists
@@ -265,7 +265,7 @@ const isTouchDevice = !headlessMode && window.ontouchstart !== undefined;
 function vibrate(pattern=100)
 {
     ASSERT(isNumber(pattern) || isArray(pattern), 'pattern must be a number or array');
-    vibrateEnable && !headlessMode && navigator && navigator.vibrate && navigator.vibrate(pattern);
+    vibrateEnable && !headlessMode && navigator?.vibrate?.(pattern);
 }
 
 /** Cancel any ongoing vibration
@@ -383,8 +383,8 @@ function inputInit()
     }
     function onMouseUp(e)
     {
-        if (isTouchDevice && touchInputEnable)
-            return;
+        if (isTouchDevice && touchInputEnable) return;
+
         inputData[0][e.button] = (inputData[0][e.button]&2) | 4;
     }
     function onMouseMove(e)
@@ -570,8 +570,7 @@ function inputUpdate()
         // update touch gamepad if enabled
         if (touchGamepadEnable && isTouchDevice)
         {
-            if (!touchGamepadTimer.isSet())
-                return;
+            if (!touchGamepadTimer.isSet()) return;
 
             // read virtual analog stick
             gamepadPrimary = 0; // touch gamepad uses index 0
@@ -609,12 +608,10 @@ function inputUpdate()
         }
 
         // return if gamepads are disabled or not supported
-        if (!gamepadsEnable || !navigator || !navigator.getGamepads)
-            return;
+        if (!gamepadsEnable || !navigator || !navigator.getGamepads) return;
 
         // only poll gamepads when focused or in debug mode
-        if (!debug && !document.hasFocus())
-            return;
+        if (!debug && !document.hasFocus()) return;
 
         // poll gamepads
         const maxGamepads = 8;
@@ -651,8 +648,7 @@ function inputUpdate()
                 data[j] = button.pressed ? wasDown ? 1 : 3 : wasDown ? 4 : 0;
 
                 // check for any input on this gamepad, analog must be full press
-                if (button.pressed)
-                if (!button.value || button.value > .9)
+                if (button.pressed && (!button.value || button.value > .9))
                     hadInput = true;
             }
             
@@ -681,7 +677,7 @@ function inputUpdate()
             }
 
             // copy dpad to left analog stick when pressed
-            if (gamepadDirectionEmulateStick && !dpad.isZero())
+            if (gamepadDirectionEmulateStick && (dpad.x || dpad.y))
                 sticks[0] = dpad.clampLength();
         }
 
@@ -710,13 +706,11 @@ function inputRender()
     function touchGamepadRender()
     {
         if (!touchInputEnable || !isTouchDevice || headlessMode) return;
-        if (!touchGamepadEnable || !touchGamepadTimer.isSet())
-            return;
+        if (!touchGamepadEnable || !touchGamepadTimer.isSet()) return;
 
         // fade off when not touching or paused
         const alpha = percent(touchGamepadTimer.get(), 4, 3);
-        if (!alpha || paused)
-            return;
+        if (!alpha || paused) return;
 
         // setup the canvas
         const context = mainContext;

package/src/engineMath.js

@@ -1,10 +1,9 @@
 /**
- * LittleJS Utility Classes and Functions
+ * LittleJS Math Classes and Functions
  * - General purpose math library
- * - Vector2 - fast, simple, easy 2D vector class
- * - Color - holds a rgba color with some math functions
- * - Timer - tracks time automatically
  * - RandomGenerator - seeded random number generator
+ * - Vector2 - fast, simple, easy 2D vector class
+ * - Color - holds a rgba color with math functions
  * @namespace Math
  */
 
@@ -194,11 +193,11 @@ function nearestPowerOfTwo(value) { return 2**ceil(log2(value)); }
 
 /** Returns true if two axis aligned bounding boxes are overlapping
  *  this can be used for simple collision detection between objects
- *  @param {Vector2} posA          - Center of box A
- *  @param {Vector2} sizeA         - Size of box A
- *  @param {Vector2} posB          - Center of box B
- *  @param {Vector2} [sizeB=(0,0)] - Size of box B, uses a point if undefined
- *  @return {boolean}              - True if overlapping
+ *  @param {Vector2} posA - Center of box A
+ *  @param {Vector2} sizeA - Size of box A
+ *  @param {Vector2} posB - Center of box B
+ *  @param {Vector2} [sizeB=vec2()] - Size of box B, uses a point if undefined
+ *  @return {boolean} - True if overlapping
  *  @memberof Math */
 function isOverlapping(posA, sizeA, posB, sizeB=vec2())
 {
@@ -272,7 +271,7 @@ function isNumber(n) { return typeof n === 'number' && !isNaN(n); }
  * @param {any} s
  * @return {boolean}
  * @memberof Math */
-function isString(s) { return s !== undefined && s !== null && typeof s.toString() === 'string'; }
+function isString(s) { return s != null && typeof s?.toString() === 'string'; }
 
 /**
  * Check if object is an array
@@ -416,8 +415,8 @@ function randInCircle(radius=1, minRadius=0)
 { return radius > 0 ? randVec2(radius * rand(minRadius / radius, 1)**.5) : new 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 {Color}   [colorA=WHITE]
+ *  @param {Color}   [colorB=BLACK]
  *  @param {boolean} [linear]
  *  @return {Color}
  *  @memberof Random */
@@ -496,8 +495,8 @@ class RandomGenerator
     { return vec2(this.float(valueA, valueB), this.float(valueA, valueB)); }
 
     /** 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 {Color}   [colorA=WHITE]
+    *  @param {Color}   [colorB=BLACK]
     *  @param {boolean} [linear]
     *  @return {Color} */
     randColor(colorA=new Color, colorB=new Color(0,0,0,1), linear=false)
@@ -541,7 +540,7 @@ class RandomGenerator
  * a = vec2(5);        // set a to (5, 5)
  * b = vec2();         // set b to (0, 0)
  * @memberof Math */
-function vec2(x=0, y) { return new Vector2(x, y === undefined ? x : y); }
+function vec2(x=0, y) { return new Vector2(x, y ?? x); }
 
 /**
  * Check if object is a valid Vector2
@@ -749,10 +748,6 @@ class Vector2
      * @return {number} */
     area() { return abs(this.x * this.y); }
 
-    /** Returns true if this vector is (0,0)
-     * @return {boolean} */
-    isZero() { return !this.x && !this.y; }
-
     /** Returns a new vector that is p percent between this and the vector passed in
      * @param {Vector2} v - other vector
      * @param {number}  percent
@@ -1114,88 +1109,4 @@ const PURPLE = debugProtectConstant(rgb(.5,0,1));
 /** Color - Magenta #ff00ff
  *  @type {Color}
  *  @memberof Math */
-const MAGENTA = debugProtectConstant(rgb(1,0,1));
-
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * Timer object tracks how long has passed since it was set
- * @memberof Engine
- * @example
- * let a = new Timer;    // creates a timer that is not set
- * a.set(3);             // sets the timer to 3 seconds
- *
- * let b = new Timer(1); // creates a timer with 1 second left
- * b.unset();            // unset the timer
- */
-class Timer
-{
-    /** Create a timer object set time passed in
-     *  @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, useRealTime=false)
-    {
-        ASSERT(timeLeft === undefined || isNumber(timeLeft), 'Constructed Timer is invalid.', timeLeft);
-        this.useRealTime = useRealTime;
-        const globalTime = this.getGlobalTime();
-        this.time = timeLeft === undefined ? undefined : globalTime + timeLeft;
-        this.setTime = timeLeft;
-    }
-
-    /** Set the timer with seconds passed in
-     *  @param {number} [timeLeft] - How much time left before the timer is elapsed in seconds */
-    set(timeLeft=0)
-    {
-        ASSERT(isNumber(timeLeft), 'Timer is invalid.', timeLeft);
-        const globalTime = this.getGlobalTime();
-        this.time = globalTime + timeLeft;
-        this.setTime = timeLeft;
-    }
-
-    /** Set if the timer should keep running even when the game is paused
-     *  @param {boolean} [useRealTime] */
-    setUseRealTime(useRealTime=true)
-    {
-        ASSERT(!this.isSet(), 'Cannot change global time setting while timer is set.');
-        this.useRealTime = useRealTime;
-    }
-
-    /** Unset the timer */
-    unset() { this.time = undefined; }
-
-    /** Returns true if set
-     * @return {boolean} */
-    isSet() { return this.time !== undefined; }
-
-    /** Returns true if set and has not elapsed
-     * @return {boolean} */
-    active() { return this.getGlobalTime() < this.time; }
-
-    /** Returns true if set and elapsed
-     * @return {boolean} */
-    elapsed() { return this.getGlobalTime() >= this.time; }
-
-    /** Get how long since elapsed, returns 0 if not set (returns negative if currently active)
-     * @return {number} */
-    get() { return this.isSet()? this.getGlobalTime() - this.time : 0; }
-
-    /** Get percentage elapsed based on time it was set to, returns 0 if not set
-     * @return {number} */
-    getPercent() { return this.isSet()? 1-percent(this.time - this.getGlobalTime(), 0, this.setTime) : 0; }
-
-    /** Get the time this timer was set to, returns 0 if not set
-     * @return {number} */
-    getSetTime() { return this.isSet() ? this.setTime : 0; }
-
-    /** Get the current global time this timer is based on
-     * @return {number} */
-    getGlobalTime() { return this.useRealTime ? timeReal : time; }
-
-    /** Returns this timer expressed as a string
-     * @return {string} */
-    toString() { return this.isSet() ? abs(this.get()) + ' seconds ' + (this.get()<0 ? 'before' : 'after' ) : 'unset'; }
-
-    /** Get how long since elapsed, returns 0 if not set (returns negative if currently active)
-     * @return {number} */
-    valueOf() { return this.get(); }
-}
+const MAGENTA = debugProtectConstant(rgb(1,0,1));

package/src/engineObject.js

@@ -33,10 +33,10 @@
 class EngineObject
 {
     /** Create an engine object and adds it to the list of objects
-     *  @param {Vector2}  [pos=(0,0)]   - World space position of the object
-     *  @param {Vector2}  [size=(1,1)]  - World space size of the object
-     *  @param {TileInfo} [tileInfo]    - Tile info to render object (undefined is untextured)
-     *  @param {number}   [angle]       - Angle the object is rotated by
+     *  @param {Vector2}  [pos=vec2()] - World space position of the object
+     *  @param {Vector2}  [size=vec2(1)] - World space size of the object
+     *  @param {TileInfo} [tileInfo] - Tile info to render object (undefined is untextured)
+     *  @param {number}   [angle] - Angle the object is rotated by
      *  @param {Color}    [color=WHITE] - Color to apply to tile when rendered
      *  @param {number}   [renderOrder] - Objects sorted by renderOrder before being rendered
      */
@@ -164,15 +164,16 @@ class EngineObject
         // physics sanity checks
         ASSERT(this.angleDamping >= 0 && this.angleDamping <= 1);
         ASSERT(this.damping >= 0 && this.damping <= 1);
-        if (!enablePhysicsSolver || !this.mass) // don't do collision for static objects
-            return;
+
+        // don't do collision for static objects or if solver disabled
+        if (!enablePhysicsSolver || !this.mass) return;
 
         const wasFalling = this.velocity.y < 0 && gravity.y < 0 || this.velocity.y > 0 && gravity.y > 0;
         if (this.groundObject)
         {
             // apply friction in local space of ground object
             const friction = max(this.friction, this.groundObject.friction);
-            const groundSpeed = this.groundObject.velocity ? this.groundObject.velocity.x : 0;
+            const groundSpeed = this.groundObject.velocity.x;
             this.velocity.x = groundSpeed + (this.velocity.x - groundSpeed) * friction;
             this.groundObject = undefined;
         }
@@ -183,19 +184,19 @@ class EngineObject
             const epsilon = .001; // necessary to push slightly outside of the collision
             for (const o of engineObjectsCollide)
             {
+                // skip destroyed, child objects, or self collision
+                if (o.destroyed || o.parent || o === this) continue;
+
                 // non solid objects don't collide with each other
-                if ((!this.isSolid && !o.isSolid) || o.destroyed || o.parent || o === this)
-                    continue;
+                if (!this.isSolid && !o.isSolid) continue;
 
                 // check collision
-                if (!this.isOverlappingObject(o))
-                    continue;
+                if (!this.isOverlappingObject(o)) continue;
 
                 // notify objects of collision and check if should be resolved
                 const collide1 = this.collideWithObject(o);
                 const collide2 = o.collideWithObject(this);
-                if (!collide1 || !collide2)
-                    continue;
+                if (!collide1 || !collide2) continue;
 
                 if (isOverlapping(oldPos, this.size, o.pos, o.size))
                 {
@@ -297,7 +298,7 @@ class EngineObject
                         const delta = y - this.pos.y;
                         if (delta < maxMoveUp)
                         if (!tileCollisionTest(vec2(this.pos.x, y), this.size, this))
-                        {   
+                        {
                             this.pos.y = y;
                             debugPhysics && debugRect(this.pos, this.size, '#ff0');
                             return;
@@ -357,10 +358,10 @@ class EngineObject
 
         // disconnect from parent and destroy children
         this.destroyed = 1;
-        this.parent && this.parent.removeChild(this);
+        this.parent?.removeChild(this);
         for (const child of this.children)
         {
-            child.parent = 0;
+            child.parent = undefined;
             child.destroy();
         }
     }
@@ -381,15 +382,15 @@ class EngineObject
      *  @param {Vector2} vec - world space vector */
     worldToLocalVector(vec) { return vec.rotate(-this.angle); }
 
-    /** Called to check if a tile collision should be resolved
+    /** Called to check if a tile collision should be resolved. Return true for physics to resolve the collision or false to ignore and resolve it manually.
      *  @param {number}  tileData - the value of the tile at the position
-     *  @param {Vector2} pos      - tile where the collision occurred
-     *  @return {boolean}         - true if the collision should be resolved */
+     *  @param {Vector2} pos - tile where the collision occurred
+     *  @return {boolean} - true if the collision should be resolved by modifying it's position and velocity */
     collideWithTile(tileData, pos) { return tileData > 0; }
 
-    /** Called to check if a object collision should be resolved
+    /** Called by the engine to check if an object collision should be resolved. Return true for physics to resolve the collision or false to ignore and resolve it manually.
      *  @param {EngineObject} object - the object to test against
-     *  @return {boolean}            - true if the collision should be resolved
+     *  @return {boolean} - true if the collision should be resolved by modifying it's position and velocity
      */
     collideWithObject(object) { return true; }
 
@@ -430,9 +431,9 @@ class EngineObject
      *  @return {number} -1 if this.mirror is true, or 1 if not mirrored */
     getMirrorSign() { return this.mirror ? -1 : 1; }
 
-    /** Attaches a child to this with a local transform, returns child for chaining   
+    /** Attaches a child to this with a local transform, returns child for chaining
      *  @param {EngineObject} child
-     *  @param {Vector2}      [localPos=(0,0)]
+     *  @param {Vector2}      [localPos=vec2()]
      *  @param {number}       [localAngle]
      *  @return {EngineObject} The child object added */
     addChild(child, localPos=vec2(), localAngle=0)
@@ -456,7 +457,7 @@ class EngineObject
         const index = this.children.indexOf(child);
         ASSERT(index >= 0, 'child not found in children array');
         index >= 0 && this.children.splice(index, 1);
-        child.parent = 0;
+        child.parent = undefined;
     }
 
     /** Check if overlapping another engine object
@@ -468,7 +469,7 @@ class EngineObject
 
     /** 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
+     *  @param {Vector2} [size=vec2()] - Size of box, uses a point if undefined
      *  @return {boolean} */
     isOverlapping(pos, size=vec2())
     { return isOverlapping(this.pos, this.size, pos, size); }

package/src/engineParticles.js

@@ -255,7 +255,7 @@ class ParticleEmitter extends EngineObject
         particle.mirror        = randBool();
 
         // call particle create callback
-        this.particleCreateCallback && this.particleCreateCallback(particle);
+        this.particleCreateCallback?.(particle);
 
         // return the newly created particle
         return particle;
@@ -340,7 +340,7 @@ class Particle extends EngineObject
             const c = this.colorEnd;
             this.color.set(c.r, c.g, c.b, c.a);
             this.size.set(this.sizeEnd, this.sizeEnd);
-            this.destroyCallback && this.destroyCallback(this);
+            this.destroyCallback?.(this);
             this.destroyed = 1;
         }
     }