littlejsengine 1.11.17 → 1.12.4

package/dist/littlejs.esm.js

@@ -334,11 +334,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);
     }
 
     {
@@ -1530,7 +1528,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 +1638,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 +1868,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; }
 
@@ -2139,7 +2137,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 +2155,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 +2199,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 +2261,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 +2284,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 +2294,7 @@ class EngineObject
                             this.groundObject = undefined; 
                         }
                     }
-                    if (isBlockedX)
+                    if (blockedLayerX)
                     {
                         // move to previous position and bounce
                         this.pos.x = oldPos.x;
@@ -3392,7 +3394,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)
@@ -4067,75 +4071,47 @@ 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
  */
 
 
 
-/** 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;
-}
+///////////////////////////////////////////////////////////////////////////////
+// Tile Layer System
 
-/** 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 +4123,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 +4165,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 +4197,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,6 +4397,146 @@ 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
@@ -5326,7 +5413,7 @@ const engineName = 'LittleJS';
  *  @type {string}
  *  @default
  *  @memberof Engine */
-const engineVersion = '1.11.17';
+const engineVersion = '1.12.4';
 
 /** Frames per second to update
  *  @type {number}
@@ -5920,383 +6007,80 @@ 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,
-
-	// 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,
-
-	// 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,
-
-	// WebGL
-	glCanvas,
-	glContext,
-	glCompileShader,
-	glCopyToContext,
-	glCreateProgram,
-	glCreateTexture,
-	glSetTextureData,
-	glDraw,
-	glFlush,
-	glSetTexture,
-	glSetAntialias,
-	glClearCanvas,
-	glAntialias,
-	glShader, 
-	glActiveTexture, 
-	glArrayBuffer, 
-	glGeometryBuffer, 
-	glPositionData, 
-	glColorData, 
-	glInstanceCount, 
-	glAdditive, 
-	glBatchAdditive,
-
-	// 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
+        if (!this.session_id)
+            return; // only use newgrounds when logged in
 
         // get medals
         const medalsResult = this.call('Medal.getList');
@@ -6408,7 +6192,7 @@ class NewgroundsPlugin
  * - can be enabled to pass other canvases through a final shader
  */
 
-'use strict';
+
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -6522,7 +6306,7 @@ class PostProcessPlugin
  * LittleJS ZzFXM Plugin
  */
 
-'use strict';
+
 
 /**
  * Music Object - Stores a zzfx music track for later use
@@ -6692,7 +6476,7 @@ function zzfxM(instruments, patterns, sequence, BPM = 125)
  * - Images
  */
 
-'use strict';
+
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -7152,7 +6936,7 @@ class UIScrollbar extends UIObject
  * - Debug physics drawing
  */
 
-'use strict';
+
  
 /** Global Box2d Plugin object
  *  @type {Box2dPlugin} */
@@ -7163,7 +6947,11 @@ let box2d;
  *  @default */
 let box2dDebug = false;
 
-///////////////////////////////////////////////////////////////////////////////
+/** Enable Box2D debug drawing
+ *  @param {boolean} enable */
+function box2dSetDebug(enable) { box2dDebug = enable; }
+
+///////////////////////////////////////////////////////////////////////////////
 /** 
  * Box2D Object - extend with your own custom physics objects
  * - A LittleJS object with Box2D physics
@@ -8566,7 +8354,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 +8495,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;
     }
 
@@ -9003,11 +8791,308 @@ function box2dEngineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameR
     }
 }
 
+
 /**
- * LittleJS Module Plugins Export
+ * LittleJS Module Export
  */
 
-'use strict';
+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,
+
+	// 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,
+
+	// WebGL
+	glCanvas,
+	glContext,
+	glCompileShader,
+	glCopyToContext,
+	glCreateProgram,
+	glCreateTexture,
+	glSetTextureData,
+	glDraw,
+	glFlush,
+	glSetTexture,
+	glSetAntialias,
+	glClearCanvas,
+	glAntialias,
+	glShader, 
+	glActiveTexture, 
+	glArrayBuffer, 
+	glGeometryBuffer, 
+	glPositionData, 
+	glColorData, 
+	glInstanceCount, 
+	glAdditive, 
+	glBatchAdditive,
+
+	// 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
+	tileCollisionLayers,
+	getTileCollisionData,
+	tileCollisionTest,
+	tileCollisionRaycast,
+	TileLayerData,
+	TileLayer,
+	TileCollisionLayer,
+
+	// Particles
+	ParticleEmitter,
+	Particle,
+
+	// Medals
+	medals,
+	medalsPreventUnlock,
+	medalsInit,
+	Medal,
+};
+
+/**
+ * LittleJS Module Plugins Export
+ */
 
 export
 {
@@ -9036,6 +9121,7 @@ export
     // Box2D Physics
     box2d,
     box2dDebug,
+    box2dSetDebug,
     box2dEngineInit,
     Box2dPlugin,
     Box2dObject,