littlejsengine 1.12.6 → 1.13.4

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,12 +203,12 @@ 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);
                         
-                    debugOverlay && debugPhysics && debugOverlap(this.pos, this.size, o.pos, o.size, '#f00');
+                    debugPhysics && debugOverlap(this.pos, this.size, o.pos, o.size, '#f00');
                     continue;
                 }
 
@@ -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,14 +263,14 @@ 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');
+                debugPhysics && debugOverlap(this.pos, this.size, o.pos, o.size, '#f0f');
             }
         }
         if (this.collideTiles)
@@ -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,9 +313,9 @@ 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');
+                    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)
@@ -209,15 +209,22 @@ class ParticleEmitter extends EngineObject
         const particle = new Particle(pos, this.tileInfo, angle, colorStart, colorEnd, particleTime, sizeStart, sizeEnd, this.fadeRate, this.additive,  this.trailScale, this.localSpace && this, this.particleDestroyCallback);
         particle.velocity      = vec2().setAngle(velocityAngle, speed);
         particle.angleVelocity = angleSpeed;
+        if (!this.localSpace)
+        {
+            // apply emitter velocity to particle
+            particle.velocity.x += this.velocity.x;
+            particle.velocity.y += this.velocity.y;
+            particle.angleVelocity += this.angleVelocity;
+        }
         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 +286,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;
+    }
 
-        // particles use circular clamped speed
-        this.clampSpeedLinear = false;
+    /** Update the object physics, called automatically by engine once each frame */
+    update()
+    {
+        super.update();
+
+        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 */

package/src/engineSettings.js

@@ -15,6 +15,12 @@
  *  @memberof Settings */
 let cameraPos = vec2();
 
+/** Rotation angle of camera in world space
+ *  @type {number}
+ *  @default
+ *  @memberof Settings */
+let cameraAngle = 0;
+
 /** Scale of camera in world space
  *  @type {number}
  *  @default
@@ -24,6 +30,13 @@ let cameraScale = 32;
 ///////////////////////////////////////////////////////////////////////////////
 // Display settings
 
+/** Enable applying color to tiles when using canvas2d
+ *  - This is slower but should be the same as webgl rendering
+ *  @type {boolean}
+ *  @default
+ *  @memberof Settings */
+let canvasColorTiles = true;
+
 /** The max size of the canvas, centered if window is larger
  *  @type {Vector2}
  *  @default Vector2(1920,1080)
@@ -37,14 +50,21 @@ let canvasMaxSize = vec2(1920, 1080);
  *  @memberof Settings */
 let canvasFixedSize = vec2();
 
-/** Use nearest neighbor canvas scaling for more pixelated look
- *  - Must be set before startup to take effect
+/** Use nearest canvas scaling for more pixelated look
  *  - If enabled sets css image-rendering:pixelated
  *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let canvasPixelated = true;
 
+/** Use nearest canvas scaling for more pixelated look
+ *  - If enabled sets css image-rendering:pixelated
+ *  - This defaults to false because text looks better with smoothing
+ *  @type {boolean}
+ *  @default
+ *  @memberof Settings */
+let overlayCanvasPixelated = false;
+
 /** Disables texture filtering for crisper pixel art
  *  @type {boolean}
  *  @default
@@ -80,13 +100,6 @@ let headlessMode = false;
  *  @memberof Settings */
 let glEnable = true;
 
-/** Fixes slow rendering in some browsers by not compositing the WebGL canvas
- *  - Must be set before startup to take effect
- *  @type {boolean}
- *  @default
- *  @memberof Settings */
-let glOverlay = true;
-
 ///////////////////////////////////////////////////////////////////////////////
 // Tile sheet settings
 
@@ -133,7 +146,7 @@ let objectDefaultAngleDamping = 1;
  *  @type {number}
  *  @default
  *  @memberof Settings */
-let objectDefaultElasticity = 0;
+let objectDefaultRestitution = 0;
 
 /** How much to slow when touching (0-1)
  *  @type {number}
@@ -168,13 +181,13 @@ let particleEmitRateScale = 1;
  *  @memberof Settings */
 let gamepadsEnable = true;
 
-/** If true, the dpad input is also routed to the left analog stick (for better accessability)
+/** If true, the dpad input is also routed to the left analog stick (for better accessibility)
  *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let gamepadDirectionEmulateStick = true;
 
-/** If true the WASD keys are also routed to the direction keys (for better accessability)
+/** If true the WASD keys are also routed to the direction keys (for better accessibility)
  *  @type {boolean}
  *  @default
  *  @memberof Settings */
@@ -282,11 +295,24 @@ let medalsPreventUnlock = false;
  *  @memberof Settings */
 function setCameraPos(pos) { cameraPos = pos; }
 
+/** Set angle of camera in world space
+ *  @param {number} angle
+ *  @memberof Settings */
+function setCameraAngle(angle) { cameraAngle = angle; }
+
 /** Set scale of camera in world space
  *  @param {number} scale
  *  @memberof Settings */
 function setCameraScale(scale) { cameraScale = scale; }
 
+/** Set if tiles should be colorized when using canvas2d
+ *  This can be slower but results should look nearly identical to webgl rendering
+ *  It can be enabled/disabled at any time
+ *  Optimized for performance, and will use faster method if color is white or untextured
+ *  @param {boolean} colorTiles
+ *  @memberof Settings */
+function setCanvasColorTiles(colorTiles) { canvasColorTiles = colorTiles; }
+
 /** Set max size of the canvas
  *  @param {Vector2} size
  *  @memberof Settings */
@@ -297,10 +323,30 @@ function setCanvasMaxSize(size) { canvasMaxSize = size; }
  *  @memberof Settings */
 function setCanvasFixedSize(size) { canvasFixedSize = size; }
 
-/** Use nearest neighbor scaling algorithm for canvas for more pixelated look
+/** Use nearest scaling algorithm for canvas for more pixelated look
+ *  - If enabled sets css image-rendering:pixelated
  *  @param {boolean} pixelated
  *  @memberof Settings */
-function setCanvasPixelated(pixelated) { canvasPixelated = pixelated; }
+function setCanvasPixelated(pixelated)
+{
+    canvasPixelated = pixelated;
+    if (mainCanvas)
+        mainCanvas.style.imageRendering = pixelated ? 'pixelated' : '';
+    if (glCanvas)
+        glCanvas.style.imageRendering = pixelated ? 'pixelated' : '';
+}
+
+/** Use nearest scaling algorithm for canvas for more pixelated look
+ *  - If enabled sets css image-rendering:pixelated
+ *  - This defaults to false because text looks better with smoothing
+ *  @param {boolean} pixelated
+ *  @memberof Settings */
+function setOverlayCanvasPixelated(pixelated)
+{ 
+    overlayCanvasPixelated = pixelated; 
+    if (overlayCanvas)
+        overlayCanvas.style.imageRendering = pixelated ? 'pixelated' : '';
+}
 
 /** Disables texture filtering for crisper pixel art
  *  @param {boolean} pixelated
@@ -325,12 +371,12 @@ function setHeadlessMode(headless) { headlessMode = headless; }
 /** Set if webgl rendering is enabled
  *  @param {boolean} enable
  *  @memberof Settings */
-function setGlEnable(enable) { glEnable = enable; }
-
-/** Set to not composite the WebGL canvas
- *  @param {boolean} overlay
- *  @memberof Settings */
-function setGlOverlay(overlay) { glOverlay = overlay; }
+function setGLEnable(enable)
+{
+    glEnable = enable;
+    if (glCanvas) // hide glCanvas if webgl is disabled
+        glCanvas.style.visibility = enable ? 'visible' : 'hidden';
+}
 
 /** Set default size of tiles in pixels
  *  @param {Vector2} size
@@ -362,10 +408,10 @@ function setObjectDefaultDamping(damp) { objectDefaultDamping = damp; }
  *  @memberof Settings */
 function setObjectDefaultAngleDamping(damp) { objectDefaultAngleDamping = damp; }
 
-/** Set how much to bounce when a collision occur
- *  @param {number} elasticity
+/** Set how much to bounce when a collision occurs
+ *  @param {number} restitution
  *  @memberof Settings */
-function setObjectDefaultElasticity(elasticity) { objectDefaultElasticity = elasticity; }
+function setObjectDefaultRestitution(restitution) { objectDefaultRestitution = restitution; }
 
 /** Set how much to slow when touching
  *  @param {number} friction