littlejsengine 1.9.9 → 1.9.11

package/dist/littlejs.release.js

@@ -1549,9 +1549,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
@@ -1680,19 +1680,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)
                     {
@@ -2542,6 +2545,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); 
@@ -2553,7 +2560,7 @@ function inputInit()
     oncontextmenu = (e)=> false; // prevent right click menu
 
     // init touch input
-    if (isTouchDevice && touchInputEnable && !headlessMode)
+    if (isTouchDevice && touchInputEnable)
         touchInputInit();
 }
 
@@ -2710,8 +2717,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;
@@ -2924,6 +2931,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;
         }
@@ -3156,10 +3164,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
@@ -3175,20 +3179,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));
@@ -3202,7 +3207,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();
@@ -3218,7 +3224,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
@@ -3227,7 +3233,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)
@@ -3253,7 +3259,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
@@ -3264,7 +3270,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
@@ -4664,7 +4671,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/examples/box2d/game.js

@@ -16,12 +16,13 @@ setShowSplashScreen(true);
 //box2dDebug = 1; // enable box2d debug draw
 
 // game variables
-const maxScenes = 9;
+const maxScenes = 11;
 let scene = 0;
 let sceneName;
 let groundObject;
 let mouseJoint;
-let carWheelJoint;
+let car;
+let repeatSpawnTimer = new Timer;
 
 ///////////////////////////////////////////////////////////////////////////////
 function gameInit()
@@ -54,13 +55,25 @@ function gameUpdate()
             mouseJoint = 0;
         }
     }
-    if (mouseWasPressed(1) || keyWasPressed('KeyZ'))
-        spawnRandomObject(mousePos);
+    if (mouseIsDown(1) || mouseIsDown('KeyZ'))
+    {
+        const isSet = repeatSpawnTimer.isSet();
+        if (!isSet || repeatSpawnTimer.elapsed())
+        {
+            // spawn continuously after a delay
+            isSet || repeatSpawnTimer.set(.5);
+            spawnRandomObject(mousePos);
+        }
+    }
+    else
+        repeatSpawnTimer.unset();
     if (mouseWasPressed(2) || keyWasPressed('KeyX'))
         explosion(mousePos);
     if (mouseJoint)
         mouseJoint.SetTarget(mousePos.getBox2d());
 
+    if (keyWasPressed('KeyR'))
+        loadScene(scene); // reset scene
     if (keyWasPressed('ArrowUp') || keyWasPressed('ArrowDown'))
     {
         // change scene
@@ -69,13 +82,11 @@ function gameUpdate()
         loadScene(scene);
     }
 
-    if (carWheelJoint)
+    if (car)
     {
         // update car control
-        const control = keyIsDown('ArrowLeft') - keyIsDown('ArrowRight');
-        let s = carWheelJoint.GetMotorSpeed();
-        s = control ? clamp(s + control, -40, 40) : s * .8;
-        carWheelJoint.SetMotorSpeed(s);
+        const input = keyIsDown('ArrowLeft') - keyIsDown('ArrowRight');
+        car.applyMotorInput(input);
     }
 }
 
@@ -110,6 +121,14 @@ function gameRender()
 ///////////////////////////////////////////////////////////////////////////////
 function gameRenderPost()
 {
+    if (mouseJoint)
+    {
+        // draw mouse joint
+        const ab = vec2(mouseJoint.GetAnchorB());
+        drawTile(ab, vec2(.3), tile(0), BLACK);
+        drawLine(mousePos, ab, .1, BLACK);
+    }
+
     // draw to overlay canvas for hud rendering
     const pos = vec2(mainCanvasSize.x/2, 50);
     drawText('LittleJS Box2D Demo', 80, 80);