littlejsengine 1.12.4 → 1.13.1

package/src/engineInput.js

@@ -17,7 +17,8 @@
  *  @memberof Input */
 function keyIsDown(key, device=0)
 { 
-    ASSERT(device > 0 || typeof key !== 'number' || key < 3, 'use code string for keyboard');
+    ASSERT(key !== undefined, 'key is undefined');
+    ASSERT(device > 0 || typeof key != 'number' || key < 3, 'use code string for keyboard');
     return inputData[device] && !!(inputData[device][key] & 1); 
 }
 
@@ -28,7 +29,8 @@ function keyIsDown(key, device=0)
  *  @memberof Input */
 function keyWasPressed(key, device=0)
 { 
-    ASSERT(device > 0 || typeof key !== 'number' || key < 3, 'use code string for keyboard');
+    ASSERT(key !== undefined, 'key is undefined');
+    ASSERT(device > 0 || typeof key != 'number' || key < 3, 'use code string for keyboard');
     return inputData[device] && !!(inputData[device][key] & 2); 
 }
 
@@ -39,7 +41,8 @@ function keyWasPressed(key, device=0)
  *  @memberof Input */
 function keyWasReleased(key, device=0)
 { 
-    ASSERT(device > 0 || typeof key !== 'number' || key < 3, 'use code string for keyboard');
+    ASSERT(key !== undefined, 'key is undefined');
+    ASSERT(device > 0 || typeof key != 'number' || key < 3, 'use code string for keyboard');
     return inputData[device] && !!(inputData[device][key] & 4);
 }
 
@@ -54,28 +57,42 @@ function keyDirection(up='ArrowUp', down='ArrowDown', left='ArrowLeft', right='A
 
 /** Clears all input
  *  @memberof Input */
-function clearInput() { inputData = [[]]; touchGamepadButtons = []; }
+function inputClear() { inputData = [[]]; touchGamepadButtons = []; }
+
+/** Clears an input key state
+ *  @param {string|number} key
+ *  @param {number} [device]
+ *  @param {boolean} [clearDown=true]
+ *  @param {boolean} [clearPressed=true]
+ *  @param {boolean} [clearReleased=true]
+ *  @memberof Input */
+function inputClearKey(key, device=0, clearDown=true, clearPressed=true, clearReleased=true)
+{
+    if (!inputData[device])
+        return;
+    inputData[device][key] &= ~((clearDown?1:0)|(clearPressed?2:0)|(clearReleased?4:0));
+}
 
 /** Returns true if mouse button is down
  *  @function
  *  @param {number} button
  *  @return {boolean}
  *  @memberof Input */
-const mouseIsDown = keyIsDown;
+function mouseIsDown(button) { return keyIsDown(button); }
 
 /** Returns true if mouse button was pressed
  *  @function
  *  @param {number} button
  *  @return {boolean}
  *  @memberof Input */
-const mouseWasPressed = keyWasPressed;
+function mouseWasPressed(button) { return keyWasPressed(button); }
 
 /** Returns true if mouse button was released
  *  @function
  *  @param {number} button
  *  @return {boolean}
  *  @memberof Input */
-const mouseWasReleased = keyWasReleased;
+function mouseWasReleased(button) { return keyWasReleased(button); }
 
 /** Mouse pos in world space
  *  @type {Vector2}
@@ -87,6 +104,16 @@ let mousePos = vec2();
  *  @memberof Input */
 let mousePosScreen = vec2();
 
+/** Mouse movement delta in world space
+ *  @type {Vector2}
+ *  @memberof Input */
+let mouseDelta = vec2();
+
+/** Mouse movement delta in screen space
+ *  @type {Vector2}
+ *  @memberof Input */
+let mouseDeltaScreen = vec2();
+
 /** Mouse wheel delta this frame
  *  @type {number}
  *  @memberof Input */
@@ -153,10 +180,11 @@ function inputUpdate()
 
     // clear input when lost focus (prevent stuck keys)
     if(!(touchInputEnable && isTouchDevice) && !document.hasFocus())
-        clearInput();
+        inputClear();
 
     // update mouse world space position
     mousePos = screenToWorld(mousePosScreen);
+    mouseDelta = mouseDeltaScreen.multiply(vec2(1,-1)).rotate(-cameraAngle);
 
     // update gamepads if enabled
     gamepadsUpdate();
@@ -171,13 +199,29 @@ function inputUpdatePost()
     for (const i in deviceInputData)
         deviceInputData[i] &= 1;
     mouseWheel = 0;
+    mouseDelta = vec2();
+    mouseDeltaScreen = vec2();
 }
 
 function inputInit()
 {
     if (headlessMode) return;
 
-    onkeydown = (e)=>
+    // add event listeners
+    document.addEventListener('keydown', onKeyDown);
+    document.addEventListener('keyup', onKeyUp);
+    document.addEventListener('mousedown', onMouseDown);
+    document.addEventListener('mouseup', onMouseUp);
+    document.addEventListener('mousemove', onMouseMove);
+    document.addEventListener('wheel', onMouseWheel);
+    document.addEventListener('contextmenu', onContextMenu);
+    document.addEventListener('blur', onBlur);
+
+    // init touch input
+    if (isTouchDevice && touchInputEnable)
+        touchInputInit();
+
+    function onKeyDown(e)
     {
         if (!e.repeat)
         {
@@ -187,45 +231,49 @@ function inputInit()
                 inputData[0][remapKey(e.code)] = 3;
         }
     }
-
-    onkeyup = (e)=>
+    function onKeyUp(e)
     {
-        inputData[0][e.code] = 4;
+        inputData[0][e.code] = (inputData[0][e.code]&2) | 4;
         if (inputWASDEmulateDirection)
             inputData[0][remapKey(e.code)] = 4;
     }
-
-    // handle remapping wasd keys to directions
     function remapKey(c)
     {
-        return inputWASDEmulateDirection ? 
-            c == 'KeyW' ? 'ArrowUp' : 
-            c == 'KeyS' ? 'ArrowDown' : 
-            c == 'KeyA' ? 'ArrowLeft' : 
+        // handle remapping wasd keys to directions
+        return inputWASDEmulateDirection ?
+            c == 'KeyW' ? 'ArrowUp' :
+            c == 'KeyS' ? 'ArrowDown' :
+            c == 'KeyA' ? 'ArrowLeft' :
             c == 'KeyD' ? 'ArrowRight' : c : c;
     }
-    
-    // mouse event handlers
-    onmousedown   = (e)=>
+    function onMouseDown(e)
     {
+        if (isTouchDevice && touchInputEnable)
+            return;
+
         // fix stalled audio requiring user interaction
         if (soundEnable && !headlessMode && audioContext && audioContext.state != 'running')
             audioContext.resume();
         
-        isUsingGamepad = false; 
-        inputData[0][e.button] = 3; 
-        mousePosScreen = mouseEventToScreen(e); 
+        isUsingGamepad = false;
+        inputData[0][e.button] = 3;
+        mousePosScreen = mouseEventToScreen(vec2(e.x,e.y));
         inputPreventDefault && e.button && e.preventDefault();
     }
-    onmouseup     = (e)=> inputData[0][e.button] = inputData[0][e.button] & 2 | 4;
-    onmousemove   = (e)=> mousePosScreen = mouseEventToScreen(e);
-    onwheel       = (e)=> mouseWheel = e.ctrlKey ? 0 : sign(e.deltaY);
-    oncontextmenu = (e)=> false; // prevent right click menu
-    onblur        = (e) => clearInput(); // reset input when focus is lost
-
-    // init touch input
-    if (isTouchDevice && touchInputEnable)
-        touchInputInit();
+    function onMouseUp(e)
+    {
+        if (isTouchDevice && touchInputEnable)
+            return;
+        inputData[0][e.button] = (inputData[0][e.button]&2) | 4;
+    }
+    function onMouseMove(e)
+    {
+        mousePosScreen = mouseEventToScreen(vec2(e.x,e.y));
+        mouseDeltaScreen = mouseDeltaScreen.add(vec2(e.movementX, e.movementY));
+    }
+    function onMouseWheel(e) { mouseWheel = e.ctrlKey ? 0 : sign(e.deltaY); }
+    function onContextMenu(e) { e.preventDefault(); } // prevent right click menu
+    function onBlur() { inputClear(); } // reset input when focus is lost
 }
 
 // convert a mouse or touch event position to screen space
@@ -373,9 +421,6 @@ function touchInputInit()
     document.addEventListener('touchmove',  (e) => handleTouch(e), { passive: false });
     document.addEventListener('touchend',   (e) => handleTouch(e), { passive: false });
 
-    // override mouse events
-    onmousedown = onmouseup = ()=> 0;
-
     // handle all touch events the same way
     let wasTouching;
     function handleTouchDefault(e)
@@ -390,9 +435,16 @@ function touchInputInit()
         if (touching)
         {
             // set event pos and pass it along
-            const p = vec2(e.touches[0].clientX, e.touches[0].clientY);
-            mousePosScreen = mouseEventToScreen(p);
-            wasTouching ? isUsingGamepad = touchGamepadEnable : inputData[0][button] = 3;
+            const pos = vec2(e.touches[0].clientX, e.touches[0].clientY);
+            const lastMousePosScreen = mousePosScreen;
+            mousePosScreen = mouseEventToScreen(pos);
+            if (wasTouching)
+            {
+                mouseDeltaScreen = mouseDeltaScreen.add(mousePosScreen.subtract(lastMousePosScreen));
+                isUsingGamepad = touchGamepadEnable;
+            }
+            else
+                inputData[0][button] = 3;
         }
         else if (wasTouching)
             inputData[0][button] = inputData[0][button] & 2 | 4;
@@ -522,4 +574,24 @@ function touchGamepadRender()
 
     // set canvas back to normal
     context.restore();
-}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Pointer Lock
+
+/** Request to lock the pointer, does not work on touch devices
+ *  @memberof Input */
+function pointerLockRequest()
+{
+    if (!isTouchDevice)
+        mainCanvas.requestPointerLock && mainCanvas.requestPointerLock();
+}
+
+/** Request to unlock the pointer
+ *  @memberof Input */
+function pointerLockExit() { document.exitPointerLock && document.exitPointerLock(); }
+
+/** Check if pointer is locked (true if locked)
+ *  @return {boolean}
+ *  @memberof Input */
+function pointerLockIsActive() { return document.pointerLockElement == mainCanvas }

package/src/engineObject.js

@@ -41,9 +41,13 @@ class EngineObject
      */
     constructor(pos=vec2(), size=vec2(1), tileInfo, angle=0, color=new Color, renderOrder=0)
     {
-        // set passed in params
-        ASSERT(isVector2(pos) && isVector2(size), 'ensure pos and size are vec2s');
-        ASSERT(typeof tileInfo !== 'number' || !tileInfo, 'old style tile setup');
+        // check passed in params
+        ASSERT(isVector2(pos) && pos.isValid(), 'object pos should be a vec2');
+        ASSERT(isVector2(size) && size.isValid(), 'object size should be a vec2');
+        ASSERT(!tileInfo || tileInfo instanceof TileInfo, 'object tileInfo should be a TileInfo or undefined');
+        ASSERT(typeof angle == 'number' && isFinite(angle), 'object angle should be a number');
+        ASSERT(isColor(color) && color.isValid(), 'object color should be a valid rgba color');
+        ASSERT(typeof renderOrder == 'number', 'object renderOrder should be a number');
 
         /** @property {Vector2} - World space position of the object */
         this.pos = pos.copy();
@@ -53,49 +57,49 @@ class EngineObject
         this.drawSize = undefined;
         /** @property {TileInfo} - Tile info to render object (undefined is untextured) */
         this.tileInfo = tileInfo;
-        /** @property {number}  - Angle to rotate the object */
+        /** @property {number} - Angle to rotate the object */
         this.angle = angle;
-        /** @property {Color}   - Color to apply when rendered */
+        /** @property {Color} - Color to apply when rendered */
         this.color = color;
-        /** @property {Color}   - Additive color to apply when rendered */
+        /** @property {Color} - Additive color to apply when rendered */
         this.additiveColor = undefined;
         /** @property {boolean} - Should it flip along y axis when rendered */
         this.mirror = false;
 
         // physical properties
-        /** @property {number} [mass=objectDefaultMass]                 - How heavy the object is, static if 0 */
-        this.mass         = objectDefaultMass;
-        /** @property {number} [damping=objectDefaultDamping]           - How much to slow down velocity each frame (0-1) */
-        this.damping      = objectDefaultDamping;
+        /** @property {number} [mass=objectDefaultMass] - How heavy the object is, static if 0 */
+        this.mass = objectDefaultMass;
+        /** @property {number} [damping=objectDefaultDamping] - How much to slow down velocity each frame (0-1) */
+        this.damping = objectDefaultDamping;
         /** @property {number} [angleDamping=objectDefaultAngleDamping] - How much to slow down rotation each frame (0-1) */
         this.angleDamping = objectDefaultAngleDamping;
-        /** @property {number} [elasticity=objectDefaultElasticity]     - How bouncy the object is when colliding (0-1) */
-        this.elasticity   = objectDefaultElasticity;
-        /** @property {number} [friction=objectDefaultFriction]         - How much friction to apply when sliding (0-1) */
-        this.friction     = objectDefaultFriction;
-        /** @property {number}  - How much to scale gravity by for this object */
+        /** @property {number} [restitution=objectDefaultRestitution] - How bouncy the object is when colliding (0-1) */
+        this.restitution = objectDefaultRestitution;
+        /** @property {number} [friction=objectDefaultFriction] - How much friction to apply when sliding (0-1) */
+        this.friction  = objectDefaultFriction;
+        /** @property {number} - How much to scale gravity by for this object */
         this.gravityScale = 1;
-        /** @property {number}  - Objects are sorted by render order */
+        /** @property {number} - Objects are sorted by render order */
         this.renderOrder = renderOrder;
         /** @property {Vector2} - Velocity of the object */
         this.velocity = vec2();
-        /** @property {number}  - Angular velocity of the object */
+        /** @property {number} - Angular velocity of the object */
         this.angleVelocity = 0;
-        /** @property {number}  - Track when object was created  */
+        /** @property {number} - Track when object was created  */
         this.spawnTime = time;
-        /** @property {Array<EngineObject>}   - List of children of this object */
+        /** @property {Array<EngineObject>} - List of children of this object */
         this.children = [];
-        /** @property {boolean}  - Limit object speed using linear or circular math */
-        this.clampSpeedLinear = true;
+        /** @property {boolean} - Limit object speed along x and y axis */
+        this.clampSpeed = true;
         /** @property {EngineObject} - Object we are standing on, if any  */
         this.groundObject = undefined;
 
         // parent child system
         /** @property {EngineObject} - Parent of object if in local space  */
         this.parent = undefined;
-        /** @property {Vector2}      - Local position if child */
+        /** @property {Vector2} - Local position if child */
         this.localPos = vec2();
-        /** @property {number}       - Local angle if child  */
+        /** @property {number} - Local angle if child  */
         this.localAngle = 0;
 
         // collision flags
@@ -136,29 +140,20 @@ class EngineObject
         if (this.parent)
             return;
 
-        // limit max speed to prevent missing collisions
-        if (this.clampSpeedLinear)
+        if (this.clampSpeed)
         {
+            // limit max speed to prevent missing collisions
             this.velocity.x = clamp(this.velocity.x, -objectMaxSpeed, objectMaxSpeed);
             this.velocity.y = clamp(this.velocity.y, -objectMaxSpeed, objectMaxSpeed);
         }
-        else
-        {
-            const length2 = this.velocity.lengthSquared();
-            if (length2 > objectMaxSpeed*objectMaxSpeed)
-            {
-                const s = objectMaxSpeed / length2**.5;
-                this.velocity.x *= s;
-                this.velocity.y *= s;
-            }
-        }
 
         // apply physics
         const oldPos = this.pos.copy();
         this.velocity.x *= this.damping;
         this.velocity.y *= this.damping;
-        if (this.mass) // don't apply gravity to static objects
+        if (this.mass)
         {
+            // apply gravity only if it has mass
             this.velocity.x += gravity.x * this.gravityScale;
             this.velocity.y += gravity.y * this.gravityScale;
         }
@@ -180,7 +175,6 @@ class EngineObject
             const groundSpeed = this.groundObject.velocity ? this.groundObject.velocity.x : 0;
             this.velocity.x = groundSpeed + (this.velocity.x - groundSpeed) * friction;
             this.groundObject = undefined;
-            //debugOverlay && debugPhysics && debugPoint(this.pos.subtract(vec2(0,this.size.y/2)), '#0f0');
         }
 
         if (this.collideSolidObjects)
@@ -209,7 +203,7 @@ class EngineObject
                     const deltaPos = oldPos.subtract(o.pos);
                     const length = deltaPos.length();
                     const pushAwayAccel = .001; // push away if already overlapping
-                    const velocity = length < .01 ? randVector(pushAwayAccel) : deltaPos.scale(pushAwayAccel/length);
+                    const velocity = length < .01 ? randVec2(pushAwayAccel) : deltaPos.scale(pushAwayAccel/length);
                     this.velocity = this.velocity.add(velocity);
                     if (o.mass) // push away if not fixed
                         o.velocity = o.velocity.subtract(velocity);
@@ -223,7 +217,7 @@ class EngineObject
                 const smallStepUp = (oldPos.y - o.pos.y)*2 > sizeBoth.y + gravity.y; // prefer to push up if small delta
                 const isBlockedX = abs(oldPos.y - o.pos.y)*2 < sizeBoth.y;
                 const isBlockedY = abs(oldPos.x - o.pos.x)*2 < sizeBoth.x;
-                const elasticity = max(this.elasticity, o.elasticity);
+                const restitution = max(this.restitution, o.restitution);
                 
                 if (smallStepUp || isBlockedY || !isBlockedX) // resolve y collision
                 {
@@ -236,7 +230,7 @@ class EngineObject
                             this.groundObject = o;
 
                         // bounce if other object is fixed or grounded
-                        this.velocity.y *= -elasticity;
+                        this.velocity.y *= -restitution;
                     }
                     else if (o.mass)
                     {
@@ -249,9 +243,9 @@ class EngineObject
                         const elastic1 = o.velocity.y * (o.mass - this.mass) / (this.mass + o.mass)
                             + this.velocity.y * 2 * this.mass / (this.mass + o.mass);
 
-                        // lerp between elastic or inelastic based on elasticity
-                        this.velocity.y = lerp(elasticity, inelastic, elastic0);
-                        o.velocity.y = lerp(elasticity, inelastic, elastic1);
+                        // lerp between elastic or inelastic based on restitution
+                        this.velocity.y = lerp(inelastic, elastic0, restitution);
+                        o.velocity.y = lerp(inelastic, elastic1, restitution);
                     }
                 }
                 if (!smallStepUp && isBlockedX) // resolve x collision
@@ -269,12 +263,12 @@ class EngineObject
                         const elastic1 = o.velocity.x * (o.mass - this.mass) / (this.mass + o.mass)
                             + this.velocity.x * 2 * this.mass / (this.mass + o.mass);
 
-                        // lerp between elastic or inelastic based on elasticity
-                        this.velocity.x = lerp(elasticity, inelastic, elastic0);
-                        o.velocity.x = lerp(elasticity, inelastic, elastic1);
+                        // lerp between elastic or inelastic based on restitution
+                        this.velocity.x = lerp(inelastic, elastic0, restitution);
+                        o.velocity.x = lerp(inelastic, elastic1, restitution);
                     }
                     else // bounce if other object is fixed
-                        this.velocity.x *= -elasticity;
+                        this.velocity.x *= -restitution;
                 }
                 debugOverlay && debugPhysics && debugOverlap(this.pos, this.size, o.pos, o.size, '#f0f');
             }
@@ -295,8 +289,8 @@ class EngineObject
                     if (blockedLayerY || !blockedLayerX)
                     {
                         // bounce velocity
-                        const elasticity = max(this.elasticity, hitLayer.elasticity);
-                        this.velocity.y *= -elasticity;
+                        const restitution = max(this.restitution, hitLayer.restitution);
+                        this.velocity.y *= -restitution;
 
                         if (wasMovingDown)
                         {
@@ -319,7 +313,7 @@ class EngineObject
                     {
                         // move to previous position and bounce
                         this.pos.x = oldPos.x;
-                        this.velocity.x *= -this.elasticity;
+                        this.velocity.x *= -this.restitution;
                     }
                     debugOverlay && debugPhysics && debugRect(this.pos, this.size, '#f00');
                 }
@@ -334,7 +328,7 @@ class EngineObject
         drawTile(this.pos, this.drawSize || this.size, this.tileInfo, this.color, this.angle, this.mirror, this.additiveColor);
     }
     
-    /** Destroy this object, destroy it's children, detach it's parent, and mark it for removal */
+    /** Destroy this object, destroy its children, detach it's parent, and mark it for removal */
     destroy()
     { 
         if (this.destroyed)
@@ -344,7 +338,10 @@ class EngineObject
         this.destroyed = 1;
         this.parent && this.parent.removeChild(this);
         for (const child of this.children)
-            child.destroy(child.parent = 0);
+        {
+            child.parent = 0;
+            child.destroy();
+        }
     }
 
     /** Convert from local space to world space
@@ -367,25 +364,29 @@ class EngineObject
      *  @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 */
-    collideWithTile(tileData, pos)    { return tileData > 0; }
+    collideWithTile(tileData, pos) { return tileData > 0; }
 
     /** Called to check if a object collision should be resolved
      *  @param {EngineObject} object - the object to test against
      *  @return {boolean}            - true if the collision should be resolved
      */
-    collideWithObject(object)         { return true; }
+    collideWithObject(object) { return true; }
 
     /** How long since the object was created
      *  @return {number} */
-    getAliveTime()                    { return time - this.spawnTime; }
+    getAliveTime() { return time - this.spawnTime; }
 
     /** Apply acceleration to this object (adjust velocity, not affected by mass)
      *  @param {Vector2} acceleration */
-    applyAcceleration(acceleration)   { if (this.mass) this.velocity = this.velocity.add(acceleration); }
+    applyAcceleration(acceleration) { if (this.mass) this.velocity = this.velocity.add(acceleration); }
+
+    /** Apply angular acceleration to this object 
+     *  @param {number} acceleration */
+    applyAngularAcceleration(acceleration) { if (this.mass) this.angleVelocity += acceleration; }
 
     /** Apply force to this object (adjust velocity, affected by mass)
      *  @param {Vector2} force */
-    applyForce(force)	              { this.applyAcceleration(force.scale(1/this.mass)); }
+    applyForce(force) { this.applyAcceleration(force.scale(1/this.mass)); }
     
     /** Get the direction of the mirror
      *  @return {number} -1 if this.mirror is true, or 1 if not mirrored */
@@ -452,15 +453,15 @@ class EngineObject
     /** Render debug info for this object  */
     renderDebugInfo()
     {
-        if (debug)
-        {
-            // show object info for debugging
-            const size = vec2(max(this.size.x, .2), max(this.size.y, .2));
-            const color1 = rgb(this.collideTiles?1:0, this.collideSolidObjects?1:0, this.isSolid?1:0, this.parent?.2:.5);
-            const color2 = this.parent ? rgb(1,1,1,.5) : rgb(0,0,0,.8);
-            drawRect(this.pos, size, color1, this.angle, false);
-            drawRect(this.pos, size.scale(.8), color2, this.angle, false);
-            this.parent && drawLine(this.pos, this.parent.pos, .1, rgb(0,0,1,.5), false);
-        }
+        if (!debug)
+            return;
+        
+        // show object info for debugging
+        const size = vec2(max(this.size.x, .2), max(this.size.y, .2));
+        const color = rgb(this.collideTiles?1:0, this.collideSolidObjects?1:0, this.isSolid?1:0, .5);
+        drawRect(this.pos, size, color, this.angle);
+        if (this.parent)
+            drawRect(this.pos, size.scale(.8), rgb(1,1,1,.5), this.angle);
+        this.parent && drawLine(this.pos, this.parent.pos, .1, rgb(1,1,1,.5));
     }
 }

package/src/engineParticles.js

@@ -14,7 +14,7 @@
  * (
  *     pos, 0, 1, 0, 500, PI,      // pos, angle, emitSize, emitTime, emitRate, emitCone
  *     tile(0, 16),                // tileInfo
- *     rgb(1,1,1),   rgb(0,0,0),   // colorStartA, colorStartB
+ *     rgb(1,1,1,1), rgb(0,0,0,1), // colorStartA, colorStartB
  *     rgb(1,1,1,0), rgb(0,0,0,0), // colorEndA, colorEndB
  *     2, .2, .2, .1, .05,  // particleTime, sizeStart, sizeEnd, particleSpeed, particleAngleSpeed
  *     .99, 1, 1, PI, .05,  // damping, angleDamping, gravityScale, particleCone, fadeRate, 
@@ -169,7 +169,7 @@ class ParticleEmitter extends EngineObject
         if (debugParticles)
         {
             // show emitter bounds
-            const emitSize = typeof this.emitSize === 'number' ? vec2(this.emitSize) : this.emitSize;
+            const emitSize = typeof this.emitSize == 'number' ? vec2(this.emitSize) : this.emitSize;
             debugRect(this.pos, emitSize, '#0f0', 0, this.angle);
         }
     }
@@ -179,9 +179,9 @@ class ParticleEmitter extends EngineObject
     emitParticle()
     {
         // spawn a particle
-        let pos = typeof this.emitSize === 'number' ? // check if number was used
-            randInCircle(this.emitSize/2)              // circle emitter
-            : vec2(rand(-.5,.5), rand(-.5,.5))         // box emitter
+        let pos = typeof this.emitSize == 'number' ? // check if number was used
+            randInCircle(this.emitSize/2)            // circle emitter
+            : vec2(rand(-.5,.5), rand(-.5,.5))       // box emitter
                 .multiply(this.emitSize).rotate(this.angle)
         let angle = rand(this.particleConeAngle, -this.particleConeAngle);
         if (!this.localSpace)
@@ -212,12 +212,12 @@ class ParticleEmitter extends EngineObject
         particle.fadeRate      = this.fadeRate;
         particle.damping       = this.damping;
         particle.angleDamping  = this.angleDamping;
-        particle.elasticity    = this.elasticity;
+        particle.restitution    = this.restitution;
         particle.friction      = this.friction;
         particle.gravityScale  = this.gravityScale;
         particle.collideTiles  = this.collideTiles;
         particle.renderOrder   = this.renderOrder;
-        particle.mirror        = !!randInt(2);
+        particle.mirror        = randBool();
 
         // call particle create callback
         this.particleCreateCallback && this.particleCreateCallback(particle);
@@ -279,9 +279,26 @@ class Particle extends EngineObject
         this.localSpaceEmitter = localSpaceEmitter;
         /** @property {Function} - Called when particle dies */
         this.destroyCallback = destroyCallback;
+        // particles do not clamp speed by default
+        this.clampSpeed = false;
+    }
+
+    /** Update the object physics, called automatically by engine once each frame */
+    update()
+    {
+        super.update();
 
-        // particles use circular clamped speed
-        this.clampSpeedLinear = false;
+        if (this.collideTiles || this.collideSolidObjects)
+        {
+            // only apply max circular speed if particle can collide
+            const length2 = this.velocity.lengthSquared();
+            if (length2 > objectMaxSpeed*objectMaxSpeed)
+            {
+                const s = objectMaxSpeed / length2**.5;
+                this.velocity.x *= s;
+                this.velocity.y *= s;
+            }
+        }
     }
 
     /** Render the particle, automatically called each frame, sorted by renderOrder */