littlejsengine 1.11.9 → 1.11.10

package/src/engineDraw.js

@@ -61,10 +61,10 @@ let drawCount;
  * Create a tile info object using a grid based system
  * - This can take vecs or floats for easier use and conversion
  * - If an index is passed in, the tile size and index will determine the position
- * @param {(Number|Vector2)} [pos=0]                - Index of tile in sheet
- * @param {(Number|Vector2)} [size=tileSizeDefault] - Size of tile in pixels
- * @param {Number} [textureIndex]                   - Texture index to use
- * @param {Number} [padding]                        - How many pixels padding around tiles
+ * @param {Vector2|number} [pos=0]                - Index of tile in sheet
+ * @param {Vector2|number} [size=tileSizeDefault] - Size of tile in pixels
+ * @param {number} [textureIndex]                   - Texture index to use
+ * @param {number} [padding]                        - How many pixels padding around tiles
  * @return {TileInfo}
  * @example
  * tile(2)                       // a tile at index 2 using the default tile size of 16
@@ -108,8 +108,8 @@ class TileInfo
     /** Create a tile info object
      *  @param {Vector2} [pos=(0,0)]            - Top left corner of tile in pixels
      *  @param {Vector2} [size=tileSizeDefault] - Size of tile in pixels
-     *  @param {Number}  [textureIndex]         - Texture index to use
-     *  @param {Number}  [padding]              - How many pixels padding around tiles
+     *  @param {number}  [textureIndex]         - Texture index to use
+     *  @param {number}  [padding]              - How many pixels padding around tiles
      */
     constructor(pos=vec2(), size=tileSizeDefault, textureIndex=0, padding=0)
     {
@@ -117,9 +117,9 @@ class TileInfo
         this.pos = pos.copy();
         /** @property {Vector2} - Size of tile in pixels */
         this.size = size.copy();
-        /** @property {Number} - Texture index to use */
+        /** @property {number} - Texture index to use */
         this.textureIndex = textureIndex;
-        /** @property {Number} - How many pixels padding around tiles */
+        /** @property {number} - How many pixels padding around tiles */
         this.padding = padding;
     }
 
@@ -131,7 +131,7 @@ class TileInfo
     { return new TileInfo(this.pos.add(offset), this.size, this.textureIndex); }
 
     /** Returns a copy of this tile offset by a number of animation frames
-    *  @param {Number} frame - Offset to apply in animation frames
+    *  @param {number} frame - Offset to apply in animation frames
     *  @return {TileInfo}
     */
     frame(frame)
@@ -203,11 +203,11 @@ function getCameraSize() { return mainCanvasSize.scale(1/cameraScale); }
  *  @param {Vector2} [size=(1,1)]               - Size of the tile in world space
  *  @param {TileInfo}[tileInfo]                 - Tile info to use, untextured if undefined
  *  @param {Color}   [color=(1,1,1,1)]          - Color to modulate with
- *  @param {Number}  [angle]                    - Angle to rotate by
- *  @param {Boolean} [mirror]                   - If true image is flipped along the Y axis
+ *  @param {number}  [angle]                    - Angle to rotate by
+ *  @param {boolean} [mirror]                   - If true image is flipped along the Y axis
  *  @param {Color}   [additiveColor=(0,0,0,0)]  - Additive color to be applied
- *  @param {Boolean} [useWebGL=glEnable]        - Use accelerated WebGL rendering
- *  @param {Boolean} [screenSpace=false]        - If true the pos and size are in screen space
+ *  @param {boolean} [useWebGL=glEnable]        - Use accelerated WebGL rendering
+ *  @param {boolean} [screenSpace=false]        - If true the pos and size are in screen space
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context] - Canvas 2D context to draw to
  *  @memberof Draw */
 function drawTile(pos, size=vec2(1), tileInfo, color=new Color,
@@ -282,9 +282,9 @@ function drawTile(pos, size=vec2(1), tileInfo, color=new Color,
  *  @param {Vector2} pos
  *  @param {Vector2} [size=(1,1)]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [angle]
- *  @param {Boolean} [useWebGL=glEnable]
- *  @param {Boolean} [screenSpace=false]
+ *  @param {number}  [angle]
+ *  @param {boolean} [useWebGL=glEnable]
+ *  @param {boolean} [screenSpace=false]
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context]
  *  @memberof Draw */
 function drawRect(pos, size, color, angle, useWebGL, screenSpace, context)
@@ -295,10 +295,10 @@ function drawRect(pos, size, color, angle, useWebGL, screenSpace, context)
 /** Draw colored line between two points
  *  @param {Vector2} posA
  *  @param {Vector2} posB
- *  @param {Number}  [thickness]
+ *  @param {number}  [thickness]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Boolean} [useWebGL=glEnable]
- *  @param {Boolean} [screenSpace=false]
+ *  @param {boolean} [useWebGL=glEnable]
+ *  @param {boolean} [screenSpace=false]
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context]
  *  @memberof Draw */
 function drawLine(posA, posB, thickness=.1, color, useWebGL, screenSpace, context)
@@ -309,11 +309,11 @@ function drawLine(posA, posB, thickness=.1, color, useWebGL, screenSpace, contex
 }
 
 /** Draw colored polygon using passed in points
- *  @param {Array}   points - Array of Vector2 points
+ *  @param {Array<Vector2>}   points - Array of Vector2 points
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [lineWidth=0]
+ *  @param {number}  [lineWidth=0]
  *  @param {Color}   [lineColor=(0,0,0,1)]
- *  @param {Boolean} [screenSpace=false]
+ *  @param {boolean} [screenSpace=false]
  *  @param {CanvasRenderingContext2D} [context=mainContext]
  *  @memberof Draw */
 function drawPoly(points, color=new Color, lineWidth=0, lineColor=new Color(0,0,0), screenSpace, context=mainContext)
@@ -335,13 +335,13 @@ function drawPoly(points, color=new Color, lineWidth=0, lineColor=new Color(0,0,
 
 /** Draw colored ellipse using passed in point
  *  @param {Vector2} pos
- *  @param {Number}  [width=1]
- *  @param {Number}  [height=1]
- *  @param {Number}  [angle=0]
+ *  @param {number}  [width=1]
+ *  @param {number}  [height=1]
+ *  @param {number}  [angle=0]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [lineWidth=0]
+ *  @param {number}  [lineWidth=0]
  *  @param {Color}   [lineColor=(0,0,0,1)]
- *  @param {Boolean} [screenSpace=false]
+ *  @param {boolean} [screenSpace=false]
  *  @param {CanvasRenderingContext2D} [context=mainContext]
  *  @memberof Draw */
 function drawEllipse(pos, width=1, height=1, angle=0, color=new Color, lineWidth=0, lineColor=new Color(0,0,0), screenSpace, context=mainContext)
@@ -368,11 +368,11 @@ function drawEllipse(pos, width=1, height=1, angle=0, color=new Color, lineWidth
 
 /** Draw colored circle using passed in point
  *  @param {Vector2} pos
- *  @param {Number}  [radius=1]
+ *  @param {number}  [radius=1]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [lineWidth=0]
+ *  @param {number}  [lineWidth=0]
  *  @param {Color}   [lineColor=(0,0,0,1)]
- *  @param {Boolean} [screenSpace=false]
+ *  @param {boolean} [screenSpace=false]
  *  @param {CanvasRenderingContext2D} [context=mainContext]
  *  @memberof Draw */
 function drawCircle(pos, radius=1, color=new Color, lineWidth=0, lineColor=new Color(0,0,0), screenSpace, context=mainContext)
@@ -381,10 +381,10 @@ function drawCircle(pos, radius=1, color=new Color, lineWidth=0, lineColor=new C
 /** Draw directly to a 2d canvas context in world space
  *  @param {Vector2}  pos
  *  @param {Vector2}  size
- *  @param {Number}   angle
- *  @param {Boolean}  mirror
+ *  @param {number}   angle
+ *  @param {boolean}  mirror
  *  @param {Function} drawFunction
- *  @param {Boolean} [screenSpace=false]
+ *  @param {boolean} [screenSpace=false]
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=mainContext]
  *  @memberof Draw */
 function drawCanvas2D(pos, size, angle, mirror, drawFunction, screenSpace, context=mainContext)
@@ -405,15 +405,15 @@ function drawCanvas2D(pos, size, angle, mirror, drawFunction, screenSpace, conte
 
 /** Draw text on main canvas in world space
  *  Automatically splits new lines into rows
- *  @param {String}  text
+ *  @param {string}  text
  *  @param {Vector2} pos
- *  @param {Number}  [size]
+ *  @param {number}  [size]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [lineWidth]
+ *  @param {number}  [lineWidth]
  *  @param {Color}   [lineColor=(0,0,0,1)]
  *  @param {CanvasTextAlign}  [textAlign='center']
- *  @param {String}  [font=fontDefault]
- *  @param {Number}  [maxWidth]
+ *  @param {string}  [font=fontDefault]
+ *  @param {number}  [maxWidth]
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=mainContext]
  *  @memberof Draw */
 function drawText(text, pos, size=1, color, lineWidth=0, lineColor, textAlign, font, maxWidth, context=mainContext)
@@ -423,15 +423,15 @@ function drawText(text, pos, size=1, color, lineWidth=0, lineColor, textAlign, f
 
 /** Draw text on overlay canvas in world space
  *  Automatically splits new lines into rows
- *  @param {String}  text
+ *  @param {string}  text
  *  @param {Vector2} pos
- *  @param {Number}  [size]
+ *  @param {number}  [size]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [lineWidth]
+ *  @param {number}  [lineWidth]
  *  @param {Color}   [lineColor=(0,0,0,1)]
  *  @param {CanvasTextAlign}  [textAlign='center']
- *  @param {String}  [font=fontDefault]
- *  @param {Number}  [maxWidth]
+ *  @param {string}  [font=fontDefault]
+ *  @param {number}  [maxWidth]
  *  @memberof Draw */
 function drawTextOverlay(text, pos, size=1, color, lineWidth=0, lineColor, textAlign, font, maxWidth)
 {
@@ -440,15 +440,15 @@ function drawTextOverlay(text, pos, size=1, color, lineWidth=0, lineColor, textA
 
 /** Draw text on overlay canvas in screen space
  *  Automatically splits new lines into rows
- *  @param {String}  text
+ *  @param {string}  text
  *  @param {Vector2} pos
- *  @param {Number}  [size]
+ *  @param {number}  [size]
  *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Number}  [lineWidth]
+ *  @param {number}  [lineWidth]
  *  @param {Color}   [lineColor=(0,0,0,1)]
  *  @param {CanvasTextAlign}  [textAlign]
- *  @param {String}  [font=fontDefault]
- *  @param {Number}  [maxWidth]
+ *  @param {string}  [font=fontDefault]
+ *  @param {number}  [maxWidth]
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=overlayContext]
  *  @memberof Draw */
 function drawTextScreen(text, pos, size=1, color=new Color, lineWidth=0, lineColor=new Color(0,0,0), textAlign='center', font=fontDefault, maxWidth=undefined, context=overlayContext)
@@ -474,8 +474,8 @@ function drawTextScreen(text, pos, size=1, color=new Color, lineWidth=0, lineCol
 }
 
 /** Enable normal or additive blend mode
- *  @param {Boolean} [additive]
- *  @param {Boolean} [useWebGL=glEnable]
+ *  @param {boolean} [additive]
+ *  @param {boolean} [useWebGL=glEnable]
  *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=mainContext]
  *  @memberof Draw */
 function setBlendMode(additive, useWebGL=glEnable, context)
@@ -542,10 +542,10 @@ class FontImage
     }
 
     /** Draw text in world space using the image font
-     *  @param {String}  text
+     *  @param {string}  text
      *  @param {Vector2} pos
-     *  @param {Number}  [scale=.25]
-     *  @param {Boolean} [center]
+     *  @param {number}  [scale=.25]
+     *  @param {boolean} [center]
      */
     drawText(text, pos, scale=1, center)
     {
@@ -553,10 +553,10 @@ class FontImage
     }
 
     /** Draw text in screen space using the image font
-     *  @param {String}  text
+     *  @param {string}  text
      *  @param {Vector2} pos
-     *  @param {Number}  [scale]
-     *  @param {Boolean} [center]
+     *  @param {number}  [scale]
+     *  @param {boolean} [center]
      */
     drawTextScreen(text, pos, scale=4, center)
     {
@@ -594,7 +594,7 @@ class FontImage
 // Display functions
 
 /** Returns true if fullscreen mode is active
- *  @return {Boolean}
+ *  @return {boolean}
  *  @memberof Draw */
 function isFullscreen() { return !!document.fullscreenElement; }
 
@@ -613,7 +613,7 @@ function toggleFullscreen()
 }
 
 /** Set the cursor style
- *  @param {String}  cursorStyle - CSS cursor style (auto, none, crosshair, etc)
+ *  @param {string}  cursorStyle - CSS cursor style (auto, none, crosshair, etc)
  *  @memberof Draw */
 function setCursor(cursorStyle = 'auto')
 {

package/src/engineExport.js

@@ -3,8 +3,8 @@
  * - Export engine as a module
  */
 
-export {
-
+export
+{
 	// Engine
 	engineName,
 	engineVersion,

package/src/engineInput.js

@@ -11,9 +11,9 @@
 'use strict';
 
 /** Returns true if device key is down
- *  @param {String|Number} key
- *  @param {Number} [device]
- *  @return {Boolean}
+ *  @param {string|number} key
+ *  @param {number} [device]
+ *  @return {boolean}
  *  @memberof Input */
 function keyIsDown(key, device=0)
 { 
@@ -22,9 +22,9 @@ function keyIsDown(key, device=0)
 }
 
 /** Returns true if device key was pressed this frame
- *  @param {String|Number} key
- *  @param {Number} [device]
- *  @return {Boolean}
+ *  @param {string|number} key
+ *  @param {number} [device]
+ *  @return {boolean}
  *  @memberof Input */
 function keyWasPressed(key, device=0)
 { 
@@ -33,9 +33,9 @@ function keyWasPressed(key, device=0)
 }
 
 /** Returns true if device key was released this frame
- *  @param {String|Number} key
- *  @param {Number} [device]
- *  @return {Boolean}
+ *  @param {string|number} key
+ *  @param {number} [device]
+ *  @return {boolean}
  *  @memberof Input */
 function keyWasReleased(key, device=0)
 { 
@@ -58,22 +58,22 @@ function clearInput() { inputData = [[]]; touchGamepadButtons = []; }
 
 /** Returns true if mouse button is down
  *  @function
- *  @param {Number} button
- *  @return {Boolean}
+ *  @param {number} button
+ *  @return {boolean}
  *  @memberof Input */
 const mouseIsDown = keyIsDown;
 
 /** Returns true if mouse button was pressed
  *  @function
- *  @param {Number} button
- *  @return {Boolean}
+ *  @param {number} button
+ *  @return {boolean}
  *  @memberof Input */
 const mouseWasPressed = keyWasPressed;
 
 /** Returns true if mouse button was released
  *  @function
- *  @param {Number} button
- *  @return {Boolean}
+ *  @param {number} button
+ *  @return {boolean}
  *  @memberof Input */
 const mouseWasReleased = keyWasReleased;
 
@@ -88,47 +88,47 @@ let mousePos = vec2();
 let mousePosScreen = vec2();
 
 /** Mouse wheel delta this frame
- *  @type {Number}
+ *  @type {number}
  *  @memberof Input */
 let mouseWheel = 0;
 
 /** Returns true if user is using gamepad (has more recently pressed a gamepad button)
- *  @type {Boolean}
+ *  @type {boolean}
  *  @memberof Input */
 let isUsingGamepad = false;
 
 /** Prevents input continuing to the default browser handling (false by default)
- *  @type {Boolean}
+ *  @type {boolean}
  *  @memberof Input */
 let preventDefaultInput = false;
 
 /** Returns true if gamepad button is down
- *  @param {Number} button
- *  @param {Number} [gamepad]
- *  @return {Boolean}
+ *  @param {number} button
+ *  @param {number} [gamepad]
+ *  @return {boolean}
  *  @memberof Input */
 function gamepadIsDown(button, gamepad=0)
 { return keyIsDown(button, gamepad+1); }
 
 /** Returns true if gamepad button was pressed
- *  @param {Number} button
- *  @param {Number} [gamepad]
- *  @return {Boolean}
+ *  @param {number} button
+ *  @param {number} [gamepad]
+ *  @return {boolean}
  *  @memberof Input */
 function gamepadWasPressed(button, gamepad=0)
 { return keyWasPressed(button, gamepad+1); }
 
 /** Returns true if gamepad button was released
- *  @param {Number} button
- *  @param {Number} [gamepad]
- *  @return {Boolean}
+ *  @param {number} button
+ *  @param {number} [gamepad]
+ *  @return {boolean}
  *  @memberof Input */
 function gamepadWasReleased(button, gamepad=0)
 { return keyWasReleased(button, gamepad+1); }
 
 /** Returns gamepad stick value
- *  @param {Number} stick
- *  @param {Number} [gamepad]
+ *  @param {number} stick
+ *  @param {number} [gamepad]
  *  @return {Vector2}
  *  @memberof Input */
 function gamepadStick(stick,  gamepad=0)
@@ -331,7 +331,7 @@ function gamepadsUpdate()
 ///////////////////////////////////////////////////////////////////////////////
 
 /** Pulse the vibration hardware if it exists
- *  @param {Number|Array} [pattern] - single value in ms or vibration interval array
+ *  @param {number|Array} [pattern] - single value in ms or vibration interval array
  *  @memberof Input */
 function vibrate(pattern=100)
 { vibrateEnable && !headlessMode && navigator && navigator.vibrate && navigator.vibrate(pattern); }

package/src/engineMedals.js

@@ -104,7 +104,7 @@ class Medal
         /** @property {String} - Icon for the medal */
         this.icon = icon;
         
-        /** @property {Boolean} - Is the medal unlocked? */
+        /** @property {boolean} - Is the medal unlocked? */
         this.unlocked = false;
 
         // load the source image if provided

package/src/engineObject.js

@@ -35,9 +35,9 @@ class EngineObject
      *  @param {Vector2}  [pos=(0,0)]       - World space position of the object
      *  @param {Vector2}  [size=(1,1)]      - World space size of the object
      *  @param {TileInfo} [tileInfo]        - Tile info to render object (undefined is untextured)
-     *  @param {Number}   [angle]           - Angle the object is rotated by
+     *  @param {number}   [angle]           - Angle the object is rotated by
      *  @param {Color}    [color=(1,1,1,1)] - Color to apply to tile when rendered
-     *  @param {Number}   [renderOrder]     - Objects sorted by renderOrder before being rendered
+     *  @param {number}   [renderOrder]     - Objects sorted by renderOrder before being rendered
      */
     constructor(pos=vec2(), size=vec2(1), tileInfo, angle=0, color=new Color, renderOrder=0)
     {
@@ -53,57 +53,59 @@ class EngineObject
         this.drawSize = undefined;
         /** @property {TileInfo} - Tile info to render object (undefined is untextured) */
         this.tileInfo = tileInfo;
-        /** @property {Number}  - Angle to rotate the object */
+        /** @property {number}  - Angle to rotate the object */
         this.angle = angle;
         /** @property {Color}   - Color to apply when rendered */
         this.color = color;
         /** @property {Color}   - Additive color to apply when rendered */
         this.additiveColor = undefined;
-        /** @property {Boolean} - Should it flip along y axis when rendered */
+        /** @property {boolean} - Should it flip along y axis when rendered */
         this.mirror = false;
 
         // physical properties
-        /** @property {Number} [mass=objectDefaultMass]                 - How heavy the object is, static if 0 */
+        /** @property {number} [mass=objectDefaultMass]                 - How heavy the object is, static if 0 */
         this.mass         = objectDefaultMass;
-        /** @property {Number} [damping=objectDefaultDamping]           - How much to slow down velocity each frame (0-1) */
+        /** @property {number} [damping=objectDefaultDamping]           - How much to slow down velocity each frame (0-1) */
         this.damping      = objectDefaultDamping;
-        /** @property {Number} [angleDamping=objectDefaultAngleDamping] - How much to slow down rotation each frame (0-1) */
+        /** @property {number} [angleDamping=objectDefaultAngleDamping] - How much to slow down rotation each frame (0-1) */
         this.angleDamping = objectDefaultAngleDamping;
-        /** @property {Number} [elasticity=objectDefaultElasticity]     - How bouncy the object is when colliding (0-1) */
+        /** @property {number} [elasticity=objectDefaultElasticity]     - How bouncy the object is when colliding (0-1) */
         this.elasticity   = objectDefaultElasticity;
-        /** @property {Number} [friction=objectDefaultFriction]         - How much friction to apply when sliding (0-1) */
+        /** @property {number} [friction=objectDefaultFriction]         - How much friction to apply when sliding (0-1) */
         this.friction     = objectDefaultFriction;
-        /** @property {Number}  - How much to scale gravity by for this object */
+        /** @property {number}  - How much to scale gravity by for this object */
         this.gravityScale = 1;
-        /** @property {Number}  - Objects are sorted by render order */
+        /** @property {number}  - Objects are sorted by render order */
         this.renderOrder = renderOrder;
         /** @property {Vector2} - Velocity of the object */
         this.velocity = vec2();
-        /** @property {Number}  - Angular velocity of the object */
+        /** @property {number}  - Angular velocity of the object */
         this.angleVelocity = 0;
-        /** @property {Number}  - Track when object was created  */
+        /** @property {number}  - Track when object was created  */
         this.spawnTime = time;
-        /** @property {Array}   - List of children of this object */
+        /** @property {Array<EngineObject>}   - List of children of this object */
         this.children = [];
-        /** @property {Boolean}  - Limit object speed using linear or circular math */
+        /** @property {boolean}  - Limit object speed using linear or circular math */
         this.clampSpeedLinear = true;
+        /** @property {EngineObject} - Object we are standing on, if any  */
+        this.groundObject = undefined;
 
         // parent child system
         /** @property {EngineObject} - Parent of object if in local space  */
         this.parent = undefined;
         /** @property {Vector2}      - Local position if child */
         this.localPos = vec2();
-        /** @property {Number}       - Local angle if child  */
+        /** @property {number}       - Local angle if child  */
         this.localAngle = 0;
 
         // collision flags
-        /** @property {Boolean} - Object collides with the tile collision */
+        /** @property {boolean} - Object collides with the tile collision */
         this.collideTiles = false;
-        /** @property {Boolean} - Object collides with solid objects */
+        /** @property {boolean} - Object collides with solid objects */
         this.collideSolidObjects = false;
-        /** @property {Boolean} - Object collides with and blocks other objects */
+        /** @property {boolean} - Object collides with and blocks other objects */
         this.isSolid = false;
-        /** @property {Boolean} - Object collides with raycasts */
+        /** @property {boolean} - Object collides with raycasts */
         this.collideRaycast = false;
 
         // add to list of objects
@@ -173,7 +175,7 @@ class EngineObject
             // apply friction in local space of ground object
             const groundSpeed = this.groundObject.velocity ? this.groundObject.velocity.x : 0;
             this.velocity.x = groundSpeed + (this.velocity.x - groundSpeed) * this.friction;
-            this.groundObject = 0;
+            this.groundObject = undefined;
             //debugOverlay && debugPhysics && debugPoint(this.pos.subtract(vec2(0,this.size.y/2)), '#0f0');
         }
 
@@ -290,18 +292,21 @@ class EngineObject
                         // bounce velocity
                         this.velocity.y *= -this.elasticity;
 
-                        // set if landed on ground
-                        if (this.groundObject = wasMovingDown)
+                        if (wasMovingDown)
                         {
                             // adjust position to slightly above nearest tile boundary
                             // this prevents gap between object and ground
                             const epsilon = .0001;
                             this.pos.y = (oldPos.y-this.size.y/2|0)+this.size.y/2+epsilon;
+
+                            // set ground object to self for tile collision
+                            this.groundObject = this;
                         }
                         else
                         {
                             // move to previous position
                             this.pos.y = oldPos.y;
+                            this.groundObject = undefined; 
                         }
                     }
                     if (isBlockedX)
@@ -353,19 +358,19 @@ class EngineObject
     worldToLocalVector(vec) { return vec.rotate(-this.angle); }
     
     /** Called to check if a tile collision should be resolved
-     *  @param {Number}  tileData - the value of the tile at the position
+     *  @param {number}  tileData - the value of the tile at the position
      *  @param {Vector2} pos      - tile where the collision occurred
-     *  @return {Boolean}         - true if the collision should be resolved */
+     *  @return {boolean}         - true if the collision should be resolved */
     collideWithTile(tileData, pos)    { return tileData > 0; }
 
     /** Called to check if a object collision should be resolved
      *  @param {EngineObject} object - the object to test against
-     *  @return {Boolean}            - true if the collision should be resolved
+     *  @return {boolean}            - true if the collision should be resolved
      */
     collideWithObject(object)         { return true; }
 
     /** How long since the object was created
-     *  @return {Number} */
+     *  @return {number} */
     getAliveTime()                    { return time - this.spawnTime; }
 
     /** Apply acceleration to this object (adjust velocity, not affected by mass)
@@ -377,13 +382,13 @@ class EngineObject
     applyForce(force)	              { this.applyAcceleration(force.scale(1/this.mass)); }
     
     /** Get the direction of the mirror
-     *  @return {Number} -1 if this.mirror is true, or 1 if not mirrored */
+     *  @return {number} -1 if this.mirror is true, or 1 if not mirrored */
     getMirrorSign() { return this.mirror ? -1 : 1; }
 
     /** Attaches a child to this with a given local transform
      *  @param {EngineObject} child
      *  @param {Vector2}      [localPos=(0,0)]
-     *  @param {Number}       [localAngle] */
+     *  @param {number}       [localAngle] */
     addChild(child, localPos=vec2(), localAngle=0)
     {
         ASSERT(!child.parent && !this.children.includes(child));
@@ -403,10 +408,10 @@ class EngineObject
     }
 
     /** Set how this object collides
-     *  @param {Boolean} [collideSolidObjects] - Does it collide with solid objects?
-     *  @param {Boolean} [isSolid]             - Does it collide with and block other objects? (expensive in large numbers)
-     *  @param {Boolean} [collideTiles]        - Does it collide with the tile collision?
-     *  @param {Boolean} [collideRaycast]      - Does it collide with raycasts? */
+     *  @param {boolean} [collideSolidObjects] - Does it collide with solid objects?
+     *  @param {boolean} [isSolid]             - Does it collide with and block other objects? (expensive in large numbers)
+     *  @param {boolean} [collideTiles]        - Does it collide with the tile collision?
+     *  @param {boolean} [collideRaycast]      - Does it collide with raycasts? */
     setCollision(collideSolidObjects=true, isSolid=true, collideTiles=true, collideRaycast=true)
     {
         ASSERT(collideSolidObjects || !isSolid, 'solid objects must be set to collide');
@@ -418,7 +423,7 @@ class EngineObject
     }
 
     /** Returns string containing info about this object for debugging
-     *  @return {String} */
+     *  @return {string} */
     toString()
     {
         if (debug)