littlejsengine 1.11.9 → 1.11.13

package/src/engineAudio.js

@@ -48,20 +48,20 @@ class Sound
 {
     /** Create a sound object and cache the zzfx samples for later use
      *  @param {Array}  zzfxSound - Array of zzfx parameters, ex. [.5,.5]
-     *  @param {Number} [range=soundDefaultRange] - World space max range of sound, will not play if camera is farther away
-     *  @param {Number} [taper=soundDefaultTaper] - At what percentage of range should it start tapering
+     *  @param {number} [range=soundDefaultRange] - World space max range of sound, will not play if camera is farther away
+     *  @param {number} [taper=soundDefaultTaper] - At what percentage of range should it start tapering
      */
     constructor(zzfxSound, range=soundDefaultRange, taper=soundDefaultTaper)
     {
         if (!soundEnable || headlessMode) return;
 
-        /** @property {Number} - World space max range of sound, will not play if camera is farther away */
+        /** @property {number} - World space max range of sound, will not play if camera is farther away */
         this.range = range;
 
-        /** @property {Number} - At what percentage of range should it start tapering off */
+        /** @property {number} - At what percentage of range should it start tapering off */
         this.taper = taper;
 
-        /** @property {Number} - How much to randomize frequency each time sound plays */
+        /** @property {number} - How much to randomize frequency each time sound plays */
         this.randomness = 0;
 
         if (zzfxSound)
@@ -77,10 +77,10 @@ class Sound
 
     /** Play the sound
      *  @param {Vector2} [pos] - World space position to play the sound, sound is not attenuated if null
-     *  @param {Number}  [volume] - How much to scale volume by (in addition to range fade)
-     *  @param {Number}  [pitch] - How much to scale pitch by (also adjusted by this.randomness)
-     *  @param {Number}  [randomnessScale] - How much to scale randomness
-     *  @param {Boolean} [loop] - Should the sound loop
+     *  @param {number}  [volume] - How much to scale volume by (in addition to range fade)
+     *  @param {number}  [pitch] - How much to scale pitch by (also adjusted by this.randomness)
+     *  @param {number}  [randomnessScale] - How much to scale randomness
+     *  @param {boolean} [loop] - Should the sound loop
      *  @return {AudioBufferSourceNode} - The audio source node
      */
     play(pos, volume=1, pitch=1, randomnessScale=1, loop=false)
@@ -115,7 +115,7 @@ class Sound
     }
 
     /** Set the sound volume of the most recently played instance of this sound
-     *  @param {Number}  [volume] - How much to scale volume by
+     *  @param {number}  [volume] - How much to scale volume by
      */
     setVolume(volume=1)
     {
@@ -137,22 +137,22 @@ class Sound
     getSource() { return this.source; }
 
     /** Play the sound as a note with a semitone offset
-     *  @param {Number}  semitoneOffset - How many semitones to offset pitch
+     *  @param {number}  semitoneOffset - How many semitones to offset pitch
      *  @param {Vector2} [pos] - World space position to play the sound, sound is not attenuated if null
-     *  @param {Number}  [volume=1] - How much to scale volume by (in addition to range fade)
+     *  @param {number}  [volume=1] - How much to scale volume by (in addition to range fade)
      *  @return {AudioBufferSourceNode} - The audio source node
      */
     playNote(semitoneOffset, pos, volume)
     { return this.play(pos, volume, 2**(semitoneOffset/12), 0); }
 
     /** Get how long this sound is in seconds
-     *  @return {Number} - How long the sound is in seconds (undefined if loading)
+     *  @return {number} - How long the sound is in seconds (undefined if loading)
      */
     getDuration() 
     { return this.sampleChannels && this.sampleChannels[0].length / this.sampleRate; }
     
     /** Check if sound is loading, for sounds fetched from a url
-     *  @return {Boolean} - True if sound is loading and not ready to play
+     *  @return {boolean} - True if sound is loading and not ready to play
      */
     isLoading() { return !this.sampleChannels; }
 }
@@ -170,10 +170,10 @@ class Sound
 class SoundWave extends Sound
 {
     /** Create a sound object and cache the wave file for later use
-     *  @param {String} filename - Filename of audio file to load
-     *  @param {Number} [randomness] - How much to randomize frequency each time sound plays
-     *  @param {Number} [range=soundDefaultRange] - World space max range of sound, will not play if camera is farther away
-     *  @param {Number} [taper=soundDefaultTaper] - At what percentage of range should it start tapering off
+     *  @param {string} filename - Filename of audio file to load
+     *  @param {number} [randomness] - How much to randomize frequency each time sound plays
+     *  @param {number} [range=soundDefaultRange] - World space max range of sound, will not play if camera is farther away
+     *  @param {number} [taper=soundDefaultTaper] - At what percentage of range should it start tapering off
      *  @param {Function} [onloadCallback] - callback function to call when sound is loaded
      */
     constructor(filename, randomness=0, range, taper, onloadCallback)
@@ -196,9 +196,9 @@ class SoundWave extends Sound
 }
 
 /** Play an mp3, ogg, or wav audio from a local file or url
- *  @param {String}  filename - Location of sound file to play
- *  @param {Number}  [volume] - How much to scale volume by
- *  @param {Boolean} [loop] - True if the music should loop
+ *  @param {string}  filename - Location of sound file to play
+ *  @param {number}  [volume] - How much to scale volume by
+ *  @param {boolean} [loop] - True if the music should loop
  *  @return {SoundWave} - The sound object for this file
  *  @memberof Audio */
 function playAudioFile(filename, volume=1, loop=false)
@@ -241,7 +241,7 @@ function playAudioFile(filename, volume=1, loop=false)
 class Music extends Sound
 {
     /** Create a music object and cache the zzfx music samples for later use
-     *  @param {[Array, Array, Array, Number]} zzfxMusic - Array of zzfx music parameters
+     *  @param {[Array, Array, Array, number]} zzfxMusic - Array of zzfx music parameters
      */
     constructor(zzfxMusic)
     {
@@ -254,8 +254,8 @@ class Music extends Sound
     }
 
     /** Play the music
-     *  @param {Number}  [volume=1] - How much to scale volume by
-     *  @param {Boolean} [loop] - True if the music should loop
+     *  @param {number}  [volume=1] - How much to scale volume by
+     *  @param {boolean} [loop] - True if the music should loop
      *  @return {AudioBufferSourceNode} - The audio source node
      */
     playMusic(volume, loop=false)
@@ -263,11 +263,11 @@ class Music extends Sound
 }
 
 /** Speak text with passed in settings
- *  @param {String} text - The text to speak
- *  @param {String} [language] - The language/accent to use (examples: en, it, ru, ja, zh)
- *  @param {Number} [volume] - How much to scale volume by
- *  @param {Number} [rate] - How quickly to speak
- *  @param {Number} [pitch] - How much to change the pitch by
+ *  @param {string} text - The text to speak
+ *  @param {string} [language] - The language/accent to use (examples: en, it, ru, ja, zh)
+ *  @param {number} [volume] - How much to scale volume by
+ *  @param {number} [rate] - How quickly to speak
+ *  @param {number} [pitch] - How much to change the pitch by
  *  @return {SpeechSynthesisUtterance} - The utterance that was spoken
  *  @memberof Audio */
 function speak(text, language='', volume=1, rate=1, pitch=1)
@@ -294,9 +294,9 @@ function speak(text, language='', volume=1, rate=1, pitch=1)
 function speakStop() {speechSynthesis && speechSynthesis.cancel();}
 
 /** Get frequency of a note on a musical scale
- *  @param {Number} semitoneOffset - How many semitones away from the root note
- *  @param {Number} [rootFrequency=220] - Frequency at semitone offset 0
- *  @return {Number} - The frequency of the note
+ *  @param {number} semitoneOffset - How many semitones away from the root note
+ *  @param {number} [rootFrequency=220] - Frequency at semitone offset 0
+ *  @return {number} - The frequency of the note
  *  @memberof Audio */
 function getNoteFrequency(semitoneOffset, rootFrequency=220)
 { return rootFrequency * 2**(semitoneOffset/12); }
@@ -305,11 +305,11 @@ function getNoteFrequency(semitoneOffset, rootFrequency=220)
 
 /** 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
- *  @param {Number}   [rate] - The playback rate to use
- *  @param {Number}   [pan] - How much to apply stereo panning
- *  @param {Boolean}  [loop] - True if the sound should loop when it reaches the end
- *  @param {Number}   [sampleRate=44100] - Sample rate for the sound
+ *  @param {number}   [volume] - How much to scale volume by
+ *  @param {number}   [rate] - The playback rate to use
+ *  @param {number}   [pan] - How much to apply stereo panning
+ *  @param {boolean}  [loop] - True if the sound should loop when it reaches the end
+ *  @param {number}   [sampleRate=44100] - Sample rate for the sound
  *  @param {GainNode} [gainNode] - Optional gain node for volume control while playing
  *  @return {AudioBufferSourceNode} - The audio node of the sound played
  *  @memberof Audio */
@@ -368,27 +368,27 @@ function zzfx(...zzfxSound) { return playSamples([zzfxG(...zzfxSound)]); }
 const zzfxR = 44100; 
 
 /** Generate samples for a ZzFX sound
- *  @param {Number}  [volume] - Volume scale (percent)
- *  @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)
- *  @param {Number}  [release] - Release time, how fast sound fades out (seconds)
- *  @param {Number}  [shape] - Shape of the sound wave
- *  @param {Number}  [shapeCurve] - Squareness of wave (0=square, 1=normal, 2=pointy)
- *  @param {Number}  [slide] - How much to slide frequency (kHz/s)
- *  @param {Number}  [deltaSlide] - How much to change slide (kHz/s/s)
- *  @param {Number}  [pitchJump] - Frequency of pitch jump (Hz)
- *  @param {Number}  [pitchJumpTime] - Time of pitch jump (seconds)
- *  @param {Number}  [repeatTime] - Resets some parameters periodically (seconds)
- *  @param {Number}  [noise] - How much random noise to add (percent)
- *  @param {Number}  [modulation] - Frequency of modulation wave, negative flips phase (Hz)
- *  @param {Number}  [bitCrush] - Resamples at a lower frequency in (samples*100)
- *  @param {Number}  [delay] - Overlap sound with itself for reverb and flanger effects (seconds)
- *  @param {Number}  [sustainVolume] - Volume level for sustain (percent)
- *  @param {Number}  [decay] - Decay time, how long to reach sustain after attack (seconds)
- *  @param {Number}  [tremolo] - Trembling effect, rate controlled by repeat time (percent)
- *  @param {Number}  [filter] - Filter cutoff frequency, positive for HPF, negative for LPF (Hz)
+ *  @param {number}  [volume] - Volume scale (percent)
+ *  @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)
+ *  @param {number}  [release] - Release time, how fast sound fades out (seconds)
+ *  @param {number}  [shape] - Shape of the sound wave
+ *  @param {number}  [shapeCurve] - Squareness of wave (0=square, 1=normal, 2=pointy)
+ *  @param {number}  [slide] - How much to slide frequency (kHz/s)
+ *  @param {number}  [deltaSlide] - How much to change slide (kHz/s/s)
+ *  @param {number}  [pitchJump] - Frequency of pitch jump (Hz)
+ *  @param {number}  [pitchJumpTime] - Time of pitch jump (seconds)
+ *  @param {number}  [repeatTime] - Resets some parameters periodically (seconds)
+ *  @param {number}  [noise] - How much random noise to add (percent)
+ *  @param {number}  [modulation] - Frequency of modulation wave, negative flips phase (Hz)
+ *  @param {number}  [bitCrush] - Resamples at a lower frequency in (samples*100)
+ *  @param {number}  [delay] - Overlap sound with itself for reverb and flanger effects (seconds)
+ *  @param {number}  [sustainVolume] - Volume level for sustain (percent)
+ *  @param {number}  [decay] - Decay time, how long to reach sustain after attack (seconds)
+ *  @param {number}  [tremolo] - Trembling effect, rate controlled by repeat time (percent)
+ *  @param {number}  [filter] - Filter cutoff frequency, positive for HPF, negative for LPF (Hz)
  *  @return {Array} - Array of audio samples
  *  @memberof Audio
  */
@@ -494,7 +494,7 @@ function zzfxG
  *  @param {Array} instruments - Array of ZzFX sound parameters
  *  @param {Array} patterns - Array of pattern data
  *  @param {Array} sequence - Array of pattern indexes
- *  @param {Number} [BPM] - Playback speed of the song in BPM
+ *  @param {number} [BPM] - Playback speed of the song in BPM
  *  @return {Array} - Left and right channel sample data
  *  @memberof Audio */
 function zzfxM(instruments, patterns, sequence, BPM = 125) 

package/src/engineDebug.js

@@ -11,37 +11,37 @@
 'use strict';
 
 /** True if debug is enabled
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Debug */
 const debug = true;
 
 /** True if asserts are enabled
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Debug */
 const enableAsserts = true;
 
 /** Size to render debug points by default
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Debug */
 const debugPointSize = .5;
 
 /** True if watermark with FPS should be shown, false in release builds
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Debug */
 let showWatermark = true;
 
 /** Key code used to toggle debug mode, Esc by default
- *  @type {String}
+ *  @type {string}
  *  @default
  *  @memberof Debug */
 let debugKey = 'Escape';
 
 /** True if the debug overlay is active, always false in release builds
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Debug */
 let debugOverlay = false;
@@ -53,7 +53,7 @@ let debugPrimitives = [], debugPhysics = false, debugRaycast = false, debugParti
 // Debug helper functions
 
 /** Asserts if the expression is false, does not do anything in release builds
- *  @param {Boolean} assert
+ *  @param {boolean} assert
  *  @param {Object} [output]
  *  @memberof Debug */
 function ASSERT(assert, output) 
@@ -65,10 +65,10 @@ function ASSERT(assert, output)
 /** Draw a debug rectangle in world space
  *  @param {Vector2} pos
  *  @param {Vector2} [size=Vector2()]
- *  @param {String}  [color]
- *  @param {Number}  [time]
- *  @param {Number}  [angle]
- *  @param {Boolean} [fill]
+ *  @param {string}  [color]
+ *  @param {number}  [time]
+ *  @param {number}  [angle]
+ *  @param {boolean} [fill]
  *  @memberof Debug */
 function debugRect(pos, size=vec2(), color='#fff', time=0, angle=0, fill=false)
 {
@@ -78,11 +78,11 @@ function debugRect(pos, size=vec2(), color='#fff', time=0, angle=0, fill=false)
 
 /** Draw a debug poly in world space
  *  @param {Vector2} pos
- *  @param {Array}   points
- *  @param {String}  [color]
- *  @param {Number}  [time]
- *  @param {Number}  [angle]
- *  @param {Boolean} [fill]
+ *  @param {Array<Vector2>} points
+ *  @param {string}  [color]
+ *  @param {number}  [time]
+ *  @param {number}  [angle]
+ *  @param {boolean} [fill]
  *  @memberof Debug */
 function debugPoly(pos, points, color='#fff', time=0, angle=0, fill=false)
 {
@@ -92,10 +92,10 @@ function debugPoly(pos, points, color='#fff', time=0, angle=0, fill=false)
 
 /** Draw a debug circle in world space
  *  @param {Vector2} pos
- *  @param {Number}  [radius]
- *  @param {String}  [color]
- *  @param {Number}  [time]
- *  @param {Boolean} [fill]
+ *  @param {number}  [radius]
+ *  @param {string}  [color]
+ *  @param {number}  [time]
+ *  @param {boolean} [fill]
  *  @memberof Debug */
 function debugCircle(pos, radius=0, color='#fff', time=0, fill=false)
 {
@@ -105,9 +105,9 @@ function debugCircle(pos, radius=0, color='#fff', time=0, fill=false)
 
 /** Draw a debug point in world space
  *  @param {Vector2} pos
- *  @param {String}  [color]
- *  @param {Number}  [time]
- *  @param {Number}  [angle]
+ *  @param {string}  [color]
+ *  @param {number}  [time]
+ *  @param {number}  [angle]
  *  @memberof Debug */
 function debugPoint(pos, color, time, angle)
 {
@@ -118,9 +118,9 @@ function debugPoint(pos, color, time, angle)
 /** Draw a debug line in world space
  *  @param {Vector2} posA
  *  @param {Vector2} posB
- *  @param {String}  [color]
- *  @param {Number}  [thickness]
- *  @param {Number}  [time]
+ *  @param {string}  [color]
+ *  @param {number}  [thickness]
+ *  @param {number}  [time]
  *  @memberof Debug */
 function debugLine(posA, posB, color, thickness=.1, time)
 {
@@ -134,7 +134,7 @@ function debugLine(posA, posB, color, thickness=.1, time)
  *  @param {Vector2} sA - size A
  *  @param {Vector2} pB - position B
  *  @param {Vector2} sB - size B
- *  @param {String}  [color]
+ *  @param {string}  [color]
  *  @memberof Debug */
 function debugOverlap(pA, sA, pB, sB, color)
 {
@@ -144,13 +144,13 @@ function debugOverlap(pA, sA, pB, sB, color)
 }
 
 /** Draw a debug axis aligned bounding box in world space
- *  @param {String}  text
+ *  @param {string}  text
  *  @param {Vector2} pos
- *  @param {Number}  [size]
- *  @param {String}  [color]
- *  @param {Number}  [time]
- *  @param {Number}  [angle]
- *  @param {String}  [font]
+ *  @param {number}  [size]
+ *  @param {string}  [color]
+ *  @param {number}  [time]
+ *  @param {number}  [angle]
+ *  @param {string}  [font]
  *  @memberof Debug */
 function debugText(text, pos, size=1, color='#fff', time=0, angle=0, font='monospace')
 {
@@ -168,23 +168,23 @@ function debugScreenshot() { debugTakeScreenshot = 1; }
 
 /** Save a canvas to disk 
  *  @param {HTMLCanvasElement} canvas
- *  @param {String}            [filename]
- *  @param {String}            [type]
+ *  @param {string}            [filename]
+ *  @param {string}            [type]
  *  @memberof Debug */
 function debugSaveCanvas(canvas, filename='screenshot', type='image/png')
 { debugSaveDataURL(canvas.toDataURL(type), filename); }
 
 /** Save a text file to disk 
- *  @param {String}     text
- *  @param {String}     [filename]
- *  @param {String}     [type]
+ *  @param {string}     text
+ *  @param {string}     [filename]
+ *  @param {string}     [type]
  *  @memberof Debug */
 function debugSaveText(text, filename='text', type='text/plain')
 { debugSaveDataURL(URL.createObjectURL(new Blob([text], {'type':type})), filename); }
 
 /** Save a data url to disk 
- *  @param {String}     dataURL
- *  @param {String}     filename
+ *  @param {string}     dataURL
+ *  @param {string}     filename
  *  @memberof Debug */
 function debugSaveDataURL(dataURL, filename)
 {
@@ -304,9 +304,12 @@ function debugRender()
         let bestDistance = Infinity;
         for (const o of engineObjects)
         {
-            if (o.canvas || o.destroyed)
+            if (o.destroyed)
                 continue;
 
+            if (o instanceof TileLayer)
+                continue; // prevent tile layers from being picked
+
             o.renderDebugInfo();
             if (!o.size.x || !o.size.y)
                 continue;