littlejsengine 1.9.9 → 1.9.11

package/plugins/box2d.js

@@ -43,8 +43,9 @@ class Box2dObject extends EngineObject
 
     destroy()
     {
-        // destroy physics body and fixtures
-        box2dWorld.DestroyBody(this.body);
+        // destroy physics body, fixtures, and joints
+        this.body && box2dWorld.DestroyBody(this.body);
+        this.body = 0;
         super.destroy();
     }
 
@@ -91,20 +92,20 @@ class Box2dObject extends EngineObject
     addShape(shape, density, friction, restitution, isSensor)
     {
         const fd = box2dCreateFixtureDef(shape, density, friction, restitution, isSensor);
-        this.addFixture(fd);
+        return this.addFixture(fd);
     }
 
     addBox(size=vec2(1), offset=vec2(), angle=0, density, friction, restitution, isSensor)
     {
         const shape = new box2d.b2PolygonShape();
         shape.SetAsBox(size.x/2, size.y/2, offset.getBox2d(), angle);
-        this.addShape(shape, density, friction, restitution, isSensor);
+        return this.addShape(shape, density, friction, restitution, isSensor);
     }
 
     addPoly(points, density, friction, restitution, isSensor)
     {
         const shape = box2dCreatePolygonShape(points);
-        this.addShape(shape, density, friction, restitution, isSensor);
+        return this.addShape(shape, density, friction, restitution, isSensor);
     }
 
     addRegularPoly(diameter=1, sides=8, density, friction, restitution, isSensor)
@@ -113,7 +114,7 @@ class Box2dObject extends EngineObject
         const radius = diameter/2;
         for (let i=sides; i--;)
             points.push(vec2(radius,0).rotate((i+.5)/sides*PI*2));
-        this.addPoly(points, density, friction, restitution, isSensor);
+        return this.addPoly(points, density, friction, restitution, isSensor);
     }
 
     addRandomPoly(diameter=1, density, friction, restitution, isSensor)
@@ -123,7 +124,7 @@ class Box2dObject extends EngineObject
         const radius = diameter/2;
         for (let i=sides; i--;)
             points.push(vec2(rand(radius/2,radius*1.5),0).rotate(i/sides*PI*2));
-        this.addPoly(points, density, friction, restitution, isSensor);
+        return this.addPoly(points, density, friction, restitution, isSensor);
     }
 
     addCircle(diameter=1, offset=vec2(), density, friction, restitution, isSensor)
@@ -131,18 +132,19 @@ class Box2dObject extends EngineObject
         const shape = new box2d.b2CircleShape();
         shape.set_m_p(offset.getBox2d());
         shape.set_m_radius(diameter/2);
-        this.addShape(shape, density, friction, restitution, isSensor);
+        return this.addShape(shape, density, friction, restitution, isSensor);
     }
 
     addEdge(point1, point2, density, friction, restitution, isSensor)
     {
         const shape = new box2d.b2EdgeShape();
         shape.Set(point1.getBox2d(), point2.getBox2d());
-        this.addShape(shape, density, friction, restitution, isSensor);
+        return this.addShape(shape, density, friction, restitution, isSensor);
     }
 
     addEdgeLoop(points, density, friction, restitution, isSensor)
     {
+        const fixtures = [];
         const getPoint = i=> points[mod(i,points.length)];
         for (let i=0; i<points.length; ++i)
         {
@@ -151,12 +153,15 @@ class Box2dObject extends EngineObject
             shape.set_m_vertex1(getPoint(i+0).getBox2d());
             shape.set_m_vertex2(getPoint(i+1).getBox2d());
             shape.set_m_vertex3(getPoint(i+2).getBox2d());
-            this.addShape(shape, density, friction, restitution, isSensor);
+            const f = this.addShape(shape, density, friction, restitution, isSensor);
+            fixtures.push(f);
         }
+        return fixtures;
     }
 
     addEdgeList(points, density, friction, restitution, isSensor)
     {
+        const fixtures = [];
         for (let i=0; i<points.length-1; ++i)
         {
             const shape = new box2d.b2EdgeShape();
@@ -164,19 +169,37 @@ class Box2dObject extends EngineObject
             points[i+0] && shape.set_m_vertex1(points[i+0].getBox2d());
             points[i+1] && shape.set_m_vertex2(points[i+1].getBox2d());
             points[i+2] && shape.set_m_vertex3(points[i+2].getBox2d());
-            this.addShape(shape, density, friction, restitution, isSensor);
+            const f = this.addShape(shape, density, friction, restitution, isSensor);
+            fixtures.push(f);
         }
+        return fixtures;
     }
 
+    ///////////////////////////////////////////////////////////////////////////////
+    // lists of fixtures and joints
+
+    hasFixtures() { return !box2dIsNull(this.body.GetFixtureList()); }
     getFixtureList()
     {
-        const fixtureList = [];
+        const fixtures = [];
         for (let fixture=this.body.GetFixtureList(); !box2dIsNull(fixture); )
         {
-            fixtureList.push(fixture);
+            fixtures.push(fixture);
             fixture = fixture.GetNext();
         }
-        return fixtureList;
+        return fixtures;
+    }
+
+    hasJoints() { return !box2dIsNull(this.body.GetJointList()); }
+    getJointList()
+    {
+        const joints = [];
+        for (let joint=this.body.GetJointList(); !box2dIsNull(joint); )
+        {
+            joints.push(joint);
+            joint = joint.get_next();
+        }
+        return joints;
     }
 
     ///////////////////////////////////////////////////////////////////////////////
@@ -214,6 +237,19 @@ class Box2dObject extends EngineObject
     setBodyType(type)          { this.body.SetType(type); }
     setSleepingAllowed(isAllowed=true) { this.body.SetSleepingAllowed(isAllowed); }
     setFixedRotation(isFixed=true)     { this.body.SetFixedRotation(isFixed); }
+    setCenterOfMass(center)      { this.setMassData(center) }
+    setMass(mass)                { this.setMassData(undefined, mass) }
+    setMomentOfInertia(I)        { this.setMassData(undefined, undefined, I) }
+    resetMassData()              { this.body.ResetMassData(); }
+    setMassData(localCenter, mass, momentOfInertia)
+    {
+        const data = new box2d.b2MassData();
+        this.body.GetMassData(data);
+        localCenter && data.set_center(localCenter.getBox2d());
+        mass && data.set_mass(mass);
+        momentOfInertia && data.set_I(momentOfInertia);
+        this.body.SetMassData(data);
+    }
     setFilterData(categoryBits=0, ignoreCategoryBits=0, groupIndex=0)
     {
         this.getFixtureList().forEach(fixture=>
@@ -228,17 +264,17 @@ class Box2dObject extends EngineObject
     { this.getFixtureList().forEach(f=>f.SetSensor(isSensor)); }
 
     ///////////////////////////////////////////////////////////////////////////////
-    // physics kinematics
+    // physics force and torque functions
 
     applyForce(force, pos)
     {
-        pos = pos || this.getCenterOfMass();
+        pos ||= this.getCenterOfMass();
         this.setAwake();
         this.body.ApplyForce(force.getBox2d(), pos.getBox2d());
     }
     applyAcceleration(acceleration, pos)
     { 
-        pos = pos || this.getCenterOfMass();
+        pos ||= this.getCenterOfMass();
         this.setAwake();
         this.body.ApplyLinearImpulse(acceleration.getBox2d(), pos.getBox2d());
     }
@@ -270,7 +306,7 @@ class Box2dRaycastResult
     }
 }
 
-// raycast and return a list of all results
+// raycast and return a list of all the results
 function box2dRaycastAll(start, end)
 {
     const raycastCallback = new box2d.JSRayCastCallback();
@@ -293,11 +329,12 @@ function box2dRaycastAll(start, end)
 function box2dRaycast(start, end)
 {
     const raycastResults = box2dRaycastAll(start, end);
-    return raycastResults.length ?
-        raycastResults.reduce((a,b)=>a.fraction < b.fraction ? a : b) : undefined;
+    if (!raycastResults.length)
+        return undefined;
+    return raycastResults.reduce((a,b)=>a.fraction < b.fraction ? a : b);
 }
 
-// box aabb cast and return the all results
+// box aabb cast and return all the objects
 function box2dBoxCastAll(pos, size)
 {
     const queryCallback = new box2d.JSQueryCallback();
@@ -320,7 +357,7 @@ function box2dBoxCastAll(pos, size)
     return queryObjects;
 }
 
-// box aabb cast and return the first result
+// box aabb cast and return the first object
 function box2dBoxCast(pos, size)
 {
     const queryCallback = new box2d.JSQueryCallback();
@@ -341,7 +378,7 @@ function box2dBoxCast(pos, size)
     return queryObject;
 }
 
-// circle cast and return the all results
+// circle cast and return all the objects
 function box2dCircleCastAll(pos, diameter)
 {
     const radius2 = (diameter/2)**2;
@@ -349,17 +386,26 @@ function box2dCircleCastAll(pos, diameter)
     return results.filter(o=>o.pos.distanceSquared(pos) < radius2);
 }
 
-// circle cast and return the first result
+// circle cast and return the first object
 function box2dCircleCast(pos, diameter)
 {
     const radius2 = (diameter/2)**2;
     let results = box2dBoxCastAll(pos, vec2(diameter));
-    results = results.filter(o=>o.pos.distanceSquared(pos) < radius2);
-    results = results.sort((a,b)=>a.pos.distanceSquared(pos)-b.pos.distanceSquared(pos));
-    return results[0];
+
+    let bestResult, bestDistance2;
+    for (const result of results)
+    {
+        const distance2 = result.pos.distanceSquared(pos);
+        if (distance2 < radius2 && (!bestResult || distance2 < bestDistance2))
+        {
+            bestResult = result;
+            bestDistance2 = distance2;
+        }
+    }
+    return bestResult;
 }
 
-// point cast and return the first result
+// point cast and return the first object
 function box2dPointCast(pos, dynamicOnly=true)
 {
     const queryCallback = new box2d.JSQueryCallback();
@@ -384,6 +430,28 @@ function box2dPointCast(pos, dynamicOnly=true)
     return queryResult;
 }
 
+// box aabb cast and return all the fixtures
+function box2dBoxCastAllFixtures(pos, size)
+{
+    const queryCallback = new box2d.JSQueryCallback();
+    queryCallback.ReportFixture = function(fixturePointer)
+    {
+        const fixture = box2d.wrapPointer(fixturePointer, box2d.b2Fixture);
+        if (!queryObjects.includes(fixture))
+            queryObjects.push(fixture); // add if not already in list
+        return true; // continue getting results
+    };
+
+    const aabb = new box2d.b2AABB();
+    aabb.set_lowerBound(pos.subtract(size.scale(.5)).getBox2d());
+    aabb.set_upperBound(pos.add(size.scale(.5)).getBox2d());
+
+    let queryFixtures = [];
+    box2dWorld.QueryAABB(queryCallback, aabb);
+    debugRaycast && debugRect(pos, size, raycstResult ? '#f00' : '#00f', .02);
+    return queryFixtures;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Box2D Joints
 
@@ -394,14 +462,19 @@ function box2dCreateMouseJoint(object, fixedObject, worldPos)
     jointDef.set_bodyA(fixedObject.body);
     jointDef.set_bodyB(object.body);
     jointDef.set_target(worldPos.getBox2d());
-    jointDef.set_maxForce(1e3 * object.getMass());
+    jointDef.set_maxForce(2e3 * object.getMass());
     return box2dCastObject(box2dWorld.CreateJoint(jointDef));
 }
 
+function box2dCreatePinJoint(objectA, objectB, collide=false)
+{
+    return box2dCreateDistanceJoint(objectA, objectB, objectB.pos, undefined, collide);
+}
+
 function box2dCreateDistanceJoint(objectA, objectB, anchorA, anchorB, collide=false)
 {
-    anchorA = anchorA || vec2(objectA.body.GetPosition());
-    anchorB = anchorB || vec2(objectB.body.GetPosition());
+    anchorA ||= vec2(objectA.body.GetPosition());
+    anchorB ||= vec2(objectB.body.GetPosition());
     const localAnchorA = objectA.worldToLocal(anchorA);
     const localAnchorB = objectB.worldToLocal(anchorB);
     const jointDef = new box2d.b2DistanceJointDef();
@@ -416,7 +489,7 @@ function box2dCreateDistanceJoint(objectA, objectB, anchorA, anchorB, collide=fa
 
 function box2dCreateRevoluteJoint(objectA, objectB, anchor, collide=false)
 {
-    anchor = anchor || vec2(objectB.body.GetPosition());
+    anchor ||= vec2(objectB.body.GetPosition());
     const localAnchorA = objectA.worldToLocal(anchor);
     const localAnchorB = objectB.worldToLocal(anchor);
     const jointDef = new box2d.b2RevoluteJointDef();
@@ -431,7 +504,7 @@ function box2dCreateRevoluteJoint(objectA, objectB, anchor, collide=false)
 
 function box2dCreatePrismaticJoint(objectA, objectB, anchor, worldAxis=vec2(0,1), collide=false)
 {
-    anchor = anchor || vec2(objectB.body.GetPosition());
+    anchor ||= vec2(objectB.body.GetPosition());
     const localAnchorA = objectA.worldToLocal(anchor);
     const localAnchorB = objectB.worldToLocal(anchor);
     const localAxisA = objectB.worldToLocalVector(worldAxis);
@@ -448,7 +521,7 @@ function box2dCreatePrismaticJoint(objectA, objectB, anchor, worldAxis=vec2(0,1)
 
 function box2dCreateWheelJoint(objectA, objectB, anchor, worldAxis=vec2(0,1), collide=false)
 {
-    anchor = anchor || vec2(objectB.body.GetPosition());
+    anchor ||= vec2(objectB.body.GetPosition());
     const localAnchorA = objectA.worldToLocal(anchor);
     const localAnchorB = objectB.worldToLocal(anchor);
     const localAxisA = objectB.worldToLocalVector(worldAxis);
@@ -464,7 +537,7 @@ function box2dCreateWheelJoint(objectA, objectB, anchor, worldAxis=vec2(0,1), co
 
 function box2dCreateWeldJoint(objectA, objectB, anchor, collide=false)
 {
-    anchor = anchor || vec2(objectB.body.GetPosition());
+    anchor ||= vec2(objectB.body.GetPosition());
     const localAnchorA = objectA.worldToLocal(anchor);
     const localAnchorB = objectB.worldToLocal(anchor);
     const jointDef = new box2d.b2WeldJointDef();
@@ -479,7 +552,7 @@ function box2dCreateWeldJoint(objectA, objectB, anchor, collide=false)
 
 function box2dCreateFrictionJoint(objectA, objectB, anchor, collide=false)
 {
-    anchor = anchor || vec2(objectB.body.GetPosition());
+    anchor ||= vec2(objectB.body.GetPosition());
     const localAnchorA = objectA.worldToLocal(anchor);
     const localAnchorB = objectB.worldToLocal(anchor);
     const jointDef = new box2d.b2FrictionJointDef();
@@ -493,8 +566,8 @@ function box2dCreateFrictionJoint(objectA, objectB, anchor, collide=false)
 
 function box2dCreateRopeJoint(objectA, objectB, anchorA, anchorB, extraLength=0, collide=false)
 {
-    anchorA = anchorA || vec2(objectA.body.GetPosition());
-    anchorB = anchorB || vec2(objectB.body.GetPosition());
+    anchorA ||= vec2(objectA.body.GetPosition());
+    anchorB ||= vec2(objectB.body.GetPosition());
     const localAnchorA = objectA.worldToLocal(anchorA);
     const localAnchorB = objectB.worldToLocal(anchorB);
     const jointDef = new box2d.b2RopeJointDef();
@@ -509,8 +582,8 @@ function box2dCreateRopeJoint(objectA, objectB, anchorA, anchorB, extraLength=0,
 
 function box2dCreatePulleyJoint(objectA, objectB, groundAnchorA, groundAnchorB, anchorA, anchorB, ratio=1, collide=false)
 {
-    anchorA = anchorA || vec2(objectA.body.GetPosition());
-    anchorB = anchorB || vec2(objectB.body.GetPosition());
+    anchorA ||= vec2(objectA.body.GetPosition());
+    anchorB ||= vec2(objectB.body.GetPosition());
     const localAnchorA = objectA.worldToLocal(anchorA);
     const localAnchorB = objectB.worldToLocal(anchorB);
     const jointDef = new box2d.b2PulleyJointDef();
@@ -641,7 +714,7 @@ function box2dCastObject(object)
 function box2dWarmup(frames=100)
 {
     // run the sim for a few frames to let objects settle
-    for(let i=frames; i--;)
+    for (let i=frames; i--;)
         box2dWorld.Step(timeDelta, box2dStepIterations, box2dStepIterations);
 }
 

package/src/engine.js

@@ -30,7 +30,7 @@ const engineName = 'LittleJS';
  *  @type {String}
  *  @default
  *  @memberof Engine */
-const engineVersion = '1.9.9';
+const engineVersion = '1.9.11';
 
 /** Frames per second to update
  *  @type {Number}

package/src/engineAudio.js

@@ -73,6 +73,7 @@ class Sound
             // generate zzfx sound now for fast playback
             const defaultRandomness = .05;
             this.randomness = zzfxSound[1] || defaultRandomness;
+            zzfxSound[1] = 0; // generate without randomness
             this.sampleChannels = [zzfxG(...zzfxSound)];
             this.sampleRate = zzfxR;
         }
@@ -305,10 +306,6 @@ function getNoteFrequency(semitoneOffset, rootFrequency=220)
 
 ///////////////////////////////////////////////////////////////////////////////
 
-// internal tracking if audio was suspended when last sound was played
-// allows first suspended sound to play when audio is resumed
-let audioSuspended = false;
-
 /** Play cached audio samples with given settings
  *  @param {Array}    sampleChannels - Array of arrays of samples to play (for stereo playback)
  *  @param {Number}   [volume] - How much to scale volume by
@@ -324,20 +321,21 @@ function playSamples(sampleChannels, volume=1, rate=1, pan=0, loop=false, sample
     if (!soundEnable || headlessMode) return;
 
     // prevent sounds from building up if they can't be played
-    const audioWasSuspended = audioSuspended;
-    if (audioSuspended = audioContext.state != 'running')
+    if (audioContext.state != 'running')
     {
         // fix stalled audio
-        audioContext.resume();
+        audioContext.resume().then(()=>
+            playSamples(sampleChannels, volume, rate, pan, loop, sampleRate, gainNode));
 
         // prevent suspended sounds from building up
-        if (audioWasSuspended)
-            return;
+        return;
     }
 
     // create buffer and source
-    const buffer = audioContext.createBuffer(sampleChannels.length, sampleChannels[0].length, sampleRate), 
-        source = audioContext.createBufferSource();
+    const channelCount = sampleChannels.length;
+    const sampleLength = sampleChannels[0].length;
+    const buffer = audioContext.createBuffer(channelCount, sampleLength, sampleRate);
+    const source = audioContext.createBufferSource();
 
     // copy samples to buffer and setup source
     sampleChannels.forEach((c,i)=> buffer.getChannelData(i).set(c));
@@ -351,7 +349,8 @@ function playSamples(sampleChannels, volume=1, rate=1, pan=0, loop=false, sample
     gainNode.connect(audioGainNode);
 
     // connect source to stereo panner and gain
-    source.connect(new StereoPannerNode(audioContext, {'pan':clamp(pan, -1, 1)})).connect(gainNode);
+    const pannerNode = new StereoPannerNode(audioContext, {'pan':clamp(pan, -1, 1)});
+    source.connect(pannerNode).connect(gainNode);
 
     // play and return sound
     source.start();
@@ -367,7 +366,7 @@ function playSamples(sampleChannels, volume=1, rate=1, pan=0, loop=false, sample
  *  @param {Array} zzfxSound - Array of ZzFX parameters, ex. [.5,.5]
  *  @return {AudioBufferSourceNode} - The audio node of the sound played
  *  @memberof Audio */
-function zzfx(...zzfxSound) { return new Sound(zzfxSound).play(); }
+function zzfx(...zzfxSound) { return playSamples([zzfxG(...zzfxSound)]); }
 
 /** Sample rate used for all ZzFX sounds
  *  @default 44100
@@ -376,7 +375,7 @@ const zzfxR = 44100;
 
 /** Generate samples for a ZzFX sound
  *  @param {Number}  [volume] - Volume scale (percent)
- *  @param {Number}  [randomness] - Unused in this fuction, handled by Sound class
+ *  @param {Number}  [randomness] - How much to randomize frequency (percent Hz)
  *  @param {Number}  [frequency] - Frequency of sound (Hz)
  *  @param {Number}  [attack] - Attack time, how fast sound starts (seconds)
  *  @param {Number}  [sustain] - Sustain time, how long sound holds (seconds)
@@ -402,7 +401,7 @@ const zzfxR = 44100;
 function zzfxG
 (
     // parameters
-    volume = 1, randomness = 0, frequency = 220, attack = 0, sustain = 0,
+    volume = 1, randomness = .05, frequency = 220, attack = 0, sustain = 0,
     release = .1, shape = 0, shapeCurve = 1, slide = 0, deltaSlide = 0,
     pitchJump = 0, pitchJumpTime = 0, repeatTime = 0, noise = 0, modulation = 0,
     bitCrush = 0, delay = 0, sustainVolume = 1, decay = 0, tremolo = 0, filter = 0
@@ -413,7 +412,8 @@ function zzfxG
     // init parameters
     let PI2 = PI*2, sampleRate = zzfxR,
         startSlide = slide *= 500 * PI2 / sampleRate / sampleRate,
-        startFrequency = frequency *= PI2 / sampleRate,
+        startFrequency = frequency *= 
+            rand(1 + randomness, 1-randomness) * PI2 / sampleRate,
         b = [], t = 0, tm = 0, i = 0, j = 1, r = 0, c = 0, s = 0, f, length,
 
         // biquad LP/HP filter

package/src/engineDebug.js

@@ -190,8 +190,23 @@ function debugSaveDataURL(dataURL, filename)
     downloadLink.click();
 }
 
+/** Show error as full page of red text
+ *  @memberof Debug */
+function debugShowErrors()
+{
+    onunhandledrejection = (event)=>showError(event.reason);
+    onerror = (event, source, lineno, colno)=>
+        showError(`${event}\n${source}\nLn ${lineno}, Col ${colno}`);
+
+    const showError = (message)=>
+    {
+        document.body.style.backgroundColor = '#111';
+        document.body.innerHTML = `<pre style=color:#f00;font-size:50px>` + message;
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
-// Engine debug function (called automatically)
+// Engine debug functions (called automatically)
 
 function debugInit()
 {
@@ -322,7 +337,7 @@ function debugRender()
             const pos = worldToScreen(p.pos);
             overlayContext.translate(pos.x|0, pos.y|0);
             overlayContext.rotate(p.angle);
-            overlayContext.scale(1, -1);
+            overlayContext.scale(1, p.text ? 1 : -1);
             overlayContext.fillStyle = overlayContext.strokeStyle = p.color;
 
             if (p.text != undefined)

package/src/engineExport.js

@@ -188,10 +188,13 @@ export {
 	// WebGL
 	glCanvas,
 	glContext,
-	glSetTexture,
 	glCompileShader,
+	glCopyToContext,
 	glCreateProgram,
 	glCreateTexture,
+	glDraw,
+	glFlush,
+	glSetTexture,
 
 	// Input
 	keyIsDown,
@@ -251,4 +254,4 @@ export {
 	medalsPreventUnlock,
 	medalsInit,
 	Medal,
-};
+};

package/src/engineInput.js

@@ -199,6 +199,10 @@ function inputInit()
     // mouse event handlers
     onmousedown   = (e)=>
     {
+        // fix stalled audio requiring user interaction
+        if (soundEnable && !headlessMode && audioContext && audioContext.state != 'running')
+            audioContext.resume();
+        
         isUsingGamepad = false; 
         inputData[0][e.button] = 3; 
         mousePosScreen = mouseToScreen(e); 
@@ -210,7 +214,7 @@ function inputInit()
     oncontextmenu = (e)=> false; // prevent right click menu
 
     // init touch input
-    if (isTouchDevice && touchInputEnable && !headlessMode)
+    if (isTouchDevice && touchInputEnable)
         touchInputInit();
 }
 
@@ -367,8 +371,8 @@ function touchInputInit()
     function handleTouchDefault(e)
     {
         // fix stalled audio requiring user interaction
-        if (soundEnable && audioContext && audioContext.state != 'running')
-            zzfx(0);
+        if (soundEnable && !headlessMode && audioContext && audioContext.state != 'running')
+            audioContext.resume();
 
         // check if touching and pass to mouse events
         const touching = e.touches.length;

package/src/engineObject.js

@@ -153,9 +153,9 @@ class EngineObject
 
         // apply physics
         const oldPos = this.pos.copy();
-        this.velocity.y += gravity * this.gravityScale;
         this.pos.x += this.velocity.x *= this.damping;
-        this.pos.y += this.velocity.y *= this.damping;
+        this.pos.y += this.velocity.y = this.damping * this.velocity.y 
+            + gravity * this.gravityScale;
         this.angle += this.angleVelocity *= this.angleDamping;
 
         // physics sanity checks
@@ -284,19 +284,22 @@ class EngineObject
                     const isBlockedX = tileCollisionTest(vec2(this.pos.x, oldPos.y), this.size, this);
                     if (isBlockedY || !isBlockedX)
                     {
-                        // set if landed on ground
-                        this.groundObject = wasMovingDown;
-
                         // bounce velocity
                         this.velocity.y *= -this.elasticity;
 
-                        // adjust next velocity to settle on ground
-                        const o = (oldPos.y - this.size.y/2|0) - (oldPos.y - this.size.y/2);
-                        if (o < 0 && o > this.damping * this.velocity.y + gravity * this.gravityScale) 
-                            this.velocity.y = this.damping ? (o - gravity * this.gravityScale) / this.damping : 0;
-
-                        // move to previous position
-                        this.pos.y = oldPos.y;
+                        // set if landed on ground
+                        if (this.groundObject = wasMovingDown)
+                        {
+                            // adjust position to slightly above nearest tile boundary
+                            // this prevents gap between object and ground
+                            const epsilon = .0001;
+                            this.pos.y = (oldPos.y-this.size.y/2|0)+this.size.y/2+epsilon;
+                        }
+                        else
+                        {
+                            // move to previous position
+                            this.pos.y = oldPos.y;
+                        }
                     }
                     if (isBlockedX)
                     {