littlejsengine 1.11.9 → 1.11.13

package/dist/littlejs.esm.js

@@ -16,37 +16,37 @@
 
 
 /** 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;
@@ -58,7 +58,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) 
@@ -70,10 +70,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)
 {
@@ -83,11 +83,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)
 {
@@ -97,10 +97,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)
 {
@@ -110,9 +110,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)
 {
@@ -123,9 +123,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)
 {
@@ -139,7 +139,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)
 {
@@ -149,13 +149,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')
 {
@@ -173,23 +173,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)
 {
@@ -309,9 +309,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;
@@ -483,112 +486,112 @@ function debugRender()
 
 
 /** A shortcut to get Math.PI
- *  @type {Number}
+ *  @type {number}
  *  @default Math.PI
  *  @memberof Utilities */
 const PI = Math.PI;
 
 /** Returns absolute value of value passed in
- *  @param {Number} value
- *  @return {Number}
+ *  @param {number} value
+ *  @return {number}
  *  @memberof Utilities */
 function abs(value) { return Math.abs(value); }
 
 /** Returns lowest of two values passed in
- *  @param {Number} valueA
- *  @param {Number} valueB
- *  @return {Number}
+ *  @param {number} valueA
+ *  @param {number} valueB
+ *  @return {number}
  *  @memberof Utilities */
 function min(valueA, valueB) { return Math.min(valueA, valueB); }
 
 /** Returns highest of two values passed in
- *  @param {Number} valueA
- *  @param {Number} valueB
- *  @return {Number}
+ *  @param {number} valueA
+ *  @param {number} valueB
+ *  @return {number}
  *  @memberof Utilities */
 function max(valueA, valueB) { return Math.max(valueA, valueB); }
 
 /** Returns the sign of value passed in
- *  @param {Number} value
- *  @return {Number}
+ *  @param {number} value
+ *  @return {number}
  *  @memberof Utilities */
 function sign(value) { return Math.sign(value); }
 
 /** Returns first parm modulo the second param, but adjusted so negative numbers work as expected
- *  @param {Number} dividend
- *  @param {Number} [divisor]
- *  @return {Number}
+ *  @param {number} dividend
+ *  @param {number} [divisor]
+ *  @return {number}
  *  @memberof Utilities */
 function mod(dividend, divisor=1) { return ((dividend % divisor) + divisor) % divisor; }
 
 /** Clamps the value between max and min
- *  @param {Number} value
- *  @param {Number} [min]
- *  @param {Number} [max]
- *  @return {Number}
+ *  @param {number} value
+ *  @param {number} [min]
+ *  @param {number} [max]
+ *  @return {number}
  *  @memberof Utilities */
 function clamp(value, min=0, max=1) { return value < min ? min : value > max ? max : value; }
 
 /** Returns what percentage the value is between valueA and valueB
- *  @param {Number} value
- *  @param {Number} valueA
- *  @param {Number} valueB
- *  @return {Number}
+ *  @param {number} value
+ *  @param {number} valueA
+ *  @param {number} valueB
+ *  @return {number}
  *  @memberof Utilities */
 function percent(value, valueA, valueB)
 { return (valueB-=valueA) ? clamp((value-valueA)/valueB) : 0; }
 
 /** Linearly interpolates between values passed in using percent
- *  @param {Number} percent
- *  @param {Number} valueA
- *  @param {Number} valueB
- *  @return {Number}
+ *  @param {number} percent
+ *  @param {number} valueA
+ *  @param {number} valueB
+ *  @return {number}
  *  @memberof Utilities */
 function lerp(percent, valueA, valueB) { return valueA + clamp(percent) * (valueB-valueA); }
 
 /** Returns signed wrapped distance between the two values passed in
- *  @param {Number} valueA
- *  @param {Number} valueB
- *  @param {Number} [wrapSize]
- *  @returns {Number}
+ *  @param {number} valueA
+ *  @param {number} valueB
+ *  @param {number} [wrapSize]
+ *  @returns {number}
  *  @memberof Utilities */
 function distanceWrap(valueA, valueB, wrapSize=1)
 { const d = (valueA - valueB) % wrapSize; return d*2 % wrapSize - d; }
 
 /** Linearly interpolates between values passed in with wrapping
- *  @param {Number} percent
- *  @param {Number} valueA
- *  @param {Number} valueB
- *  @param {Number} [wrapSize]
- *  @returns {Number}
+ *  @param {number} percent
+ *  @param {number} valueA
+ *  @param {number} valueB
+ *  @param {number} [wrapSize]
+ *  @returns {number}
  *  @memberof Utilities */
 function lerpWrap(percent, valueA, valueB, wrapSize=1)
 { return valueB + clamp(percent) * distanceWrap(valueA, valueB, wrapSize); }
 
 /** Returns signed wrapped distance between the two angles passed in
- *  @param {Number} angleA
- *  @param {Number} angleB
- *  @returns {Number}
+ *  @param {number} angleA
+ *  @param {number} angleB
+ *  @returns {number}
  *  @memberof Utilities */
 function distanceAngle(angleA, angleB) { return distanceWrap(angleA, angleB, 2*PI); }
 
 /** Linearly interpolates between the angles passed in with wrapping
- *  @param {Number} percent
- *  @param {Number} angleA
- *  @param {Number} angleB
- *  @returns {Number}
+ *  @param {number} percent
+ *  @param {number} angleA
+ *  @param {number} angleB
+ *  @returns {number}
  *  @memberof Utilities */
 function lerpAngle(percent, angleA, angleB) { return lerpWrap(percent, angleA, angleB, 2*PI); }
 
 /** Applies smoothstep function to the percentage value
- *  @param {Number} percent
- *  @return {Number}
+ *  @param {number} percent
+ *  @return {number}
  *  @memberof Utilities */
 function smoothStep(percent) { return percent * percent * (3 - 2 * percent); }
 
 /** Returns the nearest power of two not less then the value
- *  @param {Number} value
- *  @return {Number}
+ *  @param {number} value
+ *  @return {number}
  *  @memberof Utilities */
 function nearestPowerOfTwo(value) { return 2**Math.ceil(Math.log2(value)); }
 
@@ -597,7 +600,7 @@ function nearestPowerOfTwo(value) { return 2**Math.ceil(Math.log2(value)); }
  *  @param {Vector2} sizeA         - Size of box A
  *  @param {Vector2} posB          - Center of box B
  *  @param {Vector2} [sizeB=(0,0)] - Size of box B, a point if undefined
- *  @return {Boolean}              - True if overlapping
+ *  @return {boolean}              - True if overlapping
  *  @memberof Utilities */
 function isOverlapping(posA, sizeA, posB, sizeB=vec2())
 { 
@@ -610,7 +613,7 @@ function isOverlapping(posA, sizeA, posB, sizeB=vec2())
  *  @param {Vector2} end   - End of raycast
  *  @param {Vector2} pos   - Center of box
  *  @param {Vector2} size  - Size of box
- *  @return {Boolean}      - True if intersecting
+ *  @return {boolean}      - True if intersecting
  *  @memberof Utilities */
 function isIntersecting(start, end, pos, size)
 {
@@ -647,17 +650,17 @@ function isIntersecting(start, end, pos, size)
 }
 
 /** Returns an oscillating wave between 0 and amplitude with frequency of 1 Hz by default
- *  @param {Number} [frequency] - Frequency of the wave in Hz
- *  @param {Number} [amplitude] - Amplitude (max height) of the wave
- *  @param {Number} [t=time]    - Value to use for time of the wave
- *  @return {Number}            - Value waving between 0 and amplitude
+ *  @param {number} [frequency] - Frequency of the wave in Hz
+ *  @param {number} [amplitude] - Amplitude (max height) of the wave
+ *  @param {number} [t=time]    - Value to use for time of the wave
+ *  @return {number}            - Value waving between 0 and amplitude
  *  @memberof Utilities */
 function wave(frequency=1, amplitude=1, t=time)
 { return amplitude/2 * (1 - Math.cos(t*frequency*2*PI)); }
 
 /** Formats seconds to mm:ss style for display purposes 
- *  @param {Number} t - time in seconds
- *  @return {String}
+ *  @param {number} t - time in seconds
+ *  @return {string}
  *  @memberof Utilities */
 function formatTime(t) { return (t/60|0) + ':' + (t%60<10?'0':'') + (t%60|0); }
 
@@ -667,34 +670,34 @@ function formatTime(t) { return (t/60|0) + ':' + (t%60<10?'0':'') + (t%60|0); }
  *  @namespace Random */
 
 /** Returns a random value between the two values passed in
- *  @param {Number} [valueA]
- *  @param {Number} [valueB]
- *  @return {Number}
+ *  @param {number} [valueA]
+ *  @param {number} [valueB]
+ *  @return {number}
  *  @memberof Random */
 function rand(valueA=1, valueB=0) { return valueB + Math.random() * (valueA-valueB); }
 
 /** Returns a floored random value between the two values passed in
  *  The upper bound is exclusive. (If 2 is passed in, result will be 0 or 1)
- *  @param {Number} valueA
- *  @param {Number} [valueB]
- *  @return {Number}
+ *  @param {number} valueA
+ *  @param {number} [valueB]
+ *  @return {number}
  *  @memberof Random */
 function randInt(valueA, valueB=0) { return Math.floor(rand(valueA,valueB)); }
 
 /** Randomly returns either -1 or 1
- *  @return {Number}
+ *  @return {number}
  *  @memberof Random */
 function randSign() { return randInt(2) * 2 - 1; }
 
 /** Returns a random Vector2 with the passed in length
- *  @param {Number} [length]
+ *  @param {number} [length]
  *  @return {Vector2}
  *  @memberof Random */
 function randVector(length=1) { return new Vector2().setAngle(rand(2*PI), length); }
 
 /** Returns a random Vector2 within a circular shape
- *  @param {Number} [radius]
- *  @param {Number} [minRadius]
+ *  @param {number} [radius]
+ *  @param {number} [minRadius]
  *  @return {Vector2}
  *  @memberof Random */
 function randInCircle(radius=1, minRadius=0)
@@ -703,7 +706,7 @@ function randInCircle(radius=1, minRadius=0)
 /** Returns a random color between the two passed in colors, combine components if linear
  *  @param {Color}   [colorA=(1,1,1,1)]
  *  @param {Color}   [colorB=(0,0,0,1)]
- *  @param {Boolean} [linear]
+ *  @param {boolean} [linear]
  *  @return {Color}
  *  @memberof Random */
 function randColor(colorA=new Color, colorB=new Color(0,0,0,1), linear=false)
@@ -727,17 +730,17 @@ function randColor(colorA=new Color, colorB=new Color(0,0,0,1), linear=false)
 class RandomGenerator
 {
     /** Create a random number generator with the seed passed in
-     *  @param {Number} seed - Starting seed */
+     *  @param {number} seed - Starting seed */
     constructor(seed)
     {
-        /** @property {Number} - random seed */
+        /** @property {number} - random seed */
         this.seed = seed;
     }
 
     /** Returns a seeded random value between the two values passed in
-    *  @param {Number} [valueA]
-    *  @param {Number} [valueB]
-    *  @return {Number} */
+    *  @param {number} [valueA]
+    *  @param {number} [valueB]
+    *  @return {number} */
     float(valueA=1, valueB=0)
     {
         // xorshift algorithm
@@ -748,13 +751,13 @@ class RandomGenerator
     }
 
     /** Returns a floored seeded random value the two values passed in
-    *  @param {Number} valueA
-    *  @param {Number} [valueB]
-    *  @return {Number} */
+    *  @param {number} valueA
+    *  @param {number} [valueB]
+    *  @return {number} */
     int(valueA, valueB=0) { return Math.floor(this.float(valueA, valueB)); }
 
     /** Randomly returns either -1 or 1 deterministically
-    *  @return {Number} */
+    *  @return {number} */
     sign() { return this.float() > .5 ? 1 : -1; }
 }
 
@@ -762,8 +765,8 @@ class RandomGenerator
 
 /** 
  * Create a 2d vector, can take another Vector2 to copy, 2 scalars, or 1 scalar
- * @param {(Number|Vector2)} [x]
- * @param {Number} [y]
+ * @param {Vector2|number} [x]
+ * @param {number} [y]
  * @return {Vector2}
  * @example
  * let a = vec2(0, 1); // vector with coordinates (0, 1)
@@ -782,7 +785,7 @@ function vec2(x=0, y)
 /** 
  * Check if object is a valid Vector2
  * @param {any} v
- * @return {Boolean}
+ * @return {boolean}
  * @memberof Utilities
  */
 function isVector2(v) { return v instanceof Vector2; }
@@ -799,20 +802,20 @@ function isVector2(v) { return v instanceof Vector2; }
 class Vector2
 {
     /** Create a 2D vector with the x and y passed in, can also be created with vec2()
-     *  @param {Number} [x] - X axis location
-     *  @param {Number} [y] - Y axis location */
+     *  @param {number} [x] - X axis location
+     *  @param {number} [y] - Y axis location */
     constructor(x=0, y=0)
     {
-        /** @property {Number} - X axis location */
+        /** @property {number} - X axis location */
         this.x = x;
-        /** @property {Number} - Y axis location */
+        /** @property {number} - Y axis location */
         this.y = y;
         ASSERT(this.isValid());
     }
 
     /** Sets values of this vector and returns self
-     *  @param {Number} [x] - X axis location
-     *  @param {Number} [y] - Y axis location
+     *  @param {number} [x] - X axis location
+     *  @param {number} [y] - Y axis location
      *  @return {Vector2} */
     set(x=0, y=0)
     {
@@ -863,7 +866,7 @@ class Vector2
     }
 
     /** Returns a copy of this vector scaled by the vector passed in
-     *  @param {Number} s - scale
+     *  @param {number} s - scale
      *  @return {Vector2} */
     scale(s)
     {
@@ -872,16 +875,16 @@ class Vector2
     }
 
     /** Returns the length of this vector
-     * @return {Number} */
+     * @return {number} */
     length() { return this.lengthSquared()**.5; }
 
     /** Returns the length of this vector squared
-     * @return {Number} */
+     * @return {number} */
     lengthSquared() { return this.x**2 + this.y**2; }
 
     /** Returns the distance from this vector to vector passed in
      * @param {Vector2} v - other vector
-     * @return {Number} */
+     * @return {number} */
     distance(v)
     {
         ASSERT(isVector2(v));
@@ -890,7 +893,7 @@ class Vector2
 
     /** Returns the distance squared from this vector to vector passed in
      * @param {Vector2} v - other vector
-     * @return {Number} */
+     * @return {number} */
     distanceSquared(v)
     {
         ASSERT(isVector2(v));
@@ -898,7 +901,7 @@ class Vector2
     }
 
     /** Returns a new vector in same direction as this one with the length passed in
-     * @param {Number} [length]
+     * @param {number} [length]
      * @return {Vector2} */
     normalize(length=1)
     {
@@ -907,7 +910,7 @@ class Vector2
     }
 
     /** Returns a new vector clamped to length passed in
-     * @param {Number} [length]
+     * @param {number} [length]
      * @return {Vector2} */
     clampLength(length=1)
     {
@@ -917,7 +920,7 @@ class Vector2
 
     /** Returns the dot product of this and the vector passed in
      * @param {Vector2} v - other vector
-     * @return {Number} */
+     * @return {number} */
     dot(v)
     {
         ASSERT(isVector2(v));
@@ -926,7 +929,7 @@ class Vector2
 
     /** Returns the cross product of this and the vector passed in
      * @param {Vector2} v - other vector
-     * @return {Number} */
+     * @return {number} */
     cross(v)
     {
         ASSERT(isVector2(v));
@@ -934,12 +937,12 @@ class Vector2
     }
 
     /** Returns the clockwise angle of this vector, up is angle 0
-     * @return {Number} */
+     * @return {number} */
     angle() { return Math.atan2(this.x, this.y); }
 
     /** Sets this vector with clockwise angle and length passed in
-     * @param {Number} [angle]
-     * @param {Number} [length]
+     * @param {number} [angle]
+     * @param {number} [length]
      * @return {Vector2} */
     setAngle(angle=0, length=1) 
     {
@@ -949,7 +952,7 @@ class Vector2
     }
 
     /** Returns copy of this vector rotated by the clockwise angle passed in
-     * @param {Number} angle
+     * @param {number} angle
      * @return {Vector2} */
     rotate(angle)
     { 
@@ -958,8 +961,8 @@ class Vector2
     }
 
     /** Set the integer direction of this vector, corresponding to multiples of 90 degree rotation (0-3)
-     * @param {Number} [direction]
-     * @param {Number} [length] */
+     * @param {number} [direction]
+     * @param {number} [length] */
     setDirection(direction, length=1)
     {
         direction = mod(direction, 4);
@@ -969,7 +972,7 @@ class Vector2
     }
 
     /** Returns the integer direction of this vector, corresponding to multiples of 90 degree rotation (0-3)
-     * @return {Number} */
+     * @return {number} */
     direction()
     { return abs(this.x) > abs(this.y) ? this.x < 0 ? 3 : 1 : this.y < 0 ? 2 : 0; }
 
@@ -982,12 +985,12 @@ class Vector2
     floor() { return new Vector2(Math.floor(this.x), Math.floor(this.y)); }
 
     /** Returns the area this vector covers as a rectangle
-     * @return {Number} */
+     * @return {number} */
     area() { return abs(this.x * this.y); }
 
     /** Returns a new vector that is p percent between this and the vector passed in
      * @param {Vector2} v - other vector
-     * @param {Number}  percent
+     * @param {number}  percent
      * @return {Vector2} */
     lerp(v, percent)
     {
@@ -997,7 +1000,7 @@ class Vector2
 
     /** Returns true if this vector is within the bounds of an array size passed in
      * @param {Vector2} arraySize
-     * @return {Boolean} */
+     * @return {boolean} */
     arrayCheck(arraySize)
     {
         ASSERT(isVector2(arraySize));
@@ -1005,8 +1008,8 @@ class Vector2
     }
 
     /** Returns this vector expressed as a string
-     * @param {Number} digits - precision to display
-     * @return {String} */
+     * @param {number} digits - precision to display
+     * @return {string} */
     toString(digits=3) 
     {
         if (debug)
@@ -1014,7 +1017,7 @@ class Vector2
     }
 
     /** Checks if this is a valid vector
-     * @return {Boolean} */
+     * @return {boolean} */
     isValid()
     {
         return typeof this.x == 'number' && !isNaN(this.x)
@@ -1026,10 +1029,10 @@ class Vector2
 
 /** 
  * Create a color object with RGBA values, white by default
- * @param {Number} [r=1] - red
- * @param {Number} [g=1] - green
- * @param {Number} [b=1] - blue
- * @param {Number} [a=1] - alpha
+ * @param {number} [r=1] - red
+ * @param {number} [g=1] - green
+ * @param {number} [b=1] - blue
+ * @param {number} [a=1] - alpha
  * @return {Color}
  * @memberof Utilities
  */
@@ -1037,10 +1040,10 @@ function rgb(r, g, b, a) { return new Color(r, g, b, a); }
 
 /** 
  * Create a color object with HSLA values, white by default
- * @param {Number} [h=0] - hue
- * @param {Number} [s=0] - saturation
- * @param {Number} [l=1] - lightness
- * @param {Number} [a=1] - alpha
+ * @param {number} [h=0] - hue
+ * @param {number} [s=0] - saturation
+ * @param {number} [l=1] - lightness
+ * @param {number} [a=1] - alpha
  * @return {Color}
  * @memberof Utilities
  */
@@ -1049,7 +1052,7 @@ function hsl(h, s, l, a) { return new Color().setHSLA(h, s, l, a); }
 /** 
  * Check if object is a valid Color
  * @param {any} c
- * @return {Boolean}
+ * @return {boolean}
  * @memberof Utilities
  */
 function isColor(c) { return c instanceof Color; }
@@ -1066,28 +1069,28 @@ function isColor(c) { return c instanceof Color; }
 class Color
 {
     /** Create a color with the rgba components passed in, white by default
-     *  @param {Number} [r] - red
-     *  @param {Number} [g] - green
-     *  @param {Number} [b] - blue
-     *  @param {Number} [a] - alpha*/
+     *  @param {number} [r] - red
+     *  @param {number} [g] - green
+     *  @param {number} [b] - blue
+     *  @param {number} [a] - alpha*/
     constructor(r=1, g=1, b=1, a=1)
     {
-        /** @property {Number} - Red */
+        /** @property {number} - Red */
         this.r = r;
-        /** @property {Number} - Green */
+        /** @property {number} - Green */
         this.g = g;
-        /** @property {Number} - Blue */
+        /** @property {number} - Blue */
         this.b = b;
-        /** @property {Number} - Alpha */
+        /** @property {number} - Alpha */
         this.a = a;
         ASSERT(this.isValid());
     }
 
     /** Sets values of this color and returns self
-     *  @param {Number} [r] - red
-     *  @param {Number} [g] - green
-     *  @param {Number} [b] - blue
-     *  @param {Number} [a] - alpha
+     *  @param {number} [r] - red
+     *  @param {number} [g] - green
+     *  @param {number} [b] - blue
+     *  @param {number} [a] - alpha
      *  @return {Color} */
     set(r=1, g=1, b=1, a=1)
     {
@@ -1140,8 +1143,8 @@ class Color
     }
 
     /** Returns a copy of this color scaled by the value passed in, alpha can be scaled separately
-     * @param {Number} scale
-     * @param {Number} [alphaScale=scale]
+     * @param {number} scale
+     * @param {number} [alphaScale=scale]
      * @return {Color} */
     scale(scale, alphaScale=scale) 
     { return new Color(this.r*scale, this.g*scale, this.b*scale, this.a*alphaScale); }
@@ -1152,7 +1155,7 @@ class Color
 
     /** Returns a new color that is p percent between this and the color passed in
      * @param {Color}  c - other color
-     * @param {Number} percent
+     * @param {number} percent
      * @return {Color} */
     lerp(c, percent)
     {
@@ -1161,10 +1164,10 @@ class Color
     }
 
     /** Sets this color given a hue, saturation, lightness, and alpha
-     * @param {Number} [h] - hue
-     * @param {Number} [s] - saturation
-     * @param {Number} [l] - lightness
-     * @param {Number} [a] - alpha
+     * @param {number} [h] - hue
+     * @param {number} [s] - saturation
+     * @param {number} [l] - lightness
+     * @param {number} [a] - alpha
      * @return {Color} */
     setHSLA(h=0, s=0, l=1, a=1)
     {
@@ -1185,7 +1188,7 @@ class Color
     }
 
     /** Returns this color expressed in hsla format
-     * @return {Array} */
+     * @return {Array<number>} */
     HSLA()
     {
         const r = clamp(this.r);
@@ -1212,8 +1215,8 @@ class Color
     }
 
     /** Returns a new color that has each component randomly adjusted
-     * @param {Number} [amount]
-     * @param {Number} [alphaAmount]
+     * @param {number} [amount]
+     * @param {number} [alphaAmount]
      * @return {Color} */
     mutate(amount=.05, alphaAmount=0) 
     {
@@ -1227,8 +1230,8 @@ class Color
     }
 
     /** Returns this color expressed as a hex color code
-     * @param {Boolean} [useAlpha] - if alpha should be included in result
-     * @return {String} */
+     * @param {boolean} [useAlpha] - if alpha should be included in result
+     * @return {string} */
     toString(useAlpha = true)      
     { 
         const toHex = (c)=> ((c=clamp(c)*255|0)<16 ? '0' : '') + c.toString(16);
@@ -1236,7 +1239,7 @@ class Color
     }
     
     /** Set this color from a hex code
-     * @param {String} hex - html hex code
+     * @param {string} hex - html hex code
      * @return {Color} */
     setHex(hex)
     {
@@ -1265,7 +1268,7 @@ class Color
     }
     
     /** Returns this color expressed as 32 bit RGBA value
-     * @return {Number} */
+     * @return {number} */
     rgbaInt()  
     {
         const r = clamp(this.r)*255|0;
@@ -1276,7 +1279,7 @@ class Color
     }
 
     /** Checks if this is a valid color
-     * @return {Boolean} */
+     * @return {boolean} */
     isValid()
     {
         return typeof this.r == 'number' && !isNaN(this.r)
@@ -1358,42 +1361,42 @@ const MAGENTA = rgb(1,0,1);
 class Timer
 {
     /** Create a timer object set time passed in
-     *  @param {Number} [timeLeft] - How much time left before the timer elapses in seconds */
+     *  @param {number} [timeLeft] - How much time left before the timer elapses in seconds */
     constructor(timeLeft) { this.time = timeLeft == undefined ? undefined : time + timeLeft; this.setTime = timeLeft; }
 
     /** Set the timer with seconds passed in
-     *  @param {Number} [timeLeft] - How much time left before the timer is elapsed in seconds */
+     *  @param {number} [timeLeft] - How much time left before the timer is elapsed in seconds */
     set(timeLeft=0) { this.time = time + timeLeft; this.setTime = timeLeft; }
 
     /** Unset the timer */
     unset() { this.time = undefined; }
 
     /** Returns true if set
-     * @return {Boolean} */
+     * @return {boolean} */
     isSet() { return this.time != undefined; }
 
     /** Returns true if set and has not elapsed
-     * @return {Boolean} */
+     * @return {boolean} */
     active() { return time < this.time; }
 
     /** Returns true if set and elapsed
-     * @return {Boolean} */
+     * @return {boolean} */
     elapsed() { return time >= this.time; }
 
     /** Get how long since elapsed, returns 0 if not set (returns negative if currently active)
-     * @return {Number} */
+     * @return {number} */
     get() { return this.isSet()? time - this.time : 0; }
 
     /** Get percentage elapsed based on time it was set to, returns 0 if not set
-     * @return {Number} */
+     * @return {number} */
     getPercent() { return this.isSet()? 1-percent(this.time - time, 0, this.setTime) : 0; }
     
     /** Returns this timer expressed as a string
-     * @return {String} */
+     * @return {string} */
     toString() { if (debug) { return this.isSet() ? Math.abs(this.get()) + ' seconds ' + (this.get()<0 ? 'before' : 'after' ) : 'unset'; }}
     
     /** Get how long since elapsed, returns 0 if not set (returns negative if currently active)
-     * @return {Number} */
+     * @return {number} */
     valueOf()               { return this.get(); }
 }
 /**
@@ -1414,7 +1417,7 @@ class Timer
 let cameraPos = vec2();
 
 /** Scale of camera in world space
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let cameraScale = 32;
@@ -1436,31 +1439,34 @@ let canvasMaxSize = vec2(1920, 1080);
 let canvasFixedSize = vec2();
 
 /** Use nearest neighbor scaling algorithm for canvas for more pixelated look
- *  @type {Boolean}
+ *  - Must be set before startup to take effect
+ *  - If enabled sets css image-rendering:pixelated
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let canvasPixelated = true;
 
 /** Disables texture filtering for crisper pixel art
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let tilesPixelated = true;
 
 /** Default font used for text rendering
- *  @type {String}
+ *  @type {string}
  *  @default
  *  @memberof Settings */
 let fontDefault = 'arial';
 
 /** Enable to show the LittleJS splash screen be shown on startup
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let showSplashScreen = false;
 
 /** Disables all rendering, audio, and input for servers
- *  @type {Boolean}
+ *  - Must be set before startup to take effect
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let headlessMode = false;
@@ -1469,13 +1475,15 @@ let headlessMode = false;
 // WebGL settings
 
 /** Enable webgl rendering, webgl can be disabled and removed from build (with some features disabled)
- *  @type {Boolean}
+ *  - Must be set before startup to take effect
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let glEnable = true;
 
 /** Fixes slow rendering in some browsers by not compositing the WebGL canvas
- *  @type {Boolean}
+ *  - Must be set before startup to take effect
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let glOverlay = true;
@@ -1490,7 +1498,7 @@ let glOverlay = true;
 let tileSizeDefault = vec2(16);
 
 /** How many pixels smaller to draw tiles to prevent bleeding from neighbors
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let tileFixBleedScale = 0;
@@ -1499,55 +1507,55 @@ let tileFixBleedScale = 0;
 // Object settings
 
 /** Enable physics solver for collisions between objects
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let enablePhysicsSolver = true;
 
 /** Default object mass for collision calculations (how heavy objects are)
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let objectDefaultMass = 1;
 
 /** How much to slow velocity by each frame (0-1)
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let objectDefaultDamping = 1;
 
 /** How much to slow angular velocity each frame (0-1)
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let objectDefaultAngleDamping = 1;
 
 /** How much to bounce when a collision occurs (0-1)
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let objectDefaultElasticity = 0;
 
 /** How much to slow when touching (0-1)
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let objectDefaultFriction = .8;
 
 /** Clamp max speed to avoid fast objects missing collisions
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let objectMaxSpeed = 1;
 
 /** How much gravity to apply to objects along the Y axis, negative is down
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let gravity = 0;
 
 /** Scales emit rate of particles, useful for low graphics mode (0 disables particle emitters)
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let particleEmitRateScale = 1;
@@ -1556,58 +1564,59 @@ let particleEmitRateScale = 1;
 // Input settings
 
 /** Should gamepads be allowed
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let gamepadsEnable = true;
 
 /** If true, the dpad input is also routed to the left analog stick (for better accessability)
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let gamepadDirectionEmulateStick = true;
 
 /** If true the WASD keys are also routed to the direction keys (for better accessability)
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let inputWASDEmulateDirection = true;
 
 /** True if touch input is enabled for mobile devices
  *  - Touch events will be routed to mouse events
- *  @type {Boolean}
+ *  - Must be set before startup to take effect
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let touchInputEnable = true;
 
 /** True if touch gamepad should appear on mobile devices
  *  - Supports left analog stick, 4 face buttons and start button (button 9)
- *  - Must be set by end of gameInit to be activated
- *  @type {Boolean}
+ *  - Must be set before startup to take effect
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let touchGamepadEnable = false;
 
 /** True if touch gamepad should be analog stick or false to use if 8 way dpad
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let touchGamepadAnalog = true;
 
 /** Size of virtual gamepad for touch devices in pixels
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let touchGamepadSize = 99;
 
 /** Transparency of touch gamepad overlay
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let touchGamepadAlpha = .3;
 
 /** Allow vibration hardware if it exists
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let vibrateEnable = true;
@@ -1616,25 +1625,25 @@ let vibrateEnable = true;
 // Audio settings
 
 /** All audio code can be disabled and removed from build
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let soundEnable = true;
 
 /** Volume scale to apply to all sound, music and speech
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let soundVolume = .3;
 
 /** Default range where sound no longer plays
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let soundDefaultRange = 40;
 
 /** Default range percent to start tapering off sound (0-1)
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let soundDefaultTaper = .7;
@@ -1643,13 +1652,13 @@ let soundDefaultTaper = .7;
 // Medals settings
 
 /** How long to show medals for in seconds
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let medalDisplayTime = 5;
 
 /** How quickly to slide on/off medals in seconds
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Settings */
 let medalDisplaySlideTime = .5;
@@ -1660,14 +1669,8 @@ let medalDisplaySlideTime = .5;
  *  @memberof Settings */
 let medalDisplaySize = vec2(640, 80);
 
-/** Size of icon in medal display
- *  @type {Number}
- *  @default
- *  @memberof Settings */
-let medalDisplayIconSize = 50;
-
 /** Set to stop medals from being unlockable (like if cheats are enabled)
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default
  *  @memberof Settings */
 let medalsPreventUnlock = false;
@@ -1681,7 +1684,7 @@ let medalsPreventUnlock = false;
 function setCameraPos(pos) { cameraPos = pos; }
 
 /** Set scale of camera in world space
- *  @param {Number} scale
+ *  @param {number} scale
  *  @memberof Settings */
 function setCameraScale(scale) { cameraScale = scale; }
 
@@ -1696,37 +1699,37 @@ function setCanvasMaxSize(size) { canvasMaxSize = size; }
 function setCanvasFixedSize(size) { canvasFixedSize = size; }
 
 /** Use nearest neighbor scaling algorithm for canvas for more pixelated look
- *  @param {Boolean} pixelated
+ *  @param {boolean} pixelated
  *  @memberof Settings */
 function setCanvasPixelated(pixelated) { canvasPixelated = pixelated; }
 
 /** Disables texture filtering for crisper pixel art
- *  @param {Boolean} pixelated
+ *  @param {boolean} pixelated
  *  @memberof Settings */
 function setTilesPixelated(pixelated) { tilesPixelated = pixelated; }
 
 /** Set default font used for text rendering
- *  @param {String} font
+ *  @param {string} font
  *  @memberof Settings */
 function setFontDefault(font) { fontDefault = font; }
 
 /** Set if the LittleJS splash screen be shown on startup
- *  @param {Boolean} show
+ *  @param {boolean} show
  *  @memberof Settings */
 function setShowSplashScreen(show) { showSplashScreen = show; }
 
 /** Set to disable rendering, audio, and input for servers
- *  @param {Boolean} headless
+ *  @param {boolean} headless
  *  @memberof Settings */
 function setHeadlessMode(headless) { headlessMode = headless; }
 
 /** Set if webgl rendering is enabled
- *  @param {Boolean} enable
+ *  @param {boolean} enable
  *  @memberof Settings */
 function setGlEnable(enable) { glEnable = enable; }
 
 /** Set to not composite the WebGL canvas
- *  @param {Boolean} overlay
+ *  @param {boolean} overlay
  *  @memberof Settings */
 function setGlOverlay(overlay) { glOverlay = overlay; }
 
@@ -1736,107 +1739,107 @@ function setGlOverlay(overlay) { glOverlay = overlay; }
 function setTileSizeDefault(size) { tileSizeDefault = size; }
 
 /** Set to prevent tile bleeding from neighbors in pixels
- *  @param {Number} scale
+ *  @param {number} scale
  *  @memberof Settings */
 function setTileFixBleedScale(scale) { tileFixBleedScale = scale; }
 
 /** Set if collisions between objects are enabled
- *  @param {Boolean} enable
+ *  @param {boolean} enable
  *  @memberof Settings */
 function setEnablePhysicsSolver(enable) { enablePhysicsSolver = enable; }
 
 /** Set default object mass for collision calculations
- *  @param {Number} mass
+ *  @param {number} mass
  *  @memberof Settings */
 function setObjectDefaultMass(mass) { objectDefaultMass = mass; }
 
 /** Set how much to slow velocity by each frame
- *  @param {Number} damp
+ *  @param {number} damp
  *  @memberof Settings */
 function setObjectDefaultDamping(damp) { objectDefaultDamping = damp; }
 
 /** Set how much to slow angular velocity each frame
- *  @param {Number} damp
+ *  @param {number} damp
  *  @memberof Settings */
 function setObjectDefaultAngleDamping(damp) { objectDefaultAngleDamping = damp; }
 
 /** Set how much to bounce when a collision occur
- *  @param {Number} elasticity
+ *  @param {number} elasticity
  *  @memberof Settings */
 function setObjectDefaultElasticity(elasticity) { objectDefaultElasticity = elasticity; }
 
 /** Set how much to slow when touching
- *  @param {Number} friction
+ *  @param {number} friction
  *  @memberof Settings */
 function setObjectDefaultFriction(friction) { objectDefaultFriction = friction; }
 
 /** Set max speed to avoid fast objects missing collisions
- *  @param {Number} speed
+ *  @param {number} speed
  *  @memberof Settings */
 function setObjectMaxSpeed(speed) { objectMaxSpeed = speed; }
 
 /** Set how much gravity to apply to objects along the Y axis
- *  @param {Number} newGravity
+ *  @param {number} newGravity
  *  @memberof Settings */
 function setGravity(newGravity) { gravity = newGravity; }
 
 /** Set to scales emit rate of particles
- *  @param {Number} scale
+ *  @param {number} scale
  *  @memberof Settings */
 function setParticleEmitRateScale(scale) { particleEmitRateScale = scale; }
 
 /** Set if gamepads are enabled
- *  @param {Boolean} enable
+ *  @param {boolean} enable
  *  @memberof Settings */
 function setGamepadsEnable(enable) { gamepadsEnable = enable; }
 
 /** Set if the dpad input is also routed to the left analog stick
- *  @param {Boolean} enable
+ *  @param {boolean} enable
  *  @memberof Settings */
 function setGamepadDirectionEmulateStick(enable) { gamepadDirectionEmulateStick = enable; }
 
 /** Set if true the WASD keys are also routed to the direction keys
- *  @param {Boolean} enable
+ *  @param {boolean} enable
  *  @memberof Settings */
 function setInputWASDEmulateDirection(enable) { inputWASDEmulateDirection = enable; }
 
 /** Set if touch input is allowed
- *  @param {Boolean} enable
+ *  @param {boolean} enable
  *  @memberof Settings */
 function setTouchInputEnable(enable) { touchInputEnable = enable; }
 
 /** Set if touch gamepad should appear on mobile devices
- *  @param {Boolean} enable
+ *  @param {boolean} enable
  *  @memberof Settings */
 function setTouchGamepadEnable(enable) { touchGamepadEnable = enable; }
 
 /** Set if touch gamepad should be analog stick or 8 way dpad
- *  @param {Boolean} analog
+ *  @param {boolean} analog
  *  @memberof Settings */
 function setTouchGamepadAnalog(analog) { touchGamepadAnalog = analog; }
 
 /** Set size of virtual gamepad for touch devices in pixels
- *  @param {Number} size
+ *  @param {number} size
  *  @memberof Settings */
 function setTouchGamepadSize(size) { touchGamepadSize = size; }
 
 /** Set transparency of touch gamepad overlay
- *  @param {Number} alpha
+ *  @param {number} alpha
  *  @memberof Settings */
 function setTouchGamepadAlpha(alpha) { touchGamepadAlpha = alpha; }
 
 /** Set to allow vibration hardware if it exists
- *  @param {Boolean} enable
+ *  @param {boolean} enable
  *  @memberof Settings */
 function setVibrateEnable(enable) { vibrateEnable = enable; }
 
 /** Set to disable all audio code
- *  @param {Boolean} enable
+ *  @param {boolean} enable
  *  @memberof Settings */
 function setSoundEnable(enable) { soundEnable = enable; }
 
 /** Set volume scale to apply to all sound, music and speech
- *  @param {Number} volume
+ *  @param {number} volume
  *  @memberof Settings */
 function setSoundVolume(volume)
 {
@@ -1846,22 +1849,22 @@ function setSoundVolume(volume)
 }
 
 /** Set default range where sound no longer plays
- *  @param {Number} range
+ *  @param {number} range
  *  @memberof Settings */
 function setSoundDefaultRange(range) { soundDefaultRange = range; }
 
 /** Set default range percent to start tapering off sound
- *  @param {Number} taper
+ *  @param {number} taper
  *  @memberof Settings */
 function setSoundDefaultTaper(taper) { soundDefaultTaper = taper; }
 
 /** Set how long to show medals for in seconds
- *  @param {Number} time
+ *  @param {number} time
  *  @memberof Settings */
 function setMedalDisplayTime(time) { medalDisplayTime = time; }
 
 /** Set how quickly to slide on/off medals in seconds
- *  @param {Number} time
+ *  @param {number} time
  *  @memberof Settings */
 function setMedalDisplaySlideTime(time) { medalDisplaySlideTime = time; }
 
@@ -1870,23 +1873,18 @@ function setMedalDisplaySlideTime(time) { medalDisplaySlideTime = time; }
  *  @memberof Settings */
 function setMedalDisplaySize(size) { medalDisplaySize = size; }
 
-/** Set size of icon in medal display
- *  @param {Number} size
- *  @memberof Settings */
-function setMedalDisplayIconSize(size) { medalDisplayIconSize = size; }
-
 /** Set to stop medals from being unlockable
- *  @param {Boolean} preventUnlock
+ *  @param {boolean} preventUnlock
  *  @memberof Settings */
 function setMedalsPreventUnlock(preventUnlock) { medalsPreventUnlock = preventUnlock; }
 
 /** Set if watermark with FPS should be shown
- *  @param {Boolean} show
+ *  @param {boolean} show
  *  @memberof Debug */
 function setShowWatermark(show) { showWatermark = show; }
 
 /** Set key code used to toggle debug mode, Esc by default
- *  @param {String} key
+ *  @param {string} key
  *  @memberof Debug */
 function setDebugKey(key) { debugKey = key; }
 /** 
@@ -1926,9 +1924,9 @@ class EngineObject
      *  @param {Vector2}  [pos=(0,0)]       - World space position of the object
      *  @param {Vector2}  [size=(1,1)]      - World space size of the object
      *  @param {TileInfo} [tileInfo]        - Tile info to render object (undefined is untextured)
-     *  @param {Number}   [angle]           - Angle the object is rotated by
+     *  @param {number}   [angle]           - Angle the object is rotated by
      *  @param {Color}    [color=(1,1,1,1)] - Color to apply to tile when rendered
-     *  @param {Number}   [renderOrder]     - Objects sorted by renderOrder before being rendered
+     *  @param {number}   [renderOrder]     - Objects sorted by renderOrder before being rendered
      */
     constructor(pos=vec2(), size=vec2(1), tileInfo, angle=0, color=new Color, renderOrder=0)
     {
@@ -1944,57 +1942,59 @@ 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 */
         this.color = color;
         /** @property {Color}   - Additive color to apply when rendered */
         this.additiveColor = undefined;
-        /** @property {Boolean} - Should it flip along y axis when rendered */
+        /** @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 */
+        /** @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) */
+        /** @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) */
+        /** @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) */
+        /** @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) */
+        /** @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}  - 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}   - 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 */
+        /** @property {boolean}  - Limit object speed using linear or circular math */
         this.clampSpeedLinear = 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 */
         this.localPos = vec2();
-        /** @property {Number}       - Local angle if child  */
+        /** @property {number}       - Local angle if child  */
         this.localAngle = 0;
 
         // collision flags
-        /** @property {Boolean} - Object collides with the tile collision */
+        /** @property {boolean} - Object collides with the tile collision */
         this.collideTiles = false;
-        /** @property {Boolean} - Object collides with solid objects */
+        /** @property {boolean} - Object collides with solid objects */
         this.collideSolidObjects = false;
-        /** @property {Boolean} - Object collides with and blocks other objects */
+        /** @property {boolean} - Object collides with and blocks other objects */
         this.isSolid = false;
-        /** @property {Boolean} - Object collides with raycasts */
+        /** @property {boolean} - Object collides with raycasts */
         this.collideRaycast = false;
 
         // add to list of objects
@@ -2062,9 +2062,10 @@ class EngineObject
         if (this.groundObject)
         {
             // apply friction in local space of ground object
-            const groundSpeed = this.groundObject.velocity ? this.groundObject.velocity.x : 0;
+            const groundSpeed = this.groundObject != this && this.groundObject.velocity ? 
+                this.groundObject.velocity.x : 0;
             this.velocity.x = groundSpeed + (this.velocity.x - groundSpeed) * this.friction;
-            this.groundObject = 0;
+            this.groundObject = undefined;
             //debugOverlay && debugPhysics && debugPoint(this.pos.subtract(vec2(0,this.size.y/2)), '#0f0');
         }
 
@@ -2181,18 +2182,22 @@ class EngineObject
                         // bounce velocity
                         this.velocity.y *= -this.elasticity;
 
-                        // set if landed on ground
-                        if (this.groundObject = wasMovingDown)
+                        if (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;
+
+                            // set ground object to self for tile collision
+                            // TODO: rework system so tile collision is its own object
+                            this.groundObject = this;
                         }
                         else
                         {
                             // move to previous position
                             this.pos.y = oldPos.y;
+                            this.groundObject = undefined; 
                         }
                     }
                     if (isBlockedX)
@@ -2244,19 +2249,19 @@ class EngineObject
     worldToLocalVector(vec) { return vec.rotate(-this.angle); }
     
     /** Called to check if a tile collision should be resolved
-     *  @param {Number}  tileData - the value of the tile at the position
+     *  @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 */
+     *  @return {boolean}         - true if the collision should be resolved */
     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
+     *  @return {boolean}            - true if the collision should be resolved
      */
     collideWithObject(object)         { return true; }
 
     /** How long since the object was created
-     *  @return {Number} */
+     *  @return {number} */
     getAliveTime()                    { return time - this.spawnTime; }
 
     /** Apply acceleration to this object (adjust velocity, not affected by mass)
@@ -2268,13 +2273,13 @@ class EngineObject
     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 */
+     *  @return {number} -1 if this.mirror is true, or 1 if not mirrored */
     getMirrorSign() { return this.mirror ? -1 : 1; }
 
     /** Attaches a child to this with a given local transform
      *  @param {EngineObject} child
      *  @param {Vector2}      [localPos=(0,0)]
-     *  @param {Number}       [localAngle] */
+     *  @param {number}       [localAngle] */
     addChild(child, localPos=vec2(), localAngle=0)
     {
         ASSERT(!child.parent && !this.children.includes(child));
@@ -2294,10 +2299,10 @@ class EngineObject
     }
 
     /** Set how this object collides
-     *  @param {Boolean} [collideSolidObjects] - Does it collide with solid objects?
-     *  @param {Boolean} [isSolid]             - Does it collide with and block other objects? (expensive in large numbers)
-     *  @param {Boolean} [collideTiles]        - Does it collide with the tile collision?
-     *  @param {Boolean} [collideRaycast]      - Does it collide with raycasts? */
+     *  @param {boolean} [collideSolidObjects] - Does it collide with solid objects?
+     *  @param {boolean} [isSolid]             - Does it collide with and block other objects? (expensive in large numbers)
+     *  @param {boolean} [collideTiles]        - Does it collide with the tile collision?
+     *  @param {boolean} [collideRaycast]      - Does it collide with raycasts? */
     setCollision(collideSolidObjects=true, isSolid=true, collideTiles=true, collideRaycast=true)
     {
         ASSERT(collideSolidObjects || !isSolid, 'solid objects must be set to collide');
@@ -2309,7 +2314,7 @@ class EngineObject
     }
 
     /** Returns string containing info about this object for debugging
-     *  @return {String} */
+     *  @return {string} */
     toString()
     {
         if (debug)
@@ -2407,10 +2412,10 @@ let drawCount;
  * Create a tile info object using a grid based system
  * - This can take vecs or floats for easier use and conversion
  * - If an index is passed in, the tile size and index will determine the position
- * @param {(Number|Vector2)} [pos=0]                - Index of tile in sheet
- * @param {(Number|Vector2)} [size=tileSizeDefault] - Size of tile in pixels
- * @param {Number} [textureIndex]                   - Texture index to use
- * @param {Number} [padding]                        - How many pixels padding around tiles
+ * @param {Vector2|number} [pos=0]                - Index of tile in sheet
+ * @param {Vector2|number} [size=tileSizeDefault] - Size of tile in pixels
+ * @param {number} [textureIndex]                   - Texture index to use
+ * @param {number} [padding]                        - How many pixels padding around tiles
  * @return {TileInfo}
  * @example
  * tile(2)                       // a tile at index 2 using the default tile size of 16
@@ -2454,8 +2459,8 @@ class TileInfo
     /** Create a tile info object
      *  @param {Vector2} [pos=(0,0)]            - Top left corner of tile in pixels
      *  @param {Vector2} [size=tileSizeDefault] - Size of tile in pixels
-     *  @param {Number}  [textureIndex]         - Texture index to use
-     *  @param {Number}  [padding]              - How many pixels padding around tiles
+     *  @param {number}  [textureIndex]         - Texture index to use
+     *  @param {number}  [padding]              - How many pixels padding around tiles
      */
     constructor(pos=vec2(), size=tileSizeDefault, textureIndex=0, padding=0)
     {
@@ -2463,9 +2468,9 @@ class TileInfo
         this.pos = pos.copy();
         /** @property {Vector2} - Size of tile in pixels */
         this.size = size.copy();
-        /** @property {Number} - Texture index to use */
+        /** @property {number} - Texture index to use */
         this.textureIndex = textureIndex;
-        /** @property {Number} - How many pixels padding around tiles */
+        /** @property {number} - How many pixels padding around tiles */
         this.padding = padding;
     }
 
@@ -2477,7 +2482,7 @@ class TileInfo
     { return new TileInfo(this.pos.add(offset), this.size, this.textureIndex); }
 
     /** Returns a copy of this tile offset by a number of animation frames
-    *  @param {Number} frame - Offset to apply in animation frames
+    *  @param {number} frame - Offset to apply in animation frames
     *  @return {TileInfo}
     */
     frame(frame)
@@ -2549,11 +2554,11 @@ function getCameraSize() { return mainCanvasSize.scale(1/cameraScale); }
  *  @param {Vector2} [size=(1,1)]               - Size of the tile in world space
  *  @param {TileInfo}[tileInfo]                 - Tile info to use, untextured if undefined
  *  @param {Color}   [color=(1,1,1,1)]          - Color to modulate with
- *  @param {Number}  [angle]                    - Angle to rotate by
- *  @param {Boolean} [mirror]                   - If true image is flipped along the Y axis
+ *  @param {number}  [angle]                    - Angle to rotate by
+ *  @param {boolean} [mirror]                   - If true image is flipped along the Y axis
  *  @param {Color}   [additiveColor=(0,0,0,0)]  - Additive color to be applied
- *  @param {Boolean} [useWebGL=glEnable]        - Use accelerated WebGL rendering
- *  @param {Boolean} [screenSpace=false]        - If true the pos and size are in screen space
+ *  @param {boolean} [useWebGL=glEnable]        - Use accelerated WebGL rendering
+ *  @param {boolean} [screenSpace=false]        - If true the pos and size are in screen space
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context] - Canvas 2D context to draw to
  *  @memberof Draw */
 function drawTile(pos, size=vec2(1), tileInfo, color=new Color,
@@ -2628,9 +2633,9 @@ function drawTile(pos, size=vec2(1), tileInfo, color=new Color,
  *  @param {Vector2} pos
  *  @param {Vector2} [size=(1,1)]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [angle]
- *  @param {Boolean} [useWebGL=glEnable]
- *  @param {Boolean} [screenSpace=false]
+ *  @param {number}  [angle]
+ *  @param {boolean} [useWebGL=glEnable]
+ *  @param {boolean} [screenSpace=false]
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context]
  *  @memberof Draw */
 function drawRect(pos, size, color, angle, useWebGL, screenSpace, context)
@@ -2641,10 +2646,10 @@ function drawRect(pos, size, color, angle, useWebGL, screenSpace, context)
 /** Draw colored line between two points
  *  @param {Vector2} posA
  *  @param {Vector2} posB
- *  @param {Number}  [thickness]
+ *  @param {number}  [thickness]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Boolean} [useWebGL=glEnable]
- *  @param {Boolean} [screenSpace=false]
+ *  @param {boolean} [useWebGL=glEnable]
+ *  @param {boolean} [screenSpace=false]
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context]
  *  @memberof Draw */
 function drawLine(posA, posB, thickness=.1, color, useWebGL, screenSpace, context)
@@ -2655,11 +2660,11 @@ function drawLine(posA, posB, thickness=.1, color, useWebGL, screenSpace, contex
 }
 
 /** Draw colored polygon using passed in points
- *  @param {Array}   points - Array of Vector2 points
+ *  @param {Array<Vector2>}   points - Array of Vector2 points
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [lineWidth=0]
+ *  @param {number}  [lineWidth=0]
  *  @param {Color}   [lineColor=(0,0,0,1)]
- *  @param {Boolean} [screenSpace=false]
+ *  @param {boolean} [screenSpace=false]
  *  @param {CanvasRenderingContext2D} [context=mainContext]
  *  @memberof Draw */
 function drawPoly(points, color=new Color, lineWidth=0, lineColor=new Color(0,0,0), screenSpace, context=mainContext)
@@ -2681,13 +2686,13 @@ function drawPoly(points, color=new Color, lineWidth=0, lineColor=new Color(0,0,
 
 /** Draw colored ellipse using passed in point
  *  @param {Vector2} pos
- *  @param {Number}  [width=1]
- *  @param {Number}  [height=1]
- *  @param {Number}  [angle=0]
+ *  @param {number}  [width=1]
+ *  @param {number}  [height=1]
+ *  @param {number}  [angle=0]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [lineWidth=0]
+ *  @param {number}  [lineWidth=0]
  *  @param {Color}   [lineColor=(0,0,0,1)]
- *  @param {Boolean} [screenSpace=false]
+ *  @param {boolean} [screenSpace=false]
  *  @param {CanvasRenderingContext2D} [context=mainContext]
  *  @memberof Draw */
 function drawEllipse(pos, width=1, height=1, angle=0, color=new Color, lineWidth=0, lineColor=new Color(0,0,0), screenSpace, context=mainContext)
@@ -2714,11 +2719,11 @@ function drawEllipse(pos, width=1, height=1, angle=0, color=new Color, lineWidth
 
 /** Draw colored circle using passed in point
  *  @param {Vector2} pos
- *  @param {Number}  [radius=1]
+ *  @param {number}  [radius=1]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [lineWidth=0]
+ *  @param {number}  [lineWidth=0]
  *  @param {Color}   [lineColor=(0,0,0,1)]
- *  @param {Boolean} [screenSpace=false]
+ *  @param {boolean} [screenSpace=false]
  *  @param {CanvasRenderingContext2D} [context=mainContext]
  *  @memberof Draw */
 function drawCircle(pos, radius=1, color=new Color, lineWidth=0, lineColor=new Color(0,0,0), screenSpace, context=mainContext)
@@ -2727,10 +2732,10 @@ function drawCircle(pos, radius=1, color=new Color, lineWidth=0, lineColor=new C
 /** Draw directly to a 2d canvas context in world space
  *  @param {Vector2}  pos
  *  @param {Vector2}  size
- *  @param {Number}   angle
- *  @param {Boolean}  mirror
+ *  @param {number}   angle
+ *  @param {boolean}  mirror
  *  @param {Function} drawFunction
- *  @param {Boolean} [screenSpace=false]
+ *  @param {boolean} [screenSpace=false]
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=mainContext]
  *  @memberof Draw */
 function drawCanvas2D(pos, size, angle, mirror, drawFunction, screenSpace, context=mainContext)
@@ -2751,15 +2756,15 @@ function drawCanvas2D(pos, size, angle, mirror, drawFunction, screenSpace, conte
 
 /** Draw text on main canvas in world space
  *  Automatically splits new lines into rows
- *  @param {String}  text
+ *  @param {string}  text
  *  @param {Vector2} pos
- *  @param {Number}  [size]
+ *  @param {number}  [size]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [lineWidth]
+ *  @param {number}  [lineWidth]
  *  @param {Color}   [lineColor=(0,0,0,1)]
  *  @param {CanvasTextAlign}  [textAlign='center']
- *  @param {String}  [font=fontDefault]
- *  @param {Number}  [maxWidth]
+ *  @param {string}  [font=fontDefault]
+ *  @param {number}  [maxWidth]
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=mainContext]
  *  @memberof Draw */
 function drawText(text, pos, size=1, color, lineWidth=0, lineColor, textAlign, font, maxWidth, context=mainContext)
@@ -2769,15 +2774,15 @@ function drawText(text, pos, size=1, color, lineWidth=0, lineColor, textAlign, f
 
 /** Draw text on overlay canvas in world space
  *  Automatically splits new lines into rows
- *  @param {String}  text
+ *  @param {string}  text
  *  @param {Vector2} pos
- *  @param {Number}  [size]
+ *  @param {number}  [size]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [lineWidth]
+ *  @param {number}  [lineWidth]
  *  @param {Color}   [lineColor=(0,0,0,1)]
  *  @param {CanvasTextAlign}  [textAlign='center']
- *  @param {String}  [font=fontDefault]
- *  @param {Number}  [maxWidth]
+ *  @param {string}  [font=fontDefault]
+ *  @param {number}  [maxWidth]
  *  @memberof Draw */
 function drawTextOverlay(text, pos, size=1, color, lineWidth=0, lineColor, textAlign, font, maxWidth)
 {
@@ -2786,15 +2791,15 @@ function drawTextOverlay(text, pos, size=1, color, lineWidth=0, lineColor, textA
 
 /** Draw text on overlay canvas in screen space
  *  Automatically splits new lines into rows
- *  @param {String}  text
+ *  @param {string}  text
  *  @param {Vector2} pos
- *  @param {Number}  [size]
+ *  @param {number}  [size]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [lineWidth]
+ *  @param {number}  [lineWidth]
  *  @param {Color}   [lineColor=(0,0,0,1)]
  *  @param {CanvasTextAlign}  [textAlign]
- *  @param {String}  [font=fontDefault]
- *  @param {Number}  [maxWidth]
+ *  @param {string}  [font=fontDefault]
+ *  @param {number}  [maxWidth]
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=overlayContext]
  *  @memberof Draw */
 function drawTextScreen(text, pos, size=1, color=new Color, lineWidth=0, lineColor=new Color(0,0,0), textAlign='center', font=fontDefault, maxWidth=undefined, context=overlayContext)
@@ -2820,8 +2825,8 @@ function drawTextScreen(text, pos, size=1, color=new Color, lineWidth=0, lineCol
 }
 
 /** Enable normal or additive blend mode
- *  @param {Boolean} [additive]
- *  @param {Boolean} [useWebGL=glEnable]
+ *  @param {boolean} [additive]
+ *  @param {boolean} [useWebGL=glEnable]
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=mainContext]
  *  @memberof Draw */
 function setBlendMode(additive, useWebGL=glEnable, context)
@@ -2888,10 +2893,10 @@ class FontImage
     }
 
     /** Draw text in world space using the image font
-     *  @param {String}  text
+     *  @param {string}  text
      *  @param {Vector2} pos
-     *  @param {Number}  [scale=.25]
-     *  @param {Boolean} [center]
+     *  @param {number}  [scale=.25]
+     *  @param {boolean} [center]
      */
     drawText(text, pos, scale=1, center)
     {
@@ -2899,10 +2904,10 @@ class FontImage
     }
 
     /** Draw text in screen space using the image font
-     *  @param {String}  text
+     *  @param {string}  text
      *  @param {Vector2} pos
-     *  @param {Number}  [scale]
-     *  @param {Boolean} [center]
+     *  @param {number}  [scale]
+     *  @param {boolean} [center]
      */
     drawTextScreen(text, pos, scale=4, center)
     {
@@ -2940,7 +2945,7 @@ class FontImage
 // Display functions
 
 /** Returns true if fullscreen mode is active
- *  @return {Boolean}
+ *  @return {boolean}
  *  @memberof Draw */
 function isFullscreen() { return !!document.fullscreenElement; }
 
@@ -2959,7 +2964,7 @@ function toggleFullscreen()
 }
 
 /** Set the cursor style
- *  @param {String}  cursorStyle - CSS cursor style (auto, none, crosshair, etc)
+ *  @param {string}  cursorStyle - CSS cursor style (auto, none, crosshair, etc)
  *  @memberof Draw */
 function setCursor(cursorStyle = 'auto')
 {
@@ -2979,9 +2984,9 @@ function setCursor(cursorStyle = 'auto')
 
 
 /** Returns true if device key is down
- *  @param {String|Number} key
- *  @param {Number} [device]
- *  @return {Boolean}
+ *  @param {string|number} key
+ *  @param {number} [device]
+ *  @return {boolean}
  *  @memberof Input */
 function keyIsDown(key, device=0)
 { 
@@ -2990,9 +2995,9 @@ function keyIsDown(key, device=0)
 }
 
 /** Returns true if device key was pressed this frame
- *  @param {String|Number} key
- *  @param {Number} [device]
- *  @return {Boolean}
+ *  @param {string|number} key
+ *  @param {number} [device]
+ *  @return {boolean}
  *  @memberof Input */
 function keyWasPressed(key, device=0)
 { 
@@ -3001,9 +3006,9 @@ function keyWasPressed(key, device=0)
 }
 
 /** Returns true if device key was released this frame
- *  @param {String|Number} key
- *  @param {Number} [device]
- *  @return {Boolean}
+ *  @param {string|number} key
+ *  @param {number} [device]
+ *  @return {boolean}
  *  @memberof Input */
 function keyWasReleased(key, device=0)
 { 
@@ -3026,22 +3031,22 @@ function clearInput() { inputData = [[]]; touchGamepadButtons = []; }
 
 /** Returns true if mouse button is down
  *  @function
- *  @param {Number} button
- *  @return {Boolean}
+ *  @param {number} button
+ *  @return {boolean}
  *  @memberof Input */
 const mouseIsDown = keyIsDown;
 
 /** Returns true if mouse button was pressed
  *  @function
- *  @param {Number} button
- *  @return {Boolean}
+ *  @param {number} button
+ *  @return {boolean}
  *  @memberof Input */
 const mouseWasPressed = keyWasPressed;
 
 /** Returns true if mouse button was released
  *  @function
- *  @param {Number} button
- *  @return {Boolean}
+ *  @param {number} button
+ *  @return {boolean}
  *  @memberof Input */
 const mouseWasReleased = keyWasReleased;
 
@@ -3056,47 +3061,53 @@ let mousePos = vec2();
 let mousePosScreen = vec2();
 
 /** Mouse wheel delta this frame
- *  @type {Number}
+ *  @type {number}
  *  @memberof Input */
 let mouseWheel = 0;
 
 /** Returns true if user is using gamepad (has more recently pressed a gamepad button)
- *  @type {Boolean}
+ *  @type {boolean}
  *  @memberof Input */
 let isUsingGamepad = false;
 
-/** Prevents input continuing to the default browser handling (false by default)
- *  @type {Boolean}
+/** Prevents input continuing to the default browser handling (true by default)
+ *  @type {boolean}
+ *  @memberof Input */
+let inputPreventDefault = true;
+
+/** Prevents input continuing to the default browser handling
+ *  This is useful to disable for html menus so the browser can handle input normally
+ *  @param {boolean} preventDefault
  *  @memberof Input */
-let preventDefaultInput = false;
+function setInputPreventDefault(preventDefault) { inputPreventDefault = preventDefault; }
 
 /** Returns true if gamepad button is down
- *  @param {Number} button
- *  @param {Number} [gamepad]
- *  @return {Boolean}
+ *  @param {number} button
+ *  @param {number} [gamepad]
+ *  @return {boolean}
  *  @memberof Input */
 function gamepadIsDown(button, gamepad=0)
 { return keyIsDown(button, gamepad+1); }
 
 /** Returns true if gamepad button was pressed
- *  @param {Number} button
- *  @param {Number} [gamepad]
- *  @return {Boolean}
+ *  @param {number} button
+ *  @param {number} [gamepad]
+ *  @return {boolean}
  *  @memberof Input */
 function gamepadWasPressed(button, gamepad=0)
 { return keyWasPressed(button, gamepad+1); }
 
 /** Returns true if gamepad button was released
- *  @param {Number} button
- *  @param {Number} [gamepad]
- *  @return {Boolean}
+ *  @param {number} button
+ *  @param {number} [gamepad]
+ *  @return {boolean}
  *  @memberof Input */
 function gamepadWasReleased(button, gamepad=0)
 { return keyWasReleased(button, gamepad+1); }
 
 /** Returns gamepad stick value
- *  @param {Number} stick
- *  @param {Number} [gamepad]
+ *  @param {number} stick
+ *  @param {number} [gamepad]
  *  @return {Vector2}
  *  @memberof Input */
 function gamepadStick(stick,  gamepad=0)
@@ -3148,7 +3159,6 @@ function inputInit()
             if (inputWASDEmulateDirection)
                 inputData[0][remapKey(e.code)] = 3;
         }
-        preventDefaultInput && e.preventDefault();
     }
 
     onkeyup = (e)=>
@@ -3178,7 +3188,7 @@ function inputInit()
         isUsingGamepad = false; 
         inputData[0][e.button] = 3; 
         mousePosScreen = mouseEventToScreen(e); 
-        e.button && e.preventDefault();
+        inputPreventDefault && e.button && e.preventDefault();
     }
     onmouseup     = (e)=> inputData[0][e.button] = inputData[0][e.button] & 2 | 4;
     onmousemove   = (e)=> mousePosScreen = mouseEventToScreen(e);
@@ -3299,7 +3309,7 @@ function gamepadsUpdate()
 ///////////////////////////////////////////////////////////////////////////////
 
 /** Pulse the vibration hardware if it exists
- *  @param {Number|Array} [pattern] - single value in ms or vibration interval array
+ *  @param {number|Array} [pattern] - single value in ms or vibration interval array
  *  @memberof Input */
 function vibrate(pattern=100)
 { vibrateEnable && !headlessMode && navigator && navigator.vibrate && navigator.vibrate(pattern); }
@@ -3362,7 +3372,7 @@ function touchInputInit()
         wasTouching = touching;
 
         // prevent default handling like copy and magnifier lens
-        if (document.hasFocus()) // allow document to get focus
+        if (inputPreventDefault && document.hasFocus()) // allow document to get focus
             e.preventDefault();
         
         // must return true so the document will get focus
@@ -3534,20 +3544,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)
@@ -3563,10 +3573,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)
@@ -3601,7 +3611,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)
     {
@@ -3623,22 +3633,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; }
 }
@@ -3656,10 +3666,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)
@@ -3682,9 +3692,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)
@@ -3727,7 +3737,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)
     {
@@ -3740,8 +3750,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)
@@ -3749,11 +3759,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)
@@ -3780,9 +3790,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); }
@@ -3791,11 +3801,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 */
@@ -3854,27 +3864,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
  */
@@ -3980,7 +3990,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) 
@@ -4092,7 +4102,7 @@ function zzfxM(instruments, patterns, sequence, BPM = 125)
 
 
 /** The tile collision layer grid, use setTileCollisionData and getTileCollisionData to access
- *  @type {Array} 
+ *  @type {Array<number>} 
  *  @memberof TileCollision */
 let tileCollision = [];
 
@@ -4114,7 +4124,7 @@ function initTileCollision(size)
 
 /** Set tile collision data for a given cell in the grid
  *  @param {Vector2} pos
- *  @param {Number}  [data]
+ *  @param {number}  [data]
  *  @memberof TileCollision */
 function setTileCollisionData(pos, data=0)
 {
@@ -4123,7 +4133,7 @@ function setTileCollisionData(pos, data=0)
 
 /** Get tile collision data for a given cell in the grid
  *  @param {Vector2} pos
- *  @return {Number}
+ *  @return {number}
  *  @memberof TileCollision */
 function getTileCollisionData(pos)
 {
@@ -4134,7 +4144,7 @@ function getTileCollisionData(pos)
  *  @param {Vector2}      pos
  *  @param {Vector2}      [size=(0,0)]
  *  @param {EngineObject} [object]
- *  @return {Boolean}
+ *  @return {boolean}
  *  @memberof TileCollision */
 function tileCollisionTest(pos, size=vec2(), object)
 {
@@ -4215,17 +4225,17 @@ function tileCollisionRaycast(posStart, posEnd, object)
 class TileLayerData
 {
     /** Create a tile layer data object, one for each tile in a TileLayer
-     *  @param {Number}  [tile]      - The tile to use, untextured if undefined
-     *  @param {Number}  [direction] - Integer direction of tile, in 90 degree increments
-     *  @param {Boolean} [mirror]    - If the tile should be mirrored along the x axis
+     *  @param {number}  [tile]      - The tile to use, untextured if undefined
+     *  @param {number}  [direction] - Integer direction of tile, in 90 degree increments
+     *  @param {boolean} [mirror]    - If the tile should be mirrored along the x axis
      *  @param {Color}   [color]     - Color of the tile */
     constructor(tile, direction=0, mirror=false, color=new Color)
     {
-        /** @property {Number}  - The tile to use, untextured if undefined */
+        /** @property {number}  - The tile to use, untextured if undefined */
         this.tile      = tile;
-        /** @property {Number}  - Integer direction of tile, in 90 degree increments */
+        /** @property {number}  - Integer direction of tile, in 90 degree increments */
         this.direction = direction;
-        /** @property {Boolean} - If the tile should be mirrored along the x axis */
+        /** @property {boolean} - If the tile should be mirrored along the x axis */
         this.mirror    = mirror;
         /** @property {Color}   - Color of the tile */
         this.color     = color;
@@ -4254,7 +4264,7 @@ class TileLayer extends EngineObject
     *  @param {Vector2}  [size=tileCollisionSize] - World space size
     *  @param {TileInfo} [tileInfo]    - Tile info for layer
     *  @param {Vector2}  [scale=(1,1)] - How much to scale this layer when rendered
-    *  @param {Number}   [renderOrder] - Objects are sorted by renderOrder
+    *  @param {number}   [renderOrder] - Objects are sorted by renderOrder
     */
     constructor(position, size=tileCollisionSize, tileInfo=tile(), scale=vec2(1), renderOrder=0)
     {
@@ -4266,7 +4276,7 @@ class TileLayer extends EngineObject
         this.context = this.canvas.getContext('2d');
         /** @property {Vector2} - How much to scale this layer when rendered */
         this.scale = scale;
-        /** @property {Boolean} - If true this layer will render to overlay canvas and appear above all objects */
+        /** @property {boolean} - If true this layer will render to overlay canvas and appear above all objects */
         this.isOverlay = false;
 
         // init tile data
@@ -4289,7 +4299,7 @@ class TileLayer extends EngineObject
     /** Set data at a given position in the array 
      *  @param {Vector2}       layerPos - Local position in array
      *  @param {TileLayerData} data     - Data to set
-     *  @param {Boolean}       [redraw] - Force the tile to redraw if true */
+     *  @param {boolean}       [redraw] - Force the tile to redraw if true */
     setData(layerPos, data, redraw=false)
     {
         if (layerPos.arrayCheck(this.size))
@@ -4342,7 +4352,7 @@ class TileLayer extends EngineObject
 
     /** Call to start the redraw process
      *  - This can be used to manually update small parts of the level
-     *  @param {Boolean} [clear] - Should it clear the canvas before drawing */
+     *  @param {boolean} [clear] - Should it clear the canvas before drawing */
     redrawStart(clear=false)
     {
         // save current render settings
@@ -4386,7 +4396,7 @@ class TileLayer extends EngineObject
      *  This can be used to clear out tiles when they are destroyed
      *  Tiles can also be redrawn if inside a redrawStart/End block
      *  @param {Vector2} layerPos 
-     *  @param {Boolean} [clear] - should the old tile be cleared out
+     *  @param {boolean} [clear] - should the old tile be cleared out
      */
     drawTileData(layerPos, clear=true)
     {
@@ -4404,7 +4414,7 @@ class TileLayer extends EngineObject
         {
             ASSERT(mainContext == this.context, 'must call redrawStart() before drawing tiles');
             const pos = layerPos.add(vec2(.5));
-            const tileInfo = tile(d.tile, s, this.tileInfo.textureIndex);
+            const tileInfo = tile(d.tile, s, this.tileInfo.textureIndex, this.tileInfo.padding);
             drawTile(pos, vec2(1), tileInfo, d.color, d.direction*PI/2, d.mirror);
         }
     }
@@ -4412,8 +4422,8 @@ class TileLayer extends EngineObject
     /** Draw directly to the 2D canvas in world space (bypass webgl)
      *  @param {Vector2}  pos
      *  @param {Vector2}  size
-     *  @param {Number}   angle
-     *  @param {Boolean}  mirror
+     *  @param {number}   angle
+     *  @param {boolean}  mirror
      *  @param {Function} drawFunction */
     drawCanvas2D(pos, size, angle, mirror, drawFunction)
     {
@@ -4433,8 +4443,8 @@ class TileLayer extends EngineObject
      *  @param {Vector2}  [size=(1,1)]
      *  @param {TileInfo} [tileInfo]
      *  @param {Color}    [color=(1,1,1,1)]
-     *  @param {Number}   [angle=0]
-     *  @param {Boolean}  [mirror=0] */
+     *  @param {number}   [angle=0]
+     *  @param {boolean}  [mirror=0] */
     drawTile(pos, size=vec2(1), tileInfo, color=new Color, angle, mirror)
     {
         this.drawCanvas2D(pos, size, angle, mirror, (context)=>
@@ -4461,7 +4471,7 @@ class TileLayer extends EngineObject
      *  @param {Vector2} pos
      *  @param {Vector2} [size=(1,1)]
      *  @param {Color}   [color=(1,1,1,1)]
-     *  @param {Number}  [angle=0] */
+     *  @param {number}  [angle=0] */
     drawRect(pos, size, color, angle) 
     { this.drawTile(pos, size, undefined, color, angle); }
 }
@@ -4513,11 +4523,11 @@ class ParticleEmitter extends EngineObject
      *  @param {Number} [particleConeAngle] - Cone for start particle angle
      *  @param {Number} [fadeRate]          - How quick to fade particles at start/end in percent of life
      *  @param {Number} [randomness]    - Apply extra randomness percent
-     *  @param {Boolean} [collideTiles] - Do particles collide against tiles
-     *  @param {Boolean} [additive]     - Should particles use additive blend
-     *  @param {Boolean} [randomColorLinear] - Should color be randomized linearly or across each component
+     *  @param {boolean} [collideTiles] - Do particles collide against tiles
+     *  @param {boolean} [additive]     - Should particles use additive blend
+     *  @param {boolean} [randomColorLinear] - Should color be randomized linearly or across each component
      *  @param {Number} [renderOrder] - Render order for particles (additive is above other stuff by default)
-     *  @param {Boolean}  [localSpace] - Should it be in local space of emitter (world space is default)
+     *  @param {boolean}  [localSpace] - Should it be in local space of emitter (world space is default)
      */
     constructor
     ( 
@@ -4571,7 +4581,7 @@ class ParticleEmitter extends EngineObject
         this.colorEndA   = colorEndA;
         /** @property {Color} - Color at end of life 2, randomized between end colors */
         this.colorEndB   = colorEndB;
-        /** @property {Boolean} - Should color be randomized linearly or across each component */
+        /** @property {boolean} - Should color be randomized linearly or across each component */
         this.randomColorLinear = randomColorLinear;
 
         // particle settings
@@ -4597,11 +4607,11 @@ class ParticleEmitter extends EngineObject
         this.fadeRate          = fadeRate;
         /** @property {Number} - Apply extra randomness percent */
         this.randomness        = randomness;
-        /** @property {Boolean} - Do particles collide against tiles */
+        /** @property {boolean} - Do particles collide against tiles */
         this.collideTiles      = collideTiles;
-        /** @property {Boolean} - Should particles use additive blend */
+        /** @property {boolean} - Should particles use additive blend */
         this.additive          = additive;
-        /** @property {Boolean} - Should it be in local space of emitter */
+        /** @property {boolean} - Should it be in local space of emitter */
         this.localSpace        = localSpace;
         /** @property {Number} - If non zero the particle is drawn as a trail, stretched in the direction of velocity */
         this.trailScale        = 0;
@@ -4711,7 +4721,7 @@ class Particle extends EngineObject
      * @param {Number}   sizeStart  - Size at start of life
      * @param {Number}   sizeEnd    - Size at end of life
      * @param {Number}   fadeRate   - How quick to fade in/out
-     * @param {Boolean}  additive   - Does it use additive blend mode
+     * @param {boolean}  additive   - Does it use additive blend mode
      * @param {Number}   trailScale - If a trail, how long to make it
      * @param {ParticleEmitter} [localSpaceEmitter] - Parent emitter if local space
      * @param {Function} [destroyCallback] - Callback when particle dies
@@ -4733,7 +4743,7 @@ class Particle extends EngineObject
         this.sizeEndDelta = sizeEnd - sizeStart;
         /** @property {Number} - How quick to fade in/out */
         this.fadeRate = fadeRate;
-        /** @property {Boolean} - Is it additive */
+        /** @property {boolean} - Is it additive */
         this.additive = additive;
         /** @property {Number} - If a trail, how long to make it */
         this.trailScale = trailScale;
@@ -4908,7 +4918,7 @@ class Medal
         /** @property {String} - Icon for the medal */
         this.icon = icon;
         
-        /** @property {Boolean} - Is the medal unlocked? */
+        /** @property {boolean} - Is the medal unlocked? */
         this.unlocked = false;
 
         // load the source image if provided
@@ -4938,8 +4948,9 @@ class Medal
     {
         const context = overlayContext;
         const width = min(medalDisplaySize.x, mainCanvas.width);
+        const height = medalDisplaySize.y;
         const x = overlayCanvas.width - width;
-        const y = -medalDisplaySize.y*hidePercent;
+        const y = -height*hidePercent;
 
         // draw containing rect and clip to that region
         context.save();
@@ -4947,25 +4958,34 @@ class Medal
         context.fillStyle = new Color(.9,.9,.9).toString();
         context.strokeStyle = new Color(0,0,0).toString();
         context.lineWidth = 3;
-        context.rect(x, y, width, medalDisplaySize.y);
+        context.rect(x, y, width, height);
         context.fill();
         context.stroke();
         context.clip();
 
-        // draw the icon and text
-        this.renderIcon(vec2(x+15+medalDisplayIconSize/2, y+medalDisplaySize.y/2));
-        const pos = vec2(x+medalDisplayIconSize+30, y+28);
-        drawTextScreen(this.name, pos, 38, new Color(0,0,0), 0, undefined, 'left');
-        pos.y += 32;
-        drawTextScreen(this.description, pos, 24, new Color(0,0,0), 0, undefined, 'left');
+        // draw the icon
+        const gap = vec2(.1, .05).scale(height);
+        const medalDisplayIconSize = height - 2*gap.x;
+        this.renderIcon(vec2(x + gap.x + medalDisplayIconSize/2, y + height/2), medalDisplayIconSize);
+
+        // draw the name
+        const nameSize = height*.5;
+        const descriptionSize = height*.3;
+        const pos = vec2(x + medalDisplayIconSize + 2*gap.x, y + gap.y*2 + nameSize/2);
+        const textWidth = width - medalDisplayIconSize - 3*gap.x;
+        drawTextScreen(this.name, pos, nameSize, new Color(0,0,0), 0, undefined, 'left', undefined, textWidth);
+
+        // draw the description
+        pos.y = y + height - gap.y*2 - descriptionSize/2;
+        drawTextScreen(this.description, pos, descriptionSize, new Color(0,0,0), 0, undefined, 'left', undefined, textWidth);
         context.restore();
     }
 
     /** Render the icon for a medal
      *  @param {Vector2} pos - Screen space position
-     *  @param {Number} [size=medalDisplayIconSize] - Screen space size
+     *  @param {Number} size - Screen space size
      */
-    renderIcon(pos, size=medalDisplayIconSize)
+    renderIcon(pos, size)
     {
         // draw the image or icon
         if (this.image)
@@ -5002,7 +5022,7 @@ let glCanvas;
 let glContext;
 
 /** Should webgl be setup with anti-aliasing? must be set before calling engineInit
- *  @type {Boolean}
+ *  @type {boolean}
  *  @memberof WebGL */
 let glAntialias = true;
 
@@ -5225,7 +5245,7 @@ function glFlush()
 
 /** Draw any sprites still in the buffer and copy to main canvas
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} context
- *  @param {Boolean} [forceDraw]
+ *  @param {boolean} [forceDraw]
  *  @memberof WebGL */
 function glCopyToContext(context, forceDraw=false)
 {
@@ -5239,7 +5259,7 @@ function glCopyToContext(context, forceDraw=false)
 }
 
 /** Set anti-aliasing for webgl canvas
- *  @param {Boolean} [antialias]
+ *  @param {boolean} [antialias]
  *  @memberof WebGL */
 function glSetAntialias(antialias=true)
 {
@@ -5304,61 +5324,62 @@ function glDraw(x, y, sizeX, sizeY, angle, uv0X, uv0Y, uv1X, uv1Y, rgba, rgbaAdd
 
 
 /** Name of engine
- *  @type {String}
+ *  @type {string}
  *  @default
  *  @memberof Engine */
 const engineName = 'LittleJS';
 
 /** Version of engine
- *  @type {String}
+ *  @type {string}
  *  @default
  *  @memberof Engine */
-const engineVersion = '1.11.9';
+const engineVersion = '1.11.13';
 
 /** Frames per second to update
- *  @type {Number}
+ *  @type {number}
  *  @default
  *  @memberof Engine */
 const frameRate = 60;
 
 /** How many seconds each frame lasts, engine uses a fixed time step
- *  @type {Number}
+ *  @type {number}
  *  @default 1/60
  *  @memberof Engine */
 const timeDelta = 1/frameRate;
 
 /** Array containing all engine objects
- *  @type {Array}
+ *  @type {Array<EngineObject>}
  *  @memberof Engine */
 let engineObjects = [];
 
 /** Array with only objects set to collide with other objects this frame (for optimization)
- *  @type {Array}
+ *  @type {Array<EngineObject>}
  *  @memberof Engine */
 let engineObjectsCollide = [];
 
 /** Current update frame, used to calculate time
- *  @type {Number}
+ *  @type {number}
  *  @memberof Engine */
 let frame = 0;
 
 /** Current engine time since start in seconds
- *  @type {Number}
+ *  @type {number}
  *  @memberof Engine */
 let time = 0;
 
 /** Actual clock time since start in seconds (not affected by pause or frame rate clamping)
- *  @type {Number}
+ *  @type {number}
  *  @memberof Engine */
 let timeReal = 0;
 
 /** Is the game paused? Causes time and objects to not be updated
- *  @type {Boolean}
+ *  @type {boolean}
  *  @default false
  *  @memberof Engine */
 let paused = false;
+
 /** Set if game is paused
- *  @param {Boolean} isPaused
+ *  @param {boolean} isPaused
  *  @memberof Engine */
 function setPaused(isPaused) { paused = isPaused; }
 
@@ -5391,7 +5412,7 @@ function engineAddPlugin(updateFunction, renderFunction)
  *  @param {Function} gameUpdatePost - Called after physics and objects are updated, even when paused
  *  @param {Function} gameRender - Called before objects are rendered, for drawing the background
  *  @param {Function} gameRenderPost - Called after objects are rendered, useful for drawing UI
- *  @param {Array} [imageSources=[]] - List of images to load
+ *  @param {Array<string>} [imageSources=[]] - List of images to load
  *  @param {HTMLElement} [rootElement] - Root element to attach to, the document body by default
  *  @memberof Engine */
 function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, imageSources=[], rootElement=document.body)
@@ -5687,9 +5708,9 @@ function engineObjectsDestroy()
 
 /** Collects all object within a given area
  *  @param {Vector2} [pos]                 - Center of test area, or undefined for all objects
- *  @param {Number|Vector2} [size]         - Radius of circle if float, rectangle size if Vector2
- *  @param {Array} [objects=engineObjects] - List of objects to check
- *  @return {Array}                        - List of collected objects
+ *  @param {Vector2|number} [size]         - Radius of circle if float, rectangle size if Vector2
+ *  @param {Array<EngineObject>} [objects=engineObjects] - List of objects to check
+ *  @return {Array<EngineObject>}                        - List of collected objects
  *  @memberof Engine */
 function engineObjectsCollect(pos, size, objects=engineObjects)
 {
@@ -5715,9 +5736,9 @@ function engineObjectsCollect(pos, size, objects=engineObjects)
 
 /** Triggers a callback for each object within a given area
  *  @param {Vector2} [pos]                 - Center of test area, or undefined for all objects
- *  @param {Number|Vector2} [size]         - Radius of circle if float, rectangle size if Vector2
+ *  @param {Vector2|number} [size]         - Radius of circle if float, rectangle size if Vector2
  *  @param {Function} [callbackFunction]   - Calls this function on every object that passes the test
- *  @param {Array} [objects=engineObjects] - List of objects to check
+ *  @param {Array<EngineObject>} [objects=engineObjects] - List of objects to check
  *  @memberof Engine */
 function engineObjectsCallback(pos, size, callbackFunction, objects=engineObjects)
 { engineObjectsCollect(pos, size, objects).forEach(o => callbackFunction(o)); }
@@ -5725,8 +5746,8 @@ function engineObjectsCallback(pos, size, callbackFunction, objects=engineObject
 /** Return a list of objects intersecting a ray
  *  @param {Vector2} start
  *  @param {Vector2} end
- *  @param {Array} [objects=engineObjects] - List of objects to check
- *  @return {Array} - List of objects hit
+ *  @param {Array<EngineObject>} [objects=engineObjects] - List of objects to check
+ *  @return {Array<EngineObject>} - List of objects hit
  *  @memberof Engine */
 function engineObjectsRaycast(start, end, objects=engineObjects)
 {
@@ -5917,8 +5938,8 @@ function drawEngineSplashScreen(t)
  * - Export engine as a module
  */
 
-export {
-
+export
+{
 	// Engine
 	engineName,
 	engineVersion,
@@ -5996,7 +6017,6 @@ export {
 	medalDisplayTime,
 	medalDisplaySlideTime,
 	medalDisplaySize,
-	medalDisplayIconSize,
 
 	// Setters for globals
 	setCameraPos,
@@ -6037,7 +6057,6 @@ export {
 	setMedalDisplayTime,
 	setMedalDisplaySlideTime,
 	setMedalDisplaySize,
-	setMedalDisplayIconSize,
 	setMedalsPreventUnlock,
 	setShowWatermark,
 	setDebugKey,