littlejsengine 1.11.17 → 1.12.6

package/dist/littlejs.esm.js

@@ -13,8 +13,6 @@
  * @namespace Debug
  */
 
-
-
 /** True if debug is enabled
  *  @type {boolean}
  *  @default
@@ -334,11 +332,9 @@ function debugRender()
             }
         }
 
-        if (tileCollisionSize.x > 0 && tileCollisionSize.y > 0)
+        if (tileCollisionLayers.length) // show floored tile pick if there is tile collision
             drawRect(mousePos.floor().add(vec2(.5)), vec2(1), rgb(0,0,1,.5), 0, false);
         mainContext = saveContext;
-
-        //glCopyToContext(mainContext = saveContext);
     }
 
     {
@@ -581,8 +577,6 @@ function debugVideoCaptureUpdate()
  * @namespace Utilities
  */
 
-
-
 /** A shortcut to get Math.PI
  *  @type {number}
  *  @default Math.PI
@@ -762,6 +756,16 @@ function wave(frequency=1, amplitude=1, t=time)
  *  @memberof Utilities */
 function formatTime(t) { return (t/60|0) + ':' + (t%60<10?'0':'') + (t%60|0); }
 
+/** Fetches a JSON file from a URL and returns the parsed JSON object. Must be used with await!
+ *  @param {string} url - URL of JSON file
+ *  @return {Promise<object>}
+ *  @memberof Utilities */
+async function fetchJSON(url)
+{
+    const response = await fetch(url);
+    return response.json();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 /** Random global functions
@@ -857,6 +861,12 @@ class RandomGenerator
     /** Randomly returns either -1 or 1 deterministically
     *  @return {number} */
     sign() { return this.float() > .5 ? 1 : -1; }
+
+    /** Returns a seeded random value between the two values passed in with a random sign
+    *  @param {number} [valueA]
+    *  @param {number} [valueB]
+    *  @return {number} */
+    floatSign(valueA=1, valueB=0) { return this.float(valueA, valueB) * this.sign(); }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1497,8 +1507,6 @@ class Timer
  * @namespace Settings
  */
 
-
-
 ///////////////////////////////////////////////////////////////////////////////
 // Camera settings
 
@@ -1530,7 +1538,7 @@ let canvasMaxSize = vec2(1920, 1080);
  *  @memberof Settings */
 let canvasFixedSize = vec2();
 
-/** Use nearest neighbor scaling algorithm for canvas for more pixelated look
+/** Use nearest neighbor canvas scaling for more pixelated look
  *  - Must be set before startup to take effect
  *  - If enabled sets css image-rendering:pixelated
  *  @type {boolean}
@@ -1640,11 +1648,11 @@ let objectDefaultFriction = .8;
  *  @memberof Settings */
 let objectMaxSpeed = 1;
 
-/** How much gravity to apply to objects along the Y axis, negative is down
- *  @type {number}
+/** How much gravity to apply to objects, negative Y is down
+ *  @type {Vector2}
  *  @default
  *  @memberof Settings */
-let gravity = 0;
+let gravity = vec2();
 
 /** Scales emit rate of particles, useful for low graphics mode (0 disables particle emitters)
  *  @type {number}
@@ -1870,8 +1878,8 @@ function setObjectDefaultFriction(friction) { objectDefaultFriction = friction;
  *  @memberof Settings */
 function setObjectMaxSpeed(speed) { objectMaxSpeed = speed; }
 
-/** Set how much gravity to apply to objects along the Y axis
- *  @param {number} newGravity
+/** Set how much gravity to apply to objects
+ *  @param {Vector2} newGravity
  *  @memberof Settings */
 function setGravity(newGravity) { gravity = newGravity; }
 
@@ -1983,8 +1991,6 @@ function setDebugKey(key) { debugKey = key; }
  * LittleJS Object System
  */
 
-
-
 /** 
  * LittleJS Object Base Object Class
  * - Top level object class used by the engine
@@ -2139,7 +2145,10 @@ class EngineObject
         this.velocity.x *= this.damping;
         this.velocity.y *= this.damping;
         if (this.mass) // don't apply gravity to static objects
-            this.velocity.y += gravity * this.gravityScale;
+        {
+            this.velocity.x += gravity.x * this.gravityScale;
+            this.velocity.y += gravity.y * this.gravityScale;
+        }
         this.pos.x += this.velocity.x;
         this.pos.y += this.velocity.y;
         this.angle += this.angleVelocity *= this.angleDamping;
@@ -2154,9 +2163,9 @@ class EngineObject
         if (this.groundObject)
         {
             // apply friction in local space of ground object
-            const groundSpeed = this.groundObject != this && this.groundObject.velocity ? 
-                this.groundObject.velocity.x : 0;
-            this.velocity.x = groundSpeed + (this.velocity.x - groundSpeed) * this.friction;
+            const friction = max(this.friction, this.groundObject.friction);
+            const groundSpeed = this.groundObject.velocity ? this.groundObject.velocity.x : 0;
+            this.velocity.x = groundSpeed + (this.velocity.x - groundSpeed) * friction;
             this.groundObject = undefined;
             //debugOverlay && debugPhysics && debugPoint(this.pos.subtract(vec2(0,this.size.y/2)), '#0f0');
         }
@@ -2198,7 +2207,7 @@ class EngineObject
 
                 // check for collision
                 const sizeBoth = this.size.add(o.size);
-                const smallStepUp = (oldPos.y - o.pos.y)*2 > sizeBoth.y + gravity; // prefer to push up if small delta
+                const smallStepUp = (oldPos.y - o.pos.y)*2 > sizeBoth.y + gravity.y; // prefer to push up if small delta
                 const isBlockedX = abs(oldPos.y - o.pos.y)*2 < sizeBoth.y;
                 const isBlockedY = abs(oldPos.x - o.pos.x)*2 < sizeBoth.x;
                 const elasticity = max(this.elasticity, o.elasticity);
@@ -2260,19 +2269,21 @@ class EngineObject
         if (this.collideTiles)
         {
             // check collision against tiles
-            if (tileCollisionTest(this.pos, this.size, this))
+            const hitLayer = tileCollisionTest(this.pos, this.size, this)
+            if (hitLayer)
             {
                 // if already was stuck in collision, don't do anything
                 // this should not happen unless something starts in collision
                 if (!tileCollisionTest(oldPos, this.size, this))
                 {
                     // test which side we bounced off (or both if a corner)
-                    const isBlockedY = tileCollisionTest(vec2(oldPos.x, this.pos.y), this.size, this);
-                    const isBlockedX = tileCollisionTest(vec2(this.pos.x, oldPos.y), this.size, this);
-                    if (isBlockedY || !isBlockedX)
+                    const blockedLayerY = tileCollisionTest(vec2(oldPos.x, this.pos.y), this.size, this);
+                    const blockedLayerX = tileCollisionTest(vec2(this.pos.x, oldPos.y), this.size, this);
+                    if (blockedLayerY || !blockedLayerX)
                     {
                         // bounce velocity
-                        this.velocity.y *= -this.elasticity;
+                        const elasticity = max(this.elasticity, hitLayer.elasticity);
+                        this.velocity.y *= -elasticity;
 
                         if (wasMovingDown)
                         {
@@ -2281,9 +2292,8 @@ class EngineObject
                             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;
+                            // set ground object for tile collision
+                            this.groundObject = hitLayer;
                         }
                         else
                         {
@@ -2292,7 +2302,7 @@ class EngineObject
                             this.groundObject = undefined; 
                         }
                     }
-                    if (isBlockedX)
+                    if (blockedLayerX)
                     {
                         // move to previous position and bounce
                         this.pos.x = oldPos.x;
@@ -2463,8 +2473,6 @@ class EngineObject
  * @namespace Draw
  */
 
-
-
 /** The primary 2D canvas visible to the user
  *  @type {HTMLCanvasElement}
  *  @memberof Draw */
@@ -3086,8 +3094,6 @@ function setCursor(cursorStyle = 'auto')
  * @namespace Input
  */
 
-
-
 /** Returns true if device key is down
  *  @param {string|number} key
  *  @param {number} [device]
@@ -3139,21 +3145,21 @@ function clearInput() { inputData = [[]]; touchGamepadButtons = []; }
  *  @param {number} button
  *  @return {boolean}
  *  @memberof Input */
-const mouseIsDown = keyIsDown;
+function mouseIsDown(button) { return keyIsDown(button); }
 
 /** Returns true if mouse button was pressed
  *  @function
  *  @param {number} button
  *  @return {boolean}
  *  @memberof Input */
-const mouseWasPressed = keyWasPressed;
+function mouseWasPressed(button) { return keyWasPressed(button); }
 
 /** Returns true if mouse button was released
  *  @function
  *  @param {number} button
  *  @return {boolean}
  *  @memberof Input */
-const mouseWasReleased = keyWasReleased;
+function mouseWasReleased(button) { return keyWasReleased(button); }
 
 /** Mouse pos in world space
  *  @type {Vector2}
@@ -3392,7 +3398,9 @@ function gamepadsUpdate()
                 const button = gamepad.buttons[j];
                 const wasDown = gamepadIsDown(j,i);
                 data[j] = button.pressed ? wasDown ? 1 : 3 : wasDown ? 4 : 0;
-                isUsingGamepad ||= !i && button.pressed;
+                if (!button.value || button.value > .9) // must be a full press
+                if (!i && button.pressed)
+                    isUsingGamepad = true;
             }
 
             if (gamepadDirectionEmulateStick)
@@ -3610,8 +3618,6 @@ function touchGamepadRender()
  * @namespace Audio
  */
 
-
-
 /** Audio context used by the engine
  *  @type {AudioContext}
  *  @memberof Audio */
@@ -3648,17 +3654,17 @@ 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} [range=soundDefaultRange] - World space max range of sound
      *  @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 */
         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 */
         this.taper = taper;
 
         /** @property {number} - How much to randomize frequency each time sound plays */
@@ -3774,8 +3780,8 @@ 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 {number} [range=soundDefaultRange] - World space max range of sound
+     *  @param {number} [taper=soundDefaultTaper] - At what percentage of range should it start tapering
      *  @param {Function} [onloadCallback] - callback function to call when sound is loaded
      */
     constructor(filename, randomness=0, range, taper, onloadCallback)
@@ -3783,17 +3789,26 @@ class SoundWave extends Sound
         super(undefined, range, taper);
         if (!soundEnable || headlessMode) return;
 
+        /** @property {Function} - callback function to call when sound is loaded */
+        this.onloadCallback = onloadCallback;
         this.randomness = randomness;
-        fetch(filename)
-        .then(response => response.arrayBuffer())
-        .then(arrayBuffer => audioContext.decodeAudioData(arrayBuffer))
-        .then(audioBuffer => 
-        {
-            this.sampleChannels = [];
-            for (let i = audioBuffer.numberOfChannels; i--;)
-                this.sampleChannels[i] = Array.from(audioBuffer.getChannelData(i));
-            this.sampleRate = audioBuffer.sampleRate;
-        }).then(() => onloadCallback && onloadCallback(this));
+        this.loadSound(filename);
+    }
+
+    /** Loads a sound from a URL and decodes it into sample data. Must be used with await!
+    *  @param {string} filename
+    *  @return {Promise<void>} */
+    async loadSound(filename)
+    {
+        const response = await fetch(filename);
+        const arrayBuffer = await response.arrayBuffer();
+        const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+        this.sampleChannels = [];
+        for (let i = audioBuffer.numberOfChannels; i--;)
+            this.sampleChannels[i] = Array.from(audioBuffer.getChannelData(i));
+        this.sampleRate = audioBuffer.sampleRate;
+        if (this.onloadCallback)
+            this.onloadCallback();
     }
 }
 
@@ -4067,75 +4082,45 @@ function zzfxG
  * LittleJS Tile Layer System
  * - Caches arrays of tiles to off screen canvas for fast rendering
  * - Unlimited numbers of layers, allocates canvases as needed
- * - Interfaces with EngineObject for collision
- * - Collision layer is separate from visible layers
- * - It is recommended to have a visible layer that matches the collision
  * - Tile layers can be drawn to using their context with canvas2d
  * - Drawn directly to the main canvas without using WebGL
+ * - Tile layers can also have collision with EngineObjects
  * @namespace TileCollision
  */
 
+///////////////////////////////////////////////////////////////////////////////
+// Tile Layer System
 
-
-/** The tile collision layer grid, use setTileCollisionData and getTileCollisionData to access
- *  @type {Array<number>} 
- *  @memberof TileCollision */
-let tileCollision = [];
-
-/** Size of the tile collision layer 2d grid
- *  @type {Vector2} 
- *  @memberof TileCollision */
-let tileCollisionSize = vec2();
-
-/** Clear and initialize tile collision
- *  @param {Vector2} size - width and height of tile collision 2d grid
- *  @memberof TileCollision */
-function initTileCollision(size)
-{
-    tileCollisionSize = size;
-    tileCollision = [];
-    for (let i=tileCollision.length = tileCollisionSize.area(); i--;)
-        tileCollision[i] = 0;
-}
-
-/** Set tile collision data for a given cell in the grid
- *  @param {Vector2} pos
- *  @param {number}  [data]
+/** Keep track of all tile layers with collision
+ *  @type {Array<TileCollisionLayer>} 
  *  @memberof TileCollision */
-function setTileCollisionData(pos, data=0)
-{
-    pos.arrayCheck(tileCollisionSize) && (tileCollision[(pos.y|0)*tileCollisionSize.x+pos.x|0] = data);
-}
+let tileCollisionLayers = [];
 
 /** Get tile collision data for a given cell in the grid
- *  @param {Vector2} pos
- *  @return {number}
- *  @memberof TileCollision */
+*  @param {Vector2} pos
+*  @return {number}
+*  @memberof TileCollision */
 function getTileCollisionData(pos)
 {
-    return pos.arrayCheck(tileCollisionSize) ? tileCollision[(pos.y|0)*tileCollisionSize.x+pos.x|0] : 0;
+    // check all tile collision layers
+    for (const layer of tileCollisionLayers)
+        if (pos.arrayCheck(layer.size))
+            return layer.getCollisionData(pos);
+    return 0;
 }
 
-/** Check if collision with another object should occur
+/** Check if a tile layer collides with another object
  *  @param {Vector2}      pos
  *  @param {Vector2}      [size=(0,0)]
  *  @param {EngineObject} [object]
- *  @return {boolean}
+ *  @return {TileCollisionLayer}
  *  @memberof TileCollision */
 function tileCollisionTest(pos, size=vec2(), object)
 {
-    const minX = max(pos.x - size.x/2|0, 0);
-    const minY = max(pos.y - size.y/2|0, 0);
-    const maxX = min(pos.x + size.x/2, tileCollisionSize.x);
-    const maxY = min(pos.y + size.y/2, tileCollisionSize.y);
-    for (let y = minY; y < maxY; ++y)
-    for (let x = minX; x < maxX; ++x)
-    {
-        const tileData = tileCollision[y*tileCollisionSize.x+x];
-        if (tileData && (!object || object.collideWithTile(tileData, vec2(x, y))))
-            return true;
-    }
-    return false;
+    // check all tile collision layers
+    for (const layer of tileCollisionLayers)
+        if (layer.collisionTest(pos, size, object))
+            return layer;
 }
 
 /** Return the center of first tile hit, undefined if nothing was hit.
@@ -4147,49 +4132,17 @@ function tileCollisionTest(pos, size=vec2(), object)
  *  @memberof TileCollision */
 function tileCollisionRaycast(posStart, posEnd, object)
 {
-    // test if a ray collides with tiles from start to end
-    // todo: a way to get the exact hit point, it must still be inside the hit tile
-    const delta = posEnd.subtract(posStart);
-    const totalLength = delta.length();
-    const normalizedDelta = delta.normalize();
-    const unit = vec2(abs(1/normalizedDelta.x), abs(1/normalizedDelta.y));
-    const flooredPosStart = posStart.floor();
-
-    // setup iteration variables
-    let pos = flooredPosStart;
-    let xi = unit.x * (delta.x < 0 ? posStart.x - pos.x : pos.x - posStart.x + 1);
-    let yi = unit.y * (delta.y < 0 ? posStart.y - pos.y : pos.y - posStart.y + 1);
-
-    while (true)
-    {
-        // check for tile collision
-        const tileData = getTileCollisionData(pos);
-        if (tileData && (!object || object.collideWithTile(tileData, pos)))
-        {
-            debugRaycast && debugLine(posStart, posEnd, '#f00', .02);
-            debugRaycast && debugPoint(pos.add(vec2(.5)), '#ff0');
-            return pos.add(vec2(.5));
-        }
-
-        // check if past the end
-        if (xi > totalLength && yi > totalLength)
-            break;
-
-        // get coordinates of the next tile to check
-        if (xi > yi)
-            pos.y += sign(delta.y), yi += unit.y;
-        else
-            pos.x += sign(delta.x), xi += unit.x;
+    // check all tile collision layers
+    for (const layer of tileCollisionLayers)
+    {
+        const hitPos = layer.collisionRaycast(posStart, posEnd, object)
+        if (hitPos)
+            return hitPos;
     }
-
-    debugRaycast && debugLine(posStart, posEnd, '#00f', .02);
 }
 
-///////////////////////////////////////////////////////////////////////////////
-// Tile Layer Rendering System
-
 /**
- * Tile layer data object stores info about how to render a tile
+ * Tile layer data object stores info about how to draw a tile
  * @example
  * // create tile layer data with tile index 0 and random orientation and color
  * const tileIndex = 0;
@@ -4221,28 +4174,27 @@ class TileLayerData
     clear() { this.tile = this.direction = 0; this.mirror = false; this.color = new Color; }
 }
 
+///////////////////////////////////////////////////////////////////////////////
 /**
  * Tile Layer - cached rendering system for tile layers
  * - Each Tile layer is rendered to an off screen canvas
  * - To allow dynamic modifications, layers are rendered using canvas 2d
  * - Some devices like mobile phones are limited to 4k texture resolution
- * - So with 16x16 tiles this limits layers to 256x256 on mobile devices
+ * - For with 16x16 tiles this limits layers to 256x256 on mobile devices
  * @extends EngineObject
  * @example
- * // create tile collision and visible tile layer
- * initTileCollision(vec2(200,100));
- * const tileLayer = new TileLayer();
+ * const tileLayer = new TileLayer(vec2(), vec2(200,100));
  */
 class TileLayer extends EngineObject
 {
     /** Create a tile layer object
-    *  @param {Vector2}  [position=(0,0)]     - World space position
-    *  @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 {Vector2}  [position=(0,0)] - World space position
+    *  @param {Vector2}  [size=(1,1)]     - 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
     */
-    constructor(position, size=tileCollisionSize, tileInfo=tile(), scale=vec2(1), renderOrder=0)
+    constructor(position, size, tileInfo=tile(), scale=vec2(1), renderOrder=0)
     {
         super(position, size, tileInfo, 0, undefined, renderOrder);
 
@@ -4254,6 +4206,10 @@ class TileLayer extends EngineObject
         this.scale = scale;
         /** @property {boolean} - If true this layer will render to overlay canvas and appear above all objects */
         this.isOverlay = false;
+        // set no friction by default, applied friction is max of both objects
+        this.friction = 0;
+        // set no elasticity by default, applied elasticity is max of both objects
+        this.elasticity = 0;
 
         // init tile data
         this.data = [];
@@ -4450,13 +4406,151 @@ class TileLayer extends EngineObject
      *  @param {number}  [angle=0] */
     drawRect(pos, size, color, angle) 
     { this.drawTile(pos, size, undefined, color, angle); }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * Tile Collision Layer - a tile layer with collision
+ * - adds collision data and functions to TileLayer
+ * - there can be multiple tile collision layers
+ * - tile collison layers should not overlap each other
+ * @extends TileLayer
+ */
+class TileCollisionLayer extends TileLayer
+{
+    /** Create a tile layer object
+    *  @param {Vector2}  [position=(0,0)] - World space position
+    *  @param {Vector2}  [size=(0,0)]     - World space size
+    *  @param {TileInfo} [tileInfo]       - Tile info for layer
+    *  @param {number}   [renderOrder]    - Objects are sorted by renderOrder
+    */
+    constructor(position, size, tileInfo=tile(), renderOrder=0)
+    {
+        const scale = vec2(1); // collision layers are not scaled
+        super(position, size.floor(), tileInfo, scale, renderOrder);
+
+        /** @property {Array<number>} - The tile collision grid */
+        this.collisionData = [];
+        this.initCollision(this.size);
+
+        // keep track of all collision layers
+        tileCollisionLayers.push(this);
+    }
+
+    /** Destroy this collision layer */
+    destroy()
+    { 
+        if (this.destroyed)
+            return;
+
+        // remove from collision layers array and destroy
+        const index = tileCollisionLayers.indexOf(this);
+        ASSERT(index >= 0, 'tile collision layer not found in array');
+        tileCollisionLayers.splice(index, 1);
+        super.destroy();
+    }
+
+    /** Clear and initialize tile collision to new size
+    *  @param {Vector2} size - width and height of tile collision 2d grid */
+    initCollision(size)
+    {
+        this.size = size.floor();
+        this.collisionData = [];
+        this.collisionData.length = size.area();
+        this.collisionData.fill(0);
+    }
+
+    /** Set tile collision data for a given cell in the grid
+    *  @param {Vector2} pos
+    *  @param {number}  [data] */
+    setCollisionData(pos, data=1)
+    {
+        const i = (pos.y|0)*this.size.x + pos.x|0;
+        pos.arrayCheck(this.size) && (this.collisionData[i] = data);
+    }
+
+    /** Get tile collision data for a given cell in the grid
+    *  @param {Vector2} pos
+    *  @return {number} */
+    getCollisionData(pos)
+    {
+        const i = (pos.y|0)*this.size.x + pos.x|0;
+        return pos.arrayCheck(this.size) ? this.collisionData[i] : 0;
+    }
+
+    /** Check if collision with another object should occur
+    *  @param {Vector2}      pos
+    *  @param {Vector2}      [size=(0,0)]
+    *  @param {EngineObject} [object]
+    *  @return {boolean} */
+    collisionTest(pos, size=vec2(), object)
+    {
+        const minX = max(pos.x - size.x/2|0, 0);
+        const minY = max(pos.y - size.y/2|0, 0);
+        const maxX = min(pos.x + size.x/2, this.size.x);
+        const maxY = min(pos.y + size.y/2, this.size.y);
+        for (let y = minY; y < maxY; ++y)
+        for (let x = minX; x < maxX; ++x)
+        {
+            // check if the object should collide with this tile
+            const tileData = this.collisionData[y*this.size.x+x];
+            if (tileData && (!object || object.collideWithTile(tileData, vec2(x, y))))
+                return true;
+        }
+        return false;
+    }
+
+    /** Return the center of first tile hit, undefined if nothing was hit.
+    *  This does not return the exact intersection, but the center of the tile hit.
+    *  @param {Vector2}      posStart
+    *  @param {Vector2}      posEnd
+    *  @param {EngineObject} [object]
+    *  @return {Vector2} */
+    collisionRaycast(posStart, posEnd, object)
+    {
+        // test if a ray collides with tiles from start to end
+        // todo: a way to get the exact hit point, it must still be inside the hit tile
+        const delta = posEnd.subtract(posStart);
+        const totalLength = delta.length();
+        const normalizedDelta = delta.normalize();
+        const unit = vec2(abs(1/normalizedDelta.x), abs(1/normalizedDelta.y));
+        const flooredPosStart = posStart.floor();
+
+        // setup iteration variables
+        let pos = flooredPosStart;
+        let xi = unit.x * (delta.x < 0 ? posStart.x - pos.x : pos.x - posStart.x + 1);
+        let yi = unit.y * (delta.y < 0 ? posStart.y - pos.y : pos.y - posStart.y + 1);
+
+        // use line drawing algorithm to test for collisions
+        while (true)
+        {
+            // check for tile collision
+            const tileData = this.getCollisionData(pos);
+            if (tileData && (!object || object.collideWithTile(tileData, pos)))
+            {
+                debugRaycast && debugLine(posStart, posEnd, '#f00', .02);
+                debugRaycast && debugPoint(pos.add(vec2(.5)), '#ff0');
+                return pos.add(vec2(.5));
+            }
+
+            // check if past the end
+            if (xi > totalLength && yi > totalLength)
+                break;
+
+            // get coordinates of next tile to check
+            if (xi > yi)
+                pos.y += sign(delta.y), yi += unit.y;
+            else
+                pos.x += sign(delta.x), xi += unit.x;
+        }
+
+        debugRaycast && debugLine(posStart, posEnd, '#00f', .02);
+    }
 }
 /** 
  * LittleJS Particle System
  */
 
-
-
 /**
  * Particle Emitter - Spawns particles with the given settings
  * @extends EngineObject
@@ -4801,8 +4895,6 @@ class Particle extends EngineObject
  * @namespace Medals
  */
 
-
-
 /** List of all medals
  *  @type {Object}
  *  @memberof Medals */
@@ -4990,8 +5082,6 @@ class Medal
  * @namespace WebGL
  */
 
-
-
 /** The WebGL canvas which appears above the main canvas and below the overlay canvas
  *  @type {HTMLCanvasElement}
  *  @memberof WebGL */
@@ -5190,7 +5280,19 @@ function glCreateTexture(image)
     const texture = glContext.createTexture();
     glContext.bindTexture(glContext.TEXTURE_2D, texture);
     if (image && image.width)
+    {
         glSetTextureData(texture, image);
+        
+        const isPowerOfTwo = (value)=> !(value & (value - 1));
+        if (!tilesPixelated && isPowerOfTwo(image.width) && isPowerOfTwo(image.height))
+        {
+            // use mipmap filtering
+            glContext.generateMipmap(glContext.TEXTURE_2D);
+            glContext.texParameteri(glContext.TEXTURE_2D, glContext.TEXTURE_MIN_FILTER, glContext.LINEAR_MIPMAP_LINEAR);
+            glContext.texParameteri(glContext.TEXTURE_2D, glContext.TEXTURE_MAG_FILTER, glContext.LINEAR);
+            return texture;
+        }
+    }
     else
     {
         // create a white texture
@@ -5198,7 +5300,7 @@ function glCreateTexture(image)
         glContext.texImage2D(glContext.TEXTURE_2D, 0, glContext.RGBA, 1, 1, 0, glContext.RGBA, glContext.UNSIGNED_BYTE, whitePixel);
     }
     
-    // use point filtering for pixelated rendering
+    // set texture filtering
     const filter = tilesPixelated ? glContext.NEAREST : glContext.LINEAR;
     glContext.texParameteri(glContext.TEXTURE_2D, glContext.TEXTURE_MIN_FILTER, filter);
     glContext.texParameteri(glContext.TEXTURE_2D, glContext.TEXTURE_MAG_FILTER, filter);
@@ -5314,8 +5416,6 @@ function glDraw(x, y, sizeX, sizeY, angle, uv0X, uv0Y, uv1X, uv1Y, rgba=-1, rgba
  * @namespace Engine
  */
 
-
-
 /** Name of engine
  *  @type {string}
  *  @default
@@ -5326,7 +5426,7 @@ const engineName = 'LittleJS';
  *  @type {string}
  *  @default
  *  @memberof Engine */
-const engineVersion = '1.11.17';
+const engineVersion = '1.12.6';
 
 /** Frames per second to update
  *  @type {number}
@@ -5408,7 +5508,7 @@ function engineAddPlugin(updateFunction, renderFunction)
  *  @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)
+async function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, imageSources=[], rootElement=document.body)
 {
     ASSERT(!mainContext, 'engine already initialized');
     ASSERT(Array.isArray(imageSources), 'pass in images as array');
@@ -5565,16 +5665,14 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
         mainCanvasSize = vec2(mainCanvas.width, mainCanvas.height);
     }
 
-    function startEngine()
+    // wait for gameInit to load
+    async function startEngine()
     {
-        new Promise((resolve) => resolve(gameInit())).then(engineUpdate);
+        await gameInit();
+        engineUpdate();
     }
-
     if (headlessMode)
-    {
-        startEngine();
-        return;
-    }
+        return startEngine();
 
     // setup html
     const styleRoot = 
@@ -5650,8 +5748,9 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
         }));
     }
 
-    // load all of the images
-    Promise.all(promises).then(startEngine);
+    // wait for all the promises to finish
+    await Promise.all(promises);
+    return startEngine();
 }
 
 /** Update each engine object, remove destroyed objects, and update time
@@ -5920,459 +6019,154 @@ function drawEngineSplashScreen(t)
     x.restore();
 }
 
-
+/** 
+ * LittleJS Newgrounds API
+ * - NewgroundsMedal extends Medal with Newgrounds API functionality
+ * - Call new NewgroundsPlugin() to setup Newgrounds
+ * - Uses CryptoJS for encryption if optional cipher is provided
+ * - Keeps connection alive and logs views
+ * - Functions to interact with scoreboards
+ * - Functions to unlock medals
+ */
+
+/** Global Newgrounds object
+ *  @type {NewgroundsPlugin}
+ *  @memberof Medal */
+let newgrounds;
+
+///////////////////////////////////////////////////////////////////////////////
 /**
- * LittleJS Module Export
+ * Newgrounds medal auto unlocks in newgrounds API
+ * @extends Medal
  */
+class NewgroundsMedal extends Medal
+{
+    /** Create a newgrounds medal object and adds it to the list of medals
+     *  @param {Number} id            - The unique identifier of the medal
+     *  @param {String} name          - Name of the medal
+     *  @param {String} [description] - Description of the medal
+     *  @param {String} [icon]        - Icon for the medal
+     *  @param {String} [src]         - Image location for the medal
+     */
+    constructor(id, name, description, icon, src)
+    { super(id, name, description, icon, src); }
 
-'use strict';
+    /** Unlocks a medal if not already unlocked */
+    unlock()
+    {
+        super.unlock();
+        newgrounds && newgrounds.unlockMedal(this.id);
+    }
+}
 
-export
+///////////////////////////////////////////////////////////////////////////////
+/** 
+ * Newgrounds API object
+ */
+class NewgroundsPlugin
 {
-	// Engine
-	engineName,
-	engineVersion,
-	frameRate,
-	timeDelta,
-	engineObjects,
-	frame,
-	time,
-	timeReal,
-	paused,
-	setPaused,
-	engineInit,
-	engineObjectsUpdate,
-	engineObjectsDestroy,
-	engineObjectsCollect,
-	engineObjectsCallback,
-	engineObjectsRaycast,
-	engineAddPlugin,
+    /** Create the global newgrounds object
+     *  @param {string} app_id     - The newgrounds App ID
+     *  @param {string} [cipher]   - The encryption Key (AES-128/Base64)
+     *  @param {Object} [cryptoJS] - An instance of CryptoJS, if there is a cipher 
+     *  @example
+     *  // create the newgrounds object, replace the app id with your own
+     *  const app_id = 'your_app_id_here';
+     *  new NewgroundsPlugin(app_id);
+     */
+    constructor(app_id, cipher, cryptoJS)
+    {
+        ASSERT(!newgrounds, 'there can only be one newgrounds object');
+        ASSERT(!cipher || cryptoJS, 'must provide cryptojs if there is a cipher');
 
-	// Globals
-	debug,
-	debugOverlay,
-	showWatermark,
+        newgrounds = this; // set global newgrounds object
+        this.app_id = app_id;
+        this.cipher = cipher;
+        this.cryptoJS = cryptoJS;
+        this.host = location ? location.hostname : '';
 
-	// Debug
-	ASSERT,
-	debugRect,
-	debugPoly,
-	debugCircle,
-	debugPoint,
-	debugLine,
-	debugOverlap,
-	debugText,
-	debugClear,
-	debugScreenshot,
-	debugSaveCanvas,
-	debugSaveText,
-	debugSaveDataURL,
-	debugShowErrors,
-	debugVideoCaptureIsActive,
-	debugVideoCaptureStart,
-	debugVideoCaptureStop,
+        // get session id from url search params
+        const url = new URL(location.href);
+        this.session_id = url.searchParams.get('ngio_session_id');
 
-	// Settings
-	cameraPos,
-	cameraScale,
-	canvasMaxSize,
-	canvasFixedSize,
-	canvasPixelated,
-	tilesPixelated,
-	fontDefault,
-	showSplashScreen,
-	headlessMode,
-	tileSizeDefault,
-	tileFixBleedScale,
-	enablePhysicsSolver,
-	objectDefaultMass,
-	objectDefaultDamping,
-	objectDefaultAngleDamping,
-	objectDefaultElasticity,
-	objectDefaultFriction,
-	objectMaxSpeed,
-	gravity,
-	particleEmitRateScale,
-	glEnable,
-	glOverlay,
-	gamepadsEnable,
-	gamepadDirectionEmulateStick,
-	inputWASDEmulateDirection,
-	touchGamepadEnable,
-	touchGamepadAnalog,
-	touchGamepadSize,
-	touchGamepadAlpha,
-	vibrateEnable,
-	soundEnable,
-	soundVolume,
-	soundDefaultRange,
-	soundDefaultTaper,
-	medalDisplayTime,
-	medalDisplaySlideTime,
-	medalDisplaySize,
+        if (!this.session_id)
+            return; // only use newgrounds when logged in
 
-	// Setters for globals
-	setCameraPos,
-	setCameraScale,
-	setCanvasMaxSize,
-	setCanvasFixedSize,
-	setCanvasPixelated,
-	setTilesPixelated,
-	setFontDefault,
-	setShowSplashScreen,
-	setHeadlessMode,
-	setGlEnable,
-	setGlOverlay,
-	setTileSizeDefault,
-	setTileFixBleedScale,
-	setEnablePhysicsSolver,
-	setObjectDefaultMass,
-	setObjectDefaultDamping,
-	setObjectDefaultAngleDamping,
-	setObjectDefaultElasticity,
-	setObjectDefaultFriction,
-	setObjectMaxSpeed,
-	setGravity,
-	setParticleEmitRateScale,
-	setTouchInputEnable,
-	setGamepadsEnable,
-	setGamepadDirectionEmulateStick,
-	setInputWASDEmulateDirection,
-	setTouchGamepadEnable,
-	setTouchGamepadAnalog,
-	setTouchGamepadSize,
-	setTouchGamepadAlpha,
-	setVibrateEnable,
-	setSoundEnable,
-	setSoundVolume,
-	setSoundDefaultRange,
-	setSoundDefaultTaper,
-	setMedalDisplayTime,
-	setMedalDisplaySlideTime,
-	setMedalDisplaySize,
-	setMedalsPreventUnlock,
-	setShowWatermark,
-	setDebugKey,
+        // get medals
+        const medalsResult = this.call('Medal.getList');
+        this.medals = medalsResult ? medalsResult.result.data['medals'] : [];
+        debugMedals && console.log(this.medals);
+        for (const newgroundsMedal of this.medals)
+        {
+            const medal = medals[newgroundsMedal['id']];
+            if (medal)
+            {
+                // copy newgrounds medal data
+                medal.image =       new Image;
+                medal.image.src =   newgroundsMedal['icon'];
+                medal.name =        newgroundsMedal['name'];
+                medal.description = newgroundsMedal['description'];
+                medal.unlocked =    newgroundsMedal['unlocked'];
+                medal.difficulty =  newgroundsMedal['difficulty'];
+                medal.value =       newgroundsMedal['value'];
 
-	// Utilities
-	PI,
-	abs,
-	min,
-	max,
-	sign,
-	mod,
-	clamp,
-	percent,
-	distanceWrap,
-	lerpWrap,
-	distanceAngle,
-	lerpAngle,
-	lerp,
-	smoothStep,
-	nearestPowerOfTwo,
-	isOverlapping,
-	isIntersecting,
-	wave,
-	formatTime,
+                if (medal.value) // add value to description
+                    medal.description = medal.description + ` (${ medal.value })`;
+            }
+        }
+    
+        // get scoreboards
+        const scoreboardResult = this.call('ScoreBoard.getBoards');
+        this.scoreboards = scoreboardResult ? scoreboardResult.result.data.scoreboards : [];
+        debugMedals && console.log(this.scoreboards);
 
-	// Random
-	rand,
-	randInt,
-	randSign,
-	randInCircle,
-	randVector,
-	randColor,
+        // keep the session alive with a ping every minute
+        const keepAliveMS = 60 * 1e3;
+        setInterval(()=>this.call('Gateway.ping', 0, true), keepAliveMS);
+    }
 
-	// Utility Classes
-	RandomGenerator,
-	Vector2,
-	Color,
-	Timer,
-	vec2,
-	rgb,
-	hsl,
-	isColor,
+    /** Send message to unlock a medal by id
+     * @param {number} id - The medal id */
+    unlockMedal(id) { return this.call('Medal.unlock', {'id':id}, true); }
 
-	// Default Colors
-	WHITE,
-	BLACK,
-	GRAY,
-	RED,
-	ORANGE,
-	YELLOW,
-	GREEN,
-	CYAN,
-	BLUE,
-	PURPLE,
-	MAGENTA,
+    /** Send message to post score
+     * @param {number} id    - The scoreboard id
+     * @param {number} value - The score value */
+    postScore(id, value) { return this.call('ScoreBoard.postScore', {'id':id, 'value':value}, true); }
 
-	// Draw
-	textureInfos,
-	tile,
-	TileInfo,
-	TextureInfo,
-	mainCanvas,
-	mainContext,
-	overlayCanvas,
-	overlayContext,
-	mainCanvasSize,
-	screenToWorld,
-	worldToScreen,
-	drawTile,
-	drawRect,
-	drawLine,
-	drawPoly,
-	drawEllipse,
-	drawCircle,
-	drawCanvas2D,
-	drawText,
-	drawTextOverlay,
-	drawTextScreen,
-	setBlendMode,
-	combineCanvases,
-	engineFontImage,
-	FontImage,
-	isFullscreen,
-	toggleFullscreen,
-	setCursor,
-	getCameraSize,
+    /** Get scores from a scoreboard
+     * @param {number} id       - The scoreboard id
+     * @param {string} [user]   - A user's id or name
+     * @param {number} [social] - If true, only social scores will be loaded
+     * @param {number} [skip]   - Number of scores to skip before start
+     * @param {number} [limit]  - Number of scores to include in the list
+     * @return {Object}         - The response JSON object
+     */
+    getScores(id, user, social=0, skip=0, limit=10)
+    { return this.call('ScoreBoard.getScores', {'id':id, 'user':user, 'social':social, 'skip':skip, 'limit':limit}); }
 
-	// WebGL
-	glCanvas,
-	glContext,
-	glCompileShader,
-	glCopyToContext,
-	glCreateProgram,
-	glCreateTexture,
-	glSetTextureData,
-	glDraw,
-	glFlush,
-	glSetTexture,
-	glSetAntialias,
-	glClearCanvas,
-	glAntialias,
-	glShader, 
-	glActiveTexture, 
-	glArrayBuffer, 
-	glGeometryBuffer, 
-	glPositionData, 
-	glColorData, 
-	glInstanceCount, 
-	glAdditive, 
-	glBatchAdditive,
+    /** Send message to log a view */
+    logView() { return this.call('App.logView', {'host':this.host}, true); }
 
-	// Input
-	keyIsDown,
-	keyWasPressed,
-	keyWasReleased,
-	keyDirection,
-	clearInput,
-	mouseIsDown,
-	mouseWasPressed,
-	mouseWasReleased,
-	mousePos,
-	mousePosScreen,
-	mouseWheel,
-	isUsingGamepad,
-	inputPreventDefault,
-	setInputPreventDefault,
-	gamepadIsDown,
-	gamepadWasPressed,
-	gamepadWasReleased,
-	gamepadStick,
-	gamepadsUpdate,
-	vibrate,
-	vibrateStop,
-	isTouchDevice,
-
-	// Audio
-	Sound,
-	SoundWave,
-	playAudioFile,
-	speak,
-	speakStop,
-	getNoteFrequency,
-	playSamples,
-	zzfx,
-	zzfxG,
-	zzfxR,
-	audioContext,
-
-	// Base Object
-	EngineObject,
-
-	// Tiles
-	tileCollision,
-	tileCollisionSize,
-	initTileCollision,
-	setTileCollisionData,
-	getTileCollisionData,
-	tileCollisionTest,
-	tileCollisionRaycast,
-	TileLayerData,
-	TileLayer,
-
-	// Particles
-	ParticleEmitter,
-	Particle,
-
-	// Medals
-	medals,
-	medalsPreventUnlock,
-	medalsInit,
-	Medal,
-};
-
-/** 
- * LittleJS Newgrounds API
- * - NewgroundsMedal extends Medal with Newgrounds API functionality
- * - Call new NewgroundsPlugin() to setup Newgrounds
- * - Uses CryptoJS for encryption if optional cipher is provided
- * - Keeps connection alive and logs views
- * - Functions to interact with scoreboards
- * - Functions to unlock medals
- */
-
-'use strict';
-
-/** Global Newgrounds object
- *  @type {NewgroundsPlugin}
- *  @memberof Medal */
-let newgrounds;
-
-///////////////////////////////////////////////////////////////////////////////
-/**
- * Newgrounds medal auto unlocks in newgrounds API
- * @extends Medal
- */
-class NewgroundsMedal extends Medal
-{
-    /** Create a newgrounds medal object and adds it to the list of medals
-     *  @param {Number} id            - The unique identifier of the medal
-     *  @param {String} name          - Name of the medal
-     *  @param {String} [description] - Description of the medal
-     *  @param {String} [icon]        - Icon for the medal
-     *  @param {String} [src]         - Image location for the medal
-     */
-    constructor(id, name, description, icon, src)
-    { super(id, name, description, icon, src); }
-
-    /** Unlocks a medal if not already unlocked */
-    unlock()
-    {
-        super.unlock();
-        newgrounds && newgrounds.unlockMedal(this.id);
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-/** 
- * Newgrounds API object
- */
-class NewgroundsPlugin
-{
-    /** Create the global newgrounds object
-     *  @param {string} app_id     - The newgrounds App ID
-     *  @param {string} [cipher]   - The encryption Key (AES-128/Base64)
-     *  @param {Object} [cryptoJS] - An instance of CryptoJS, if there is a cipher 
-     *  @example
-     *  // create the newgrounds object, replace the app id with your own
-     *  const app_id = 'your_app_id_here';
-     *  new NewgroundsPlugin(app_id);
-     */
-    constructor(app_id, cipher, cryptoJS)
-    {
-        ASSERT(!newgrounds, 'there can only be one newgrounds object');
-        ASSERT(!cipher || cryptoJS, 'must provide cryptojs if there is a cipher');
-
-        newgrounds = this; // set global newgrounds object
-        this.app_id = app_id;
-        this.cipher = cipher;
-        this.cryptoJS = cryptoJS;
-        this.host = location ? location.hostname : '';
-
-        // get session id from url search params
-        const url = new URL(location.href);
-        this.session_id = url.searchParams.get('ngio_session_id');
-
-        if (!this.session_id)
-            return; // only use newgrounds when logged in
-
-        // get medals
-        const medalsResult = this.call('Medal.getList');
-        this.medals = medalsResult ? medalsResult.result.data['medals'] : [];
-        debugMedals && console.log(this.medals);
-        for (const newgroundsMedal of this.medals)
-        {
-            const medal = medals[newgroundsMedal['id']];
-            if (medal)
-            {
-                // copy newgrounds medal data
-                medal.image =       new Image;
-                medal.image.src =   newgroundsMedal['icon'];
-                medal.name =        newgroundsMedal['name'];
-                medal.description = newgroundsMedal['description'];
-                medal.unlocked =    newgroundsMedal['unlocked'];
-                medal.difficulty =  newgroundsMedal['difficulty'];
-                medal.value =       newgroundsMedal['value'];
-
-                if (medal.value) // add value to description
-                    medal.description = medal.description + ` (${ medal.value })`;
-            }
-        }
-    
-        // get scoreboards
-        const scoreboardResult = this.call('ScoreBoard.getBoards');
-        this.scoreboards = scoreboardResult ? scoreboardResult.result.data.scoreboards : [];
-        debugMedals && console.log(this.scoreboards);
-
-        // keep the session alive with a ping every minute
-        const keepAliveMS = 60 * 1e3;
-        setInterval(()=>this.call('Gateway.ping', 0, true), keepAliveMS);
-    }
-
-    /** Send message to unlock a medal by id
-     * @param {number} id - The medal id */
-    unlockMedal(id) { return this.call('Medal.unlock', {'id':id}, true); }
-
-    /** Send message to post score
-     * @param {number} id    - The scoreboard id
-     * @param {number} value - The score value */
-    postScore(id, value) { return this.call('ScoreBoard.postScore', {'id':id, 'value':value}, true); }
-
-    /** Get scores from a scoreboard
-     * @param {number} id       - The scoreboard id
-     * @param {string} [user]   - A user's id or name
-     * @param {number} [social] - If true, only social scores will be loaded
-     * @param {number} [skip]   - Number of scores to skip before start
-     * @param {number} [limit]  - Number of scores to include in the list
-     * @return {Object}         - The response JSON object
-     */
-    getScores(id, user, social=0, skip=0, limit=10)
-    { return this.call('ScoreBoard.getScores', {'id':id, 'user':user, 'social':social, 'skip':skip, 'limit':limit}); }
-
-    /** Send message to log a view */
-    logView() { return this.call('App.logView', {'host':this.host}, true); }
-
-    /** Send a message to call a component of the Newgrounds API
-     * @param {string}  component    - Name of the component
-     * @param {Object}  [parameters] - Parameters to use for call
-     * @param {boolean} [async]      - If true, don't wait for response before continuing
-     * @return {Object}              - The response JSON object
-     */
-    call(component, parameters, async=false)
-    {
-        const call = {'component':component, 'parameters':parameters};
-        if (this.cipher)
-        {
-            // encrypt using AES-128 Base64 with cryptoJS
-            const cryptoJS = this.cryptoJS;
-            const aesKey = cryptoJS['enc']['Base64']['parse'](this.cipher);
-            const iv = cryptoJS['lib']['WordArray']['random'](16);
-            const encrypted = cryptoJS['AES']['encrypt'](JSON.stringify(call), aesKey, {'iv':iv});
-            call['secure'] = cryptoJS['enc']['Base64']['stringify'](iv.concat(encrypted['ciphertext']));
-            call['parameters'] = 0;
-        }
+    /** Send a message to call a component of the Newgrounds API
+     * @param {string}  component    - Name of the component
+     * @param {Object}  [parameters] - Parameters to use for call
+     * @param {boolean} [async]      - If true, don't wait for response before continuing
+     * @return {Object}              - The response JSON object
+     */
+    call(component, parameters, async=false)
+    {
+        const call = {'component':component, 'parameters':parameters};
+        if (this.cipher)
+        {
+            // encrypt using AES-128 Base64 with cryptoJS
+            const cryptoJS = this.cryptoJS;
+            const aesKey = cryptoJS['enc']['Base64']['parse'](this.cipher);
+            const iv = cryptoJS['lib']['WordArray']['random'](16);
+            const encrypted = cryptoJS['AES']['encrypt'](JSON.stringify(call), aesKey, {'iv':iv});
+            call['secure'] = cryptoJS['enc']['Base64']['stringify'](iv.concat(encrypted['ciphertext']));
+            call['parameters'] = 0;
+        }
 
         // build the input object
         const input =
@@ -6408,8 +6202,6 @@ class NewgroundsPlugin
  * - can be enabled to pass other canvases through a final shader
  */
 
-'use strict';
-
 ///////////////////////////////////////////////////////////////////////////////
 
 /** Global Post Process plugin object
@@ -6522,8 +6314,6 @@ class PostProcessPlugin
  * LittleJS ZzFXM Plugin
  */
 
-'use strict';
-
 /**
  * Music Object - Stores a zzfx music track for later use
  * 
@@ -6692,8 +6482,6 @@ function zzfxM(instruments, patterns, sequence, BPM = 125)
  * - Images
  */
 
-'use strict';
-
 ///////////////////////////////////////////////////////////////////////////////
 
 /** Global UI system plugin object
@@ -6861,6 +6649,8 @@ class UIObject
         this.lineWidth  = uiSystem.defaultLineWidth;
         /** @property {string} */
         this.font       = uiSystem.defaultFont;
+        /** @property {number} - override for text height */
+        this.textHeight   = undefined;
         /** @property {boolean} */
         this.visible    = true;
         /** @property {Array<UIObject>} */
@@ -6971,7 +6761,8 @@ class UIText extends UIObject
     }
     render()
     {
-        uiSystem.drawText(this.text, this.pos, this.size, this.textColor, this.lineWidth, this.lineColor, this.align, this.font);
+        const textSize = vec2(this.size.x, this.textHeight || this.size.y);
+        uiSystem.drawText(this.text, this.pos, textSize, this.textColor, this.lineWidth, this.lineColor, this.align, this.font);
     }
 }
 
@@ -7034,7 +6825,9 @@ class UIButton extends UIObject
         const lineColor = this.mouseIsHeld ? this.color : this.lineColor;
         const color = this.mouseIsOver? this.hoverColor : this.color;
         uiSystem.drawRect(this.pos, this.size, color, this.lineWidth, lineColor);
-        const textSize = vec2(this.size.x, this.size.y*.8);
+        
+        const textScale = .8; // scale text to fit in button
+        const textSize = vec2(this.size.x, this.textHeight || this.size.y*textScale);
         uiSystem.drawText(this.text, this.pos, textSize, 
             this.textColor, 0, undefined, this.align, this.font);
     }
@@ -7131,7 +6924,8 @@ class UIScrollbar extends UIObject
         const barColor = this.mouseIsHeld ? this.color : this.handleColor;
         uiSystem.drawRect(handlePos, handleSize, barColor, this.lineWidth, this.lineColor);
 
-        const textSize = vec2(this.size.x, this.size.y*.8);
+        const textScale = .8; // scale text to fit in scrollbar
+        const textSize = vec2(this.size.x, this.textHeight || this.size.y*textScale);
         uiSystem.drawText(this.text, this.pos, textSize, 
             this.textColor, 0, undefined, this.align, this.font);
     }
@@ -7140,29 +6934,35 @@ class UIScrollbar extends UIObject
 /**
  * LittleJS Box2D Physics Plugin
  * - Box2dObject extends EngineObject with Box2D physics
- * - Call box2dEngineInit() to start instead of normal engineInit()
+ * - Call box2dInit() before engineInit() to enable
  * - You will also need to include box2d.wasm.js
- * - Uses box2d.js super fast web assembly port of Box2D
+ * - Uses a super fast web assembly port of Box2D
  * - More info: https://github.com/kripken/box2d.js
- * - Fully wraps everything in Box2d
  * - Functions to create polygon, circle, and edge shapes
- * - Raycasting and querying
- * - Joint creation
  * - Contact begin and end callbacks
+ * - Wraps b2Vec2 type to/from Vector2
+ * - Raycasting and querying
+ * - Every type of joint
  * - Debug physics drawing
+ * @namespace Box2D
  */
 
-'use strict';
- 
 /** Global Box2d Plugin object
- *  @type {Box2dPlugin} */
+ *  @type {Box2dPlugin}
+ *  @memberof Box2D */
 let box2d;
 
 /** Enable Box2D debug drawing
  *  @type {boolean}
- *  @default */
+ *  @default
+ *  @memberof Box2D */
 let box2dDebug = false;
 
+/** Enable Box2D debug drawing
+ *  @param {boolean} enable
+ *  @memberof Box2D */
+function box2dSetDebug(enable) { box2dDebug = enable; }
+
 ///////////////////////////////////////////////////////////////////////////////
 /** 
  * Box2D Object - extend with your own custom physics objects
@@ -7262,7 +7062,7 @@ class Box2dObject extends EngineObject
      *  @param {number}  [friction]
      *  @param {number}  [restitution]
      *  @param {boolean} [isSensor] */
-    addShape(shape, density=1, friction=.2, restitution=0, isSensor=false)
+    addShape(shape, density=1, friction=1, restitution=0, isSensor=false)
     {
         const fd = new box2d.instance.b2FixtureDef();
         fd.set_shape(shape);
@@ -8566,7 +8366,7 @@ class Box2dPlugin
      *  @param {number} [frames] */
     step(frames=1)
     {
-        box2d.world.SetGravity(box2d.vec2dTo(vec2(0,gravity)));
+        box2d.world.SetGravity(box2d.vec2dTo(gravity));
         for (let i=frames; i--;)
             box2d.world.Step(timeDelta, this.velocityIterations, this.positionIterations);
     }
@@ -8707,8 +8507,8 @@ class Box2dPlugin
         aabb.set_upperBound(box2d.vec2dTo(pos));
 
         let queryObject;
-        debugRaycast && debugRect(pos, vec2(), queryObject ? '#f00' : '#00f', .02);
         box2d.world.QueryAABB(queryCallback, aabb);
+        debugRaycast && debugRect(pos, vec2(), queryObject ? '#f00' : '#00f', .02);
         return queryObject;
     }
 
@@ -8839,176 +8639,464 @@ class Box2dPlugin
         return new Vector2(v.get_x(), v.get_y()); 
     }
 
-    /** converts a box2d vec2 pointer to a Vector2
-     *  @param {Object} v */
-    vec2FromPointer(v)
-    {
-        return box2d.vec2From(box2d.instance.wrapPointer(v, box2d.instance.b2Vec2));
-    }
+    /** converts a box2d vec2 pointer to a Vector2
+     *  @param {Object} v */
+    vec2FromPointer(v)
+    {
+        return box2d.vec2From(box2d.instance.wrapPointer(v, box2d.instance.b2Vec2));
+    }
+
+    /** converts a Vector2 to a box2 vec2
+     *  @param {Vector2} v */
+    vec2dTo(v)
+    {
+        ASSERT(v instanceof Vector2);
+        return new box2d.instance.b2Vec2(v.x, v.y);
+    }
+
+    /** checks if a box2d object is null
+     *  @param {Object} o */
+    isNull(o) { return !box2d.instance.getPointer(o); }
+
+    /** casts a box2d object to its correct type
+     *  @param {Object} o */
+    castObjectType(o)
+    {
+        switch (o.GetType())
+        {
+            case box2d.instance.b2Shape.e_circle:
+                return box2d.instance.castObject(o, box2d.instance.b2CircleShape);
+            case box2d.instance.b2Shape.e_edge:
+                return box2d.instance.castObject(o, box2d.instance.b2EdgeShape);
+            case box2d.instance.b2Shape.e_polygon:
+                return box2d.instance.castObject(o, box2d.instance.b2PolygonShape);
+            case box2d.instance.b2Shape.e_chain:
+                return box2d.instance.castObject(o, box2d.instance.b2ChainShape);
+            case box2d.instance.e_revoluteJoint:
+                return box2d.instance.castObject(o, box2d.instance.b2RevoluteJoint);
+            case box2d.instance.e_prismaticJoint:
+                return box2d.instance.castObject(o, box2d.instance.b2PrismaticJoint);
+            case box2d.instance.e_distanceJoint:
+                return box2d.instance.castObject(o, box2d.instance.b2DistanceJoint);
+            case box2d.instance.e_pulleyJoint:
+                return box2d.instance.castObject(o, box2d.instance.b2PulleyJoint);
+            case box2d.instance.e_mouseJoint:
+                return box2d.instance.castObject(o, box2d.instance.b2MouseJoint);
+            case box2d.instance.e_gearJoint:
+                return box2d.instance.castObject(o, box2d.instance.b2GearJoint);
+            case box2d.instance.e_wheelJoint:
+                return box2d.instance.castObject(o, box2d.instance.b2WheelJoint);
+            case box2d.instance.e_weldJoint:
+                return box2d.instance.castObject(o, box2d.instance.b2WeldJoint);
+            case box2d.instance.e_frictionJoint:
+                return box2d.instance.castObject(o, box2d.instance.b2FrictionJoint);
+            case box2d.instance.e_ropeJoint:
+                return box2d.instance.castObject(o, box2d.instance.b2RopeJoint);
+            case box2d.instance.e_motorJoint:
+                return box2d.instance.castObject(o, box2d.instance.b2MotorJoint);
+        }
+        
+        ASSERT(false, 'Unknown box2d object type');
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/** Box2d Init - Call with await before starting LittleJS to init box2d
+ *  @return {Promise<Box2dPlugin>}
+ *  @memberof Box2D */
+async function box2dInit()
+{
+    // load box2d
+    new Box2dPlugin(await Box2D());
+    setupDebugDraw();
+    engineAddPlugin(box2dUpdate, box2dRender);
+    return box2d;
+
+    // add the box2d plugin to the engine
+    function box2dUpdate()
+    {
+        if (!paused)
+            box2d.step();
+    }
+    function box2dRender()
+    {
+        if (box2dDebug || debugPhysics && debugOverlay)
+            box2d.world.DrawDebugData();
+    }
+    
+    // box2d debug drawing
+    function setupDebugDraw()
+    {
+        // setup debug draw
+        const debugDraw = new box2d.instance.JSDraw();
+        const box2dColor = (c)=> new Color(c.get_r(), c.get_g(), c.get_b());
+        const box2dColorPointer = (c)=>
+            box2dColor(box2d.instance.wrapPointer(c, box2d.instance.b2Color));
+        const getDebugColor = (color)=>box2dColorPointer(color).scale(1,.8);
+        const getPointsList = (vertices, vertexCount) =>
+        {
+            const points = [];
+            for (let i=vertexCount; i--;)
+                points.push(box2d.vec2FromPointer(vertices+i*8));
+            return points;
+        }
+        debugDraw.DrawSegment = function(point1, point2, color)
+        {
+            color = getDebugColor(color);
+            point1 = box2d.vec2FromPointer(point1);
+            point2 = box2d.vec2FromPointer(point2);
+            box2d.drawLine(vec2(), 0, point1, point2, color, undefined, overlayContext);
+        };
+        debugDraw.DrawPolygon = function(vertices, vertexCount, color)
+        {
+            color = getDebugColor(color);
+            const points = getPointsList(vertices, vertexCount);
+            box2d.drawPoly(vec2(), 0, points, undefined, color, undefined, overlayContext);
+        };
+        debugDraw.DrawSolidPolygon = function(vertices, vertexCount, color)
+        {
+            color = getDebugColor(color);
+            const points = getPointsList(vertices, vertexCount);
+            box2d.drawPoly(vec2(), 0, points, color, color, undefined, overlayContext);
+        };
+        debugDraw.DrawCircle = function(center, radius, color)
+        {
+            color = getDebugColor(color);
+            center = box2d.vec2FromPointer(center);
+            box2d.drawCircle(center, radius, undefined, color, undefined, overlayContext);
+        };
+        debugDraw.DrawSolidCircle = function(center, radius, axis, color)
+        {
+            color = getDebugColor(color);
+            center = box2d.vec2FromPointer(center);
+            axis = box2d.vec2FromPointer(axis).scale(radius);
+            box2d.drawCircle(center, radius, color, color, undefined, overlayContext);
+            box2d.drawLine(center, 0, vec2(), axis, color, undefined, overlayContext);
+        };
+        debugDraw.DrawTransform = function(transform)
+        {
+            transform = box2d.instance.wrapPointer(transform, box2d.instance.b2Transform);
+            const pos = vec2(transform.get_p());
+            const angle = -transform.get_q().GetAngle();
+            const p1 = vec2(1,0), c1 = rgb(.75,0,0,.8);
+            const p2 = vec2(0,1), c2 = rgb(0,.75,0,.8);
+            box2d.drawLine(pos, angle, vec2(), p1, c1, undefined, overlayContext);
+            box2d.drawLine(pos, angle, vec2(), p2, c2, undefined, overlayContext);
+        }
+            
+        debugDraw.AppendFlags(box2d.instance.b2Draw.e_shapeBit);
+        debugDraw.AppendFlags(box2d.instance.b2Draw.e_jointBit);
+        //debugDraw.AppendFlags(box2d.instance.b2Draw.e_aabbBit);
+        //debugDraw.AppendFlags(box2d.instance.b2Draw.e_pairBit);
+        //debugDraw.AppendFlags(box2d.instance.b2Draw.e_centerOfMassBit);
+        box2d.world.SetDebugDraw(debugDraw);
+    }
+}
+
+
+/**
+ * LittleJS Module Export
+ */
+
+export
+{
+	// Engine
+	engineName,
+	engineVersion,
+	frameRate,
+	timeDelta,
+	engineObjects,
+	frame,
+	time,
+	timeReal,
+	paused,
+	setPaused,
+	engineInit,
+	engineObjectsUpdate,
+	engineObjectsDestroy,
+	engineObjectsCollect,
+	engineObjectsCallback,
+	engineObjectsRaycast,
+	engineAddPlugin,
+
+	// Globals
+	debug,
+	debugOverlay,
+	showWatermark,
+
+	// Debug
+	ASSERT,
+	debugRect,
+	debugPoly,
+	debugCircle,
+	debugPoint,
+	debugLine,
+	debugOverlap,
+	debugText,
+	debugClear,
+	debugScreenshot,
+	debugSaveCanvas,
+	debugSaveText,
+	debugSaveDataURL,
+	debugShowErrors,
+	debugVideoCaptureIsActive,
+	debugVideoCaptureStart,
+	debugVideoCaptureStop,
+
+	// Settings
+	cameraPos,
+	cameraScale,
+	canvasMaxSize,
+	canvasFixedSize,
+	canvasPixelated,
+	tilesPixelated,
+	fontDefault,
+	showSplashScreen,
+	headlessMode,
+	tileSizeDefault,
+	tileFixBleedScale,
+	enablePhysicsSolver,
+	objectDefaultMass,
+	objectDefaultDamping,
+	objectDefaultAngleDamping,
+	objectDefaultElasticity,
+	objectDefaultFriction,
+	objectMaxSpeed,
+	gravity,
+	particleEmitRateScale,
+	glEnable,
+	glOverlay,
+	gamepadsEnable,
+	gamepadDirectionEmulateStick,
+	inputWASDEmulateDirection,
+	touchGamepadEnable,
+	touchGamepadAnalog,
+	touchGamepadSize,
+	touchGamepadAlpha,
+	vibrateEnable,
+	soundEnable,
+	soundVolume,
+	soundDefaultRange,
+	soundDefaultTaper,
+	medalDisplayTime,
+	medalDisplaySlideTime,
+	medalDisplaySize,
+
+	// Setters for globals
+	setCameraPos,
+	setCameraScale,
+	setCanvasMaxSize,
+	setCanvasFixedSize,
+	setCanvasPixelated,
+	setTilesPixelated,
+	setFontDefault,
+	setShowSplashScreen,
+	setHeadlessMode,
+	setGlEnable,
+	setGlOverlay,
+	setTileSizeDefault,
+	setTileFixBleedScale,
+	setEnablePhysicsSolver,
+	setObjectDefaultMass,
+	setObjectDefaultDamping,
+	setObjectDefaultAngleDamping,
+	setObjectDefaultElasticity,
+	setObjectDefaultFriction,
+	setObjectMaxSpeed,
+	setGravity,
+	setParticleEmitRateScale,
+	setTouchInputEnable,
+	setGamepadsEnable,
+	setGamepadDirectionEmulateStick,
+	setInputWASDEmulateDirection,
+	setTouchGamepadEnable,
+	setTouchGamepadAnalog,
+	setTouchGamepadSize,
+	setTouchGamepadAlpha,
+	setVibrateEnable,
+	setSoundEnable,
+	setSoundVolume,
+	setSoundDefaultRange,
+	setSoundDefaultTaper,
+	setMedalDisplayTime,
+	setMedalDisplaySlideTime,
+	setMedalDisplaySize,
+	setMedalsPreventUnlock,
+	setShowWatermark,
+	setDebugKey,
+
+	// Utilities
+	PI,
+	abs,
+	min,
+	max,
+	sign,
+	mod,
+	clamp,
+	percent,
+	distanceWrap,
+	lerpWrap,
+	distanceAngle,
+	lerpAngle,
+	lerp,
+	smoothStep,
+	nearestPowerOfTwo,
+	isOverlapping,
+	isIntersecting,
+	wave,
+	formatTime,
+	fetchJSON,
+
+	// Random
+	rand,
+	randInt,
+	randSign,
+	randInCircle,
+	randVector,
+	randColor,
+
+	// Utility Classes
+	RandomGenerator,
+	Vector2,
+	Color,
+	Timer,
+	vec2,
+	rgb,
+	hsl,
+	isColor,
+
+	// Default Colors
+	WHITE,
+	BLACK,
+	GRAY,
+	RED,
+	ORANGE,
+	YELLOW,
+	GREEN,
+	CYAN,
+	BLUE,
+	PURPLE,
+	MAGENTA,
+
+	// Draw
+	textureInfos,
+	tile,
+	TileInfo,
+	TextureInfo,
+	mainCanvas,
+	mainContext,
+	overlayCanvas,
+	overlayContext,
+	mainCanvasSize,
+	screenToWorld,
+	worldToScreen,
+	drawTile,
+	drawRect,
+	drawLine,
+	drawPoly,
+	drawEllipse,
+	drawCircle,
+	drawCanvas2D,
+	drawText,
+	drawTextOverlay,
+	drawTextScreen,
+	setBlendMode,
+	combineCanvases,
+	engineFontImage,
+	FontImage,
+	isFullscreen,
+	toggleFullscreen,
+	setCursor,
+	getCameraSize,
 
-    /** converts a Vector2 to a box2 vec2
-     *  @param {Vector2} v */
-    vec2dTo(v)
-    {
-        ASSERT(v instanceof Vector2);
-        return new box2d.instance.b2Vec2(v.x, v.y);
-    }
+	// WebGL
+	glCanvas,
+	glContext,
+	glCompileShader,
+	glCopyToContext,
+	glCreateProgram,
+	glCreateTexture,
+	glSetTextureData,
+	glDraw,
+	glFlush,
+	glSetTexture,
+	glSetAntialias,
+	glClearCanvas,
+	glAntialias,
+	glShader, 
+	glActiveTexture, 
+	glArrayBuffer, 
+	glGeometryBuffer, 
+	glPositionData, 
+	glColorData, 
+	glInstanceCount, 
+	glAdditive, 
+	glBatchAdditive,
 
-    /** checks if a box2d object is null
-     *  @param {Object} o */
-    isNull(o) { return !box2d.instance.getPointer(o); }
+	// Input
+	keyIsDown,
+	keyWasPressed,
+	keyWasReleased,
+	keyDirection,
+	clearInput,
+	mouseIsDown,
+	mouseWasPressed,
+	mouseWasReleased,
+	mousePos,
+	mousePosScreen,
+	mouseWheel,
+	isUsingGamepad,
+	inputPreventDefault,
+	setInputPreventDefault,
+	gamepadIsDown,
+	gamepadWasPressed,
+	gamepadWasReleased,
+	gamepadStick,
+	gamepadsUpdate,
+	vibrate,
+	vibrateStop,
+	isTouchDevice,
 
-    /** casts a box2d object to its correct type
-     *  @param {Object} o */
-    castObjectType(o)
-    {
-        switch (o.GetType())
-        {
-            case box2d.instance.b2Shape.e_circle:
-                return box2d.instance.castObject(o, box2d.instance.b2CircleShape);
-            case box2d.instance.b2Shape.e_edge:
-                return box2d.instance.castObject(o, box2d.instance.b2EdgeShape);
-            case box2d.instance.b2Shape.e_polygon:
-                return box2d.instance.castObject(o, box2d.instance.b2PolygonShape);
-            case box2d.instance.b2Shape.e_chain:
-                return box2d.instance.castObject(o, box2d.instance.b2ChainShape);
-            case box2d.instance.e_revoluteJoint:
-                return box2d.instance.castObject(o, box2d.instance.b2RevoluteJoint);
-            case box2d.instance.e_prismaticJoint:
-                return box2d.instance.castObject(o, box2d.instance.b2PrismaticJoint);
-            case box2d.instance.e_distanceJoint:
-                return box2d.instance.castObject(o, box2d.instance.b2DistanceJoint);
-            case box2d.instance.e_pulleyJoint:
-                return box2d.instance.castObject(o, box2d.instance.b2PulleyJoint);
-            case box2d.instance.e_mouseJoint:
-                return box2d.instance.castObject(o, box2d.instance.b2MouseJoint);
-            case box2d.instance.e_gearJoint:
-                return box2d.instance.castObject(o, box2d.instance.b2GearJoint);
-            case box2d.instance.e_wheelJoint:
-                return box2d.instance.castObject(o, box2d.instance.b2WheelJoint);
-            case box2d.instance.e_weldJoint:
-                return box2d.instance.castObject(o, box2d.instance.b2WeldJoint);
-            case box2d.instance.e_frictionJoint:
-                return box2d.instance.castObject(o, box2d.instance.b2FrictionJoint);
-            case box2d.instance.e_ropeJoint:
-                return box2d.instance.castObject(o, box2d.instance.b2RopeJoint);
-            case box2d.instance.e_motorJoint:
-                return box2d.instance.castObject(o, box2d.instance.b2MotorJoint);
-        }
-        
-        ASSERT(false, 'Unknown box2d object type');
-    }
-}
+	// Audio
+	Sound,
+	SoundWave,
+	playAudioFile,
+	speak,
+	speakStop,
+	getNoteFrequency,
+	playSamples,
+	zzfx,
+	zzfxG,
+	zzfxR,
+	audioContext,
 
-///////////////////////////////////////////////////////////////////////////////
-/** Box2d Init - Startup LittleJS engine with your callback functions
- *  @param {Function|function():Promise} gameInit - Called once after the engine starts up
- *  @param {Function} gameUpdate - Called every frame before objects are updated
- *  @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<string>} [imageSources=[]] - List of images to load
- *  @param {HTMLElement} [rootElement] - Root element to attach to, the document body by default */
-function box2dEngineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, imageSources, rootElement)
-{
-    Box2D().then(box2dInstance=>
-    {
-        // create box2d object
-        new Box2dPlugin(box2dInstance);
-        setupDebugDraw();
+	// Base Object
+	EngineObject,
 
-        // start littlejs
-        engineAddPlugin(box2dUpdate, box2dRender);
-        engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, imageSources, rootElement);
-    });
+	// Tiles
+	tileCollisionLayers,
+	getTileCollisionData,
+	tileCollisionTest,
+	tileCollisionRaycast,
+	TileLayerData,
+	TileLayer,
+	TileCollisionLayer,
 
-    // hook up box2d plugin to update and render
-    function box2dUpdate()
-    {
-        if (!paused)
-            box2d.step();
-    }
-    function box2dRender()
-    {
-        if (box2dDebug || debugPhysics && debugOverlay)
-            box2d.world.DrawDebugData();
-    }
-    
-    // box2d debug drawing
-    function setupDebugDraw()
-    {
-        // setup debug draw
-        const debugDraw = new box2d.instance.JSDraw();
-        const box2dColor = (c)=> new Color(c.get_r(), c.get_g(), c.get_b());
-        const box2dColorPointer = (c)=>
-            box2dColor(box2d.instance.wrapPointer(c, box2d.instance.b2Color));
-        const getDebugColor = (color)=>box2dColorPointer(color).scale(1,.8);
-        const getPointsList = (vertices, vertexCount) =>
-        {
-            const points = [];
-            for (let i=vertexCount; i--;)
-                points.push(box2d.vec2FromPointer(vertices+i*8));
-            return points;
-        }
-        debugDraw.DrawSegment = function(point1, point2, color)
-        {
-            color = getDebugColor(color);
-            point1 = box2d.vec2FromPointer(point1);
-            point2 = box2d.vec2FromPointer(point2);
-            box2d.drawLine(vec2(), 0, point1, point2, color, undefined, overlayContext);
-        };
-        debugDraw.DrawPolygon = function(vertices, vertexCount, color)
-        {
-            color = getDebugColor(color);
-            const points = getPointsList(vertices, vertexCount);
-            box2d.drawPoly(vec2(), 0, points, undefined, color, undefined, overlayContext);
-        };
-        debugDraw.DrawSolidPolygon = function(vertices, vertexCount, color)
-        {
-            color = getDebugColor(color);
-            const points = getPointsList(vertices, vertexCount);
-            box2d.drawPoly(vec2(), 0, points, color, color, undefined, overlayContext);
-        };
-        debugDraw.DrawCircle = function(center, radius, color)
-        {
-            color = getDebugColor(color);
-            center = box2d.vec2FromPointer(center);
-            box2d.drawCircle(center, radius, undefined, color, undefined, overlayContext);
-        };
-        debugDraw.DrawSolidCircle = function(center, radius, axis, color)
-        {
-            color = getDebugColor(color);
-            center = box2d.vec2FromPointer(center);
-            axis = box2d.vec2FromPointer(axis).scale(radius);
-            box2d.drawCircle(center, radius, color, color, undefined, overlayContext);
-            box2d.drawLine(center, 0, vec2(), axis, color, undefined, overlayContext);
-        };
-        debugDraw.DrawTransform = function(transform)
-        {
-            transform = box2d.instance.wrapPointer(transform, box2d.instance.b2Transform);
-            const pos = vec2(transform.get_p());
-            const angle = -transform.get_q().GetAngle();
-            const p1 = vec2(1,0), c1 = rgb(.75,0,0,.8);
-            const p2 = vec2(0,1), c2 = rgb(0,.75,0,.8);
-            box2d.drawLine(pos, angle, vec2(), p1, c1, undefined, overlayContext);
-            box2d.drawLine(pos, angle, vec2(), p2, c2, undefined, overlayContext);
-        }
-            
-        debugDraw.AppendFlags(box2d.instance.b2Draw.e_shapeBit);
-        debugDraw.AppendFlags(box2d.instance.b2Draw.e_jointBit);
-        //debugDraw.AppendFlags(box2d.instance.b2Draw.e_aabbBit);
-        //debugDraw.AppendFlags(box2d.instance.b2Draw.e_pairBit);
-        //debugDraw.AppendFlags(box2d.instance.b2Draw.e_centerOfMassBit);
-        box2d.world.SetDebugDraw(debugDraw);
-    }
-}
+	// Particles
+	ParticleEmitter,
+	Particle,
+
+	// Medals
+	medals,
+	medalsPreventUnlock,
+	medalsInit,
+	Medal,
+};
 
 /**
  * LittleJS Module Plugins Export
  */
 
-'use strict';
-
 export
 {
     // Newgrounds
@@ -9036,7 +9124,8 @@ export
     // Box2D Physics
     box2d,
     box2dDebug,
-    box2dEngineInit,
+    box2dSetDebug,
+    box2dInit,
     Box2dPlugin,
     Box2dObject,
     Box2dRaycastResult,