littlejsengine 1.2.3 → 1.3.3

package/engine/engineDraw.js

@@ -110,7 +110,7 @@ function drawTile(pos, size=vec2(1), tileIndex=-1, tileSize=tileSizeDefault, col
             if (tileIndex < 0)
             {
                 // if negative tile index, force untextured
-                context.fillStyle = color.rgba();
+                context.fillStyle = color;
                 context.fillRect(-.5, -.5, 1, 1);
             }
             else
@@ -165,7 +165,7 @@ function drawTileScreenSpace(pos, size=vec2(1), tileIndex, tileSize, color, angl
  *  @memberof Draw */
 function drawRectScreenSpace(pos, size, color, angle, useWebGL)
 {
-    drawTileSrceenSpace(pos, size, -1, tileSizeDefault, color, angle, 0, 0, useWebGL);
+    drawTileScreenSpace(pos, size, -1, tileSizeDefault, color, angle, 0, 0, useWebGL);
 }
 
 /** Draw colored line between two points
@@ -215,7 +215,8 @@ function setBlendMode(additive, useWebGL=glEnable)
         mainContext.globalCompositeOperation = additive ? 'lighter' : 'source-over';
 }
 
-/** Draw text on overlay canvas in world space
+/** Draw text on overlay canvas in screen space
+ *  Automatically splits new lines into rows
  *  @param {String}  text
  *  @param {Vector2} pos
  *  @param {Number}  [size=1]
@@ -224,20 +225,38 @@ function setBlendMode(additive, useWebGL=glEnable)
  *  @param {Color}   [lineColor=new Color(0,0,0)]
  *  @param {String}  [textAlign='center']
  *  @memberof Draw */
-function drawText(text, pos, size=1, color=new Color, lineWidth=0, lineColor=new Color(0,0,0), textAlign='center', font=fontDefault)
+function drawTextScreen(text, pos, size=1, color=new Color, lineWidth=0, lineColor=new Color(0,0,0), textAlign='center', font=fontDefault)
 {
-    pos = worldToScreen(pos);
-    overlayContext.font = size*cameraScale + 'px '+ font;
+    overlayContext.fillStyle = color;
+    overlayContext.lineWidth = lineWidth;
+    overlayContext.strokeStyle = lineColor;
     overlayContext.textAlign = textAlign;
+    overlayContext.font = size + 'px '+ font;
     overlayContext.textBaseline = 'middle';
-    if (lineWidth)
+    overlayContext.lineJoin = 'round';
+
+    pos = pos.copy();
+    text.split('\n').forEach(line=>
     {
-        overlayContext.lineWidth = lineWidth*cameraScale;
-        overlayContext.strokeStyle = lineColor.rgba();
-        overlayContext.strokeText(text, pos.x, pos.y);
-    }
-    overlayContext.fillStyle = color.rgba();
-    overlayContext.fillText(text, pos.x, pos.y);
+        lineWidth && overlayContext.strokeText(line, pos.x, pos.y);
+        overlayContext.fillText(line, pos.x, pos.y);
+        pos.y += size;
+    });
+}
+
+/** Draw text on overlay canvas in world space
+ *  Automatically splits new lines into rows
+ *  @param {String}  text
+ *  @param {Vector2} pos
+ *  @param {Number}  [size=1]
+ *  @param {Color}   [color=new Color(1,1,1)]
+ *  @param {Number}  [lineWidth=0]
+ *  @param {Color}   [lineColor=new Color(0,0,0)]
+ *  @param {String}  [textAlign='center']
+ *  @memberof Draw */
+function drawText(text, pos, size=1, color, lineWidth, lineColor, textAlign, font)
+{
+    drawTextScreen(text, worldToScreen(pos), size*cameraScale, color, lineWidth*cameraScale, lineColor, textAlign, font);
 }
 
 ///////////////////////////////////////////////////////////////////////////////

package/engine/engineInput.js

@@ -70,6 +70,10 @@ let mouseWheel = 0;
  *  @memberof Input */
 let isUsingGamepad = 0;
 
+/** Prevents input continuing to the default browser handling (false by default)
+ *  @memberof Input */
+let preventDefaultInput = 0;
+
 /** Returns true if gamepad button is down
  *  @param {Number} button
  *  @param {Number} [gamepad=0]
@@ -133,7 +137,7 @@ onkeydown = (e)=>
 {
     if (debug && e.target != document.body) return;
     e.repeat || (inputData[isUsingGamepad = 0][remapKeyCode(e.keyCode)] = 3);
-    debug || e.preventDefault();
+    preventDefaultInput && e.preventDefault();
 }
 onkeyup = (e)=>
 {

package/engine/engineMedals.js

@@ -35,7 +35,7 @@ function medalsInit(saveName)
 {
     // check if medals are unlocked
     medalsSaveName = saveName;
-    debugMedals || medals.forEach(medal=> medal.unlocked = 1 || localStorage[medal.storageKey()]);
+    debugMedals || medals.forEach(medal=> localStorage[medal.storageKey()]);
 }
 
 /** 
@@ -192,7 +192,7 @@ class Newgrounds
         cipher && (this.cryptoJS = CryptoJS());
 
         // get session id from url search params
-        const url = new URL(window.location.href);
+        const url = new URL(location.href);
         this.session_id = url.searchParams.get('ngio_session_id') || 0;
 
         if (this.session_id == 0)
@@ -224,6 +224,9 @@ class Newgrounds
         const scoreboardResult = this.call('ScoreBoard.getBoards');
         this.scoreboards = scoreboardResult ? scoreboardResult.result.data.scoreboards : [];
         debugMedals && console.log(this.scoreboards);
+
+        const keepAliveMS = 5 * 60 * 1e3;
+        setInterval(()=>this.call('Gateway.ping', 0, 1), keepAliveMS);
     }
 
     /** Send message to unlock a medal by id

package/engine/engineObject.js

@@ -34,9 +34,9 @@ class EngineObject
     /** Create an engine object and adds it to the list of objects
      *  @param {Vector2} [position=new Vector2()]    - World space position of the object
      *  @param {Vector2} [size=objectDefaultSize]    - World space size of the object
-     *  @param {Number}  [tileIndex=-1]              - Tile to use to render object, untextured if -1
+     *  @param {Number}  [tileIndex=-1]              - Tile to use to render object (-1 is untextured)
      *  @param {Vector2} [tileSize=tileSizeDefault]  - Size of tile in source pixels
-     *  @param {Number}  [angle=0]                   - Angle to rotate the object
+     *  @param {Number}  [angle=0]                   - Angle the object is rotated by
      *  @param {Color}   [color]                     - Color to apply to tile when rendered
      *  @param {Number}  [renderOrder=0]             - Objects sorted by renderOrder before being rendered
      */
@@ -51,7 +51,7 @@ class EngineObject
         this.size = size;
         /** @property {Vector2} - Size of object used for drawing, uses size if not set */
         this.drawSize;
-        /** @property {Number}  - Tile to use to render object, untextured if -1 */
+        /** @property {Number}  - Tile to use to render object (-1 is untextured) */
         this.tileIndex = tileIndex;
         /** @property {Vector2} - Size of tile in source pixels */
         this.tileSize = tileSize;
@@ -63,7 +63,7 @@ class EngineObject
         this.additiveColor;
 
         // set object defaults
-        /** @property {Number} [mass=objectDefaultMass]                 - How heavy the object is */
+        /** @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) */
         this.damping      = objectDefaultDamping;
@@ -117,7 +117,7 @@ class EngineObject
         ASSERT(this.angleDamping >= 0 && this.angleDamping <= 1);
         ASSERT(this.damping >= 0 && this.damping <= 1);
 
-        if (!this.mass) // do not update collision for fixed objects
+        if (!enablePhysicsSolver || !this.mass) // do not update collision for fixed objects
             return;
 
         const wasMovingDown = this.velocity.y < 0;
@@ -352,4 +352,23 @@ class EngineObject
         this.isSolid = isSolid;
         this.collideTiles = collideTiles;
     }
+
+    toString()
+    {
+        if (debug)
+        {
+            let text = 'type = ' + this.constructor.name;
+            if (this.pos.x || this.pos.y)
+                text += '\npos = ' + this.pos;
+            if (this.velocity.x || this.velocity.y)
+                text += '\nvelocity = ' + this.velocity;
+            if (this.size.x || this.size.y)
+                text += '\nsize = ' + this.size;
+            if (this.angle)
+                text += '\nangle = ' + this.angle.toFixed(3);
+            if (this.color)
+                text += '\ncolor = ' + this.color;
+            return text;
+        }
+    }
 }

package/engine/engineParticles.js

@@ -28,7 +28,7 @@ class ParticleEmitter extends EngineObject
 {
     /** Create a particle system with the given settings
      *  @param {Vector2} position           - World space position of the emitter
-     *  @param {Number}  [angle=0]          - Angle to rotate the object
+     *  @param {Number}  [angle=0]          - Angle to emit the particles
      *  @param {Number}  [emitSize=0]       - World space size of the emitter (float for circle diameter, vec2 for rect)
      *  @param {Number}  [emitTime=0]       - How long to stay alive (0 is forever)
      *  @param {Number}  [emitRate=100]     - How many particles per second to spawn, does not emit if 0
@@ -113,7 +113,7 @@ class ParticleEmitter extends EngineObject
         // particle settings
         /** @property {Number} - How long particles live */
         this.particleTime      = particleTime;
-        /** @property {Number} -  How big are particles at start */
+        /** @property {Number} - How big are particles at start */
         this.sizeStart         = sizeStart;
         /** @property {Number} - How big are particles at end */
         this.sizeEnd           = sizeEnd;

package/engine/engineSettings.js

@@ -53,6 +53,11 @@ let tileFixBleedScale = .3;
  *  @memberof Settings */
 let objectDefaultSize = vec2(1);
 
+/** Enable physics solver for collisions between objects
+ *  @default
+ *  @memberof Settings */
+let enablePhysicsSolver = 1;
+
 /** Default object mass for collison calcuations (how heavy objects are)
  *  @default
  *  @memberof Settings */

package/engine/engineTileLayer.js

@@ -153,14 +153,14 @@ class TileLayerData
  */
 class TileLayer extends EngineObject
 {
-    /** Create a tile layer object
-     *  @param {Vector2} [position=new Vector2()]   - World space position
-     *  @param {Vector2} [size=objectDefaultSize]   - World space size
-     *  @param {Vector2} [tileSize=tileSizeDefault] - Size of tiles in source pixels
-     *  @param {Vector2} [scale=new Vector2(1,1)]   - How much to scale this layer when rendered
-     *  @param {Number}  [renderOrder=0]            - Objects sorted by renderOrder before being rendered
-     */
-    constructor(pos, size=tileCollisionSize, tileSize=tileSizeDefault, scale=vec2(1), renderOrder=0)
+/** Create a tile layer object
+    *  @param {Vector2} [position=new Vector2()]   - World space position
+    *  @param {Vector2} [size=tileCollisionSize]   - World space size
+    *  @param {Vector2} [tileSize=tileSizeDefault] - Size of tiles in source pixels
+    *  @param {Vector2} [scale=new Vector2(1,1)]   - How much to scale this layer when rendered
+    *  @param {Number}  [renderOrder=0]            - Objects sorted by renderOrder before being rendered
+    */
+constructor(pos, size=tileCollisionSize, tileSize=tileSizeDefault, scale=vec2(1), renderOrder=0)
     {
         super(pos, size, -1, tileSize, 0, undefined, renderOrder);
 
@@ -320,7 +320,7 @@ class TileLayer extends EngineObject
             if (tileIndex < 0)
             {
                 // untextured
-                context.fillStyle = color.rgba();
+                context.fillStyle = color;
                 context.fillRect(-.5, -.5, 1, 1);
             }
             else
@@ -339,5 +339,6 @@ class TileLayer extends EngineObject
      *  @param {Vector2} [size=new Vector2(1,1)]
      *  @param {Color}   [color=new Color(1,1,1)]
      *  @param {Number}  [angle=0] */
-    drawRect(pos, size, color, angle) { this.drawTile(pos, size, -1, 0, color, angle); }
+    drawRect(pos, size, color, angle) 
+    { this.drawTile(pos, size, -1, 0, color, angle); }
 }

package/engine/engineUtilities.js

@@ -300,7 +300,7 @@ class Vector2
 
     /** Returns the area this vector covers as a rectangle
      * @return {Number} */
-    area() { return this.x * this.y; }
+    area() { return abs(this.x * this.y); }
 
     /** Returns a new vector that is p percent between this and the vector passed in
      * @param {Vector2} vector
@@ -311,7 +311,13 @@ class Vector2
     /** Returns true if this vector is within the bounds of an array size passed in
      * @param {Vector2} arraySize
      * @return {Boolean} */
-    arrayCheck(arraySize) { return this.x >= 0 && this.y >= 0 && this.x < arraySize.x && this.y < arraySize.y; } 
+    arrayCheck(arraySize) { return this.x >= 0 && this.y >= 0 && this.x < arraySize.x && this.y < arraySize.y; }
+
+    /** Returns this vector expressed as a string
+     * @param {float} digits - precision to display
+     * @return {String} */
+    toString(digits=3) 
+    { return `(${(this.x<0?'':' ') + this.x.toFixed(digits)},${(this.y<0?'':' ') + this.y.toFixed(digits)} )`; }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -382,7 +388,7 @@ class Color
      * @return {Color} */
     lerp(c, p) { return this.add(c.subtract(this).scale(clamp(p))); }
 
-    /** Sets this color given a hue, saturation, lightness , and alpha
+    /** Sets this color given a hue, saturation, lightness, and alpha
      * @param {Number} [hue=0]
      * @param {Number} [saturation=0]
      * @param {Number} [lightness=1]
@@ -418,21 +424,71 @@ class Color
         ).clamp();
     }
 
-    /** Returns this color expressed as an rgba string
+    /** Returns this color expressed as an CSS color value
      * @return {String} */
-    rgba()      
+    toString()      
     { 
         ASSERT(this.r>=0 && this.r<=1 && this.g>=0 && this.g<=1 && this.b>=0 && this.b<=1 && this.a>=0 && this.a<=1);
         return `rgb(${this.r*255|0},${this.g*255|0},${this.b*255|0},${this.a})`; 
     }
     
-    /** Returns this color expressed as 32 bit integer value
+    /** Returns this color expressed as 32 bit integer RGBA value
      * @return {Number} */
     rgbaInt()  
     {
         ASSERT(this.r>=0 && this.r<=1 && this.g>=0 && this.g<=1 && this.b>=0 && this.b<=1 && this.a>=0 && this.a<=1);
         return (this.r*255|0) + (this.g*255<<8) + (this.b*255<<16) + (this.a*255<<24); 
     }
+
+    /** Returns this color expressed as a hex code
+     * @return {String} */
+    hex()
+    {
+        const toHex = (c)=> ((c=c*255|0)<16 ? '0' : '') + c.toString(16);
+        return '#' + toHex(this.r) + toHex(this.g) + toHex(this.b);
+    }
+
+    /** Returns this color expressed in hsla format
+     * @return {Array} */
+    getHSLA()
+    {
+        const r = this.r;
+        const g = this.g;
+        const b = this.b;
+        const a = this.a;
+        const max = Math.max(r, g, b);
+        const min = Math.min(r, g, b);
+        const l = (max + min) / 2;
+        
+        let h = 0, s = 0;
+        if (max != min)
+        {
+            let d = max - min;
+            s = l > .5 ? d / (2 - max - min) : d / (max + min);
+            if (r == max)
+                h = (g - b) / d + (g < b ? 6 : 0);
+            else if (g == max)
+                h = (b - r) / d + 2;
+            else if (b == max)
+                h =  (r - g) / d + 4;
+        }
+
+        return [h / 6, s, l, a];
+    }
+
+    /** Set this color from a hex code
+     * @param {String} hex - html hex code
+     * @return {Color} */
+    setHex(hex)
+    {
+        const fromHex = (a)=> parseInt(hex.slice(a,a+2), 16)/255;
+        this.r = fromHex(1);
+        this.g = fromHex(3),
+        this.b = fromHex(5);
+        this.a = 1;
+        ASSERT(this.r>=0 && this.r<=1 && this.g>=0 && this.g<=1 && this.b>=0 && this.b<=1);
+        return this;
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -469,7 +525,7 @@ class Timer
 
     /** Returns true if set and elapsed
      * @return {Boolean} */
-    elapsed() { return time >  this.time; }
+    elapsed() { return time > this.time; }
 
     /** Get how long since elapsed, returns 0 if not set (returns negative if currently active)
      * @return {Number} */
@@ -478,4 +534,8 @@ class Timer
     /** Get percentage elapsed based on time it was set to, returns 0 if not set
      * @return {Number} */
     getPercent() { return this.isSet()? percent(this.time - time, this.setTime, 0) : 0; }
+    
+    /** Returns this timer expressed as a string
+     * @return {String} */
+    toString() { if (debug) { return this.unset() ? 'unset' : Math.abs(this.get()) + ' seconds ' + (this.get()<0 ? 'before' : 'after' ); } }
 }

package/engine/engineWebGL.js

@@ -47,7 +47,7 @@ function glInit()
 
     // setup vertex and fragment shaders
     glShader = glCreateProgram(
-        'precision highp float;'+     // use highp for better accuracy, lowp for better perf
+        'precision highp float;'+     // use highp for better accuracy
         'uniform mat4 m;'+            // transform matrix
         'attribute vec2 p,t;'+        // position, uv
         'attribute vec4 c,a;'+        // color, additiveColor
@@ -58,7 +58,7 @@ function glInit()
         'v=t;d=c;e=a;'+               // pass stuff to fragment shader
         '}'                           // end of shader
         ,
-        'precision highp float;'+           // use highp for better accuracy, lowp for better perf
+        'precision highp float;'+           // use highp for better accuracy
         'varying vec2 v;'+                  // uv
         'varying vec4 d,e;'+                // color, additiveColor
         'uniform sampler2D s;'+             // texture
@@ -244,7 +244,7 @@ function glFlush()
  *  @memberof WebGL */
 function glCopyToContext(context, forceDraw)
 {
-    if (!glEnable || !glBatchCount) return;
+    if ((!glEnable || !glBatchCount) && !forceDraw) return;
     
     glFlush();
     

package/engine/index.d.ts

@@ -60,7 +60,19 @@ declare function drawCanvas2D(pos: Vector2, size: Vector2, angle: number, mirror
  *  @param {Boolean} [useWebGL=glEnable]
  *  @memberof Draw */
 declare function setBlendMode(additive?: boolean, useWebGL?: boolean): void;
+/** Draw text on overlay canvas in screen space
+ *  Automatically splits new lines into rows
+ *  @param {String}  text
+ *  @param {Vector2} pos
+ *  @param {Number}  [size=1]
+ *  @param {Color}   [color=new Color(1,1,1)]
+ *  @param {Number}  [lineWidth=0]
+ *  @param {Color}   [lineColor=new Color(0,0,0)]
+ *  @param {String}  [textAlign='center']
+ *  @memberof Draw */
+declare function drawTextScreen(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: string, font?: string): void;
 /** Draw text on overlay canvas in world space
+ *  Automatically splits new lines into rows
  *  @param {String}  text
  *  @param {Vector2} pos
  *  @param {Number}  [size=1]
@@ -69,7 +81,7 @@ declare function setBlendMode(additive?: boolean, useWebGL?: boolean): void;
  *  @param {Color}   [lineColor=new Color(0,0,0)]
  *  @param {String}  [textAlign='center']
  *  @memberof Draw */
-declare function drawText(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: string, font?: string): void;
+declare function drawText(text: string, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: string, font: any): void;
 /** Toggle fullsceen mode
  *  @memberof Draw */
 declare function toggleFullscreen(): void;
@@ -551,6 +563,10 @@ declare class Vector2 {
      * @param {Vector2} arraySize
      * @return {Boolean} */
     arrayCheck(arraySize: Vector2): boolean;
+    /** Returns this vector expressed as a string
+     * @param {float} digits - precision to display
+     * @return {String} */
+    toString(digits?: float): string;
 }
 /**
  * Color object (red, green, blue, alpha) with some helpful functions
@@ -606,7 +622,7 @@ declare class Color {
      * @param {Number} percent
      * @return {Color} */
     lerp(c: any, p: any): Color;
-    /** Sets this color given a hue, saturation, lightness , and alpha
+    /** Sets this color given a hue, saturation, lightness, and alpha
      * @param {Number} [hue=0]
      * @param {Number} [saturation=0]
      * @param {Number} [lightness=1]
@@ -618,12 +634,22 @@ declare class Color {
      * @param {Number} [alphaAmount=0]
      * @return {Color} */
     mutate(amount?: number, alphaAmount?: number): Color;
-    /** Returns this color expressed as an rgba string
+    /** Returns this color expressed as an CSS color value
      * @return {String} */
-    rgba(): string;
-    /** Returns this color expressed as 32 bit integer value
+    toString(): string;
+    /** Returns this color expressed as 32 bit integer RGBA value
      * @return {Number} */
     rgbaInt(): number;
+    /** Returns this color expressed as a hex code
+     * @return {String} */
+    hex(): string;
+    /** Returns this color expressed in hsla format
+     * @return {Array} */
+    getHSLA(): any[];
+    /** Set this color from a hex code
+     * @param {String} hex - html hex code
+     * @return {Color} */
+    setHex(hex: string): Color;
 }
 /**
  * Timer object tracks how long has passed since it was set
@@ -660,6 +686,9 @@ declare class Timer {
     /** Get percentage elapsed based on time it was set to, returns 0 if not set
      * @return {Number} */
     getPercent(): number;
+    /** Returns this timer expressed as a string
+     * @return {String} */
+    toString(): string;
 }
 /** The max size of the canvas, centered if window is larger
  *  @type {Vector2}
@@ -693,6 +722,10 @@ declare let tileFixBleedScale: number;
  *  @default
  *  @memberof Settings */
 declare let objectDefaultSize: Vector2;
+/** Enable physics solver for collisions between objects
+ *  @default
+ *  @memberof Settings */
+declare let enablePhysicsSolver: number;
 /** Default object mass for collison calcuations (how heavy objects are)
  *  @default
  *  @memberof Settings */
@@ -841,9 +874,9 @@ declare class EngineObject {
     /** Create an engine object and adds it to the list of objects
      *  @param {Vector2} [position=new Vector2()]    - World space position of the object
      *  @param {Vector2} [size=objectDefaultSize]    - World space size of the object
-     *  @param {Number}  [tileIndex=-1]              - Tile to use to render object, untextured if -1
+     *  @param {Number}  [tileIndex=-1]              - Tile to use to render object (-1 is untextured)
      *  @param {Vector2} [tileSize=tileSizeDefault]  - Size of tile in source pixels
-     *  @param {Number}  [angle=0]                   - Angle to rotate the object
+     *  @param {Number}  [angle=0]                   - Angle the object is rotated by
      *  @param {Color}   [color]                     - Color to apply to tile when rendered
      *  @param {Number}  [renderOrder=0]             - Objects sorted by renderOrder before being rendered
      */
@@ -852,7 +885,7 @@ declare class EngineObject {
     pos: Vector2;
     /** @property {Vector2} - World space width and height of the object */
     size: Vector2;
-    /** @property {Number}  - Tile to use to render object, untextured if -1 */
+    /** @property {Number}  - Tile to use to render object (-1 is untextured) */
     tileIndex: number;
     /** @property {Vector2} - Size of tile in source pixels */
     tileSize: Vector2;
@@ -860,7 +893,7 @@ declare class EngineObject {
     angle: number;
     /** @property {Color}   - Color to apply when rendered */
     color: Color;
-    /** @property {Number} [mass=objectDefaultMass]                 - How heavy the object is */
+    /** @property {Number} [mass=objectDefaultMass]                 - How heavy the object is, static if 0 */
     mass: number;
     /** @property {Number} [damping=objectDefaultDamping]           - How much to slow down velocity each frame (0-1) */
     damping: number;
@@ -931,6 +964,7 @@ declare class EngineObject {
     setCollision(collideSolidObjects?: boolean, isSolid?: boolean, collideTiles?: boolean): void;
     collideSolidObjects: boolean;
     isSolid: boolean;
+    toString(): string;
 }
 /** Tile sheet for batch rendering system
  *  @type {Image}
@@ -1065,6 +1099,9 @@ declare let mouseWheel: number;
 /** Returns true if user is using gamepad (has more recently pressed a gamepad button)
  *  @memberof Input */
 declare let isUsingGamepad: number;
+/** Prevents input continuing to the default browser handling (false by default)
+ *  @memberof Input */
+declare let preventDefaultInput: number;
 /** Returns true if gamepad button is down
  *  @param {Number} button
  *  @param {Number} [gamepad=0]
@@ -1272,12 +1309,12 @@ declare class TileLayerData {
  */
 declare class TileLayer extends EngineObject {
     /** Create a tile layer object
-     *  @param {Vector2} [position=new Vector2()]   - World space position
-     *  @param {Vector2} [size=objectDefaultSize]   - World space size
-     *  @param {Vector2} [tileSize=tileSizeDefault] - Size of tiles in source pixels
-     *  @param {Vector2} [scale=new Vector2(1,1)]   - How much to scale this layer when rendered
-     *  @param {Number}  [renderOrder=0]            - Objects sorted by renderOrder before being rendered
-     */
+        *  @param {Vector2} [position=new Vector2()]   - World space position
+        *  @param {Vector2} [size=tileCollisionSize]   - World space size
+        *  @param {Vector2} [tileSize=tileSizeDefault] - Size of tiles in source pixels
+        *  @param {Vector2} [scale=new Vector2(1,1)]   - How much to scale this layer when rendered
+        *  @param {Number}  [renderOrder=0]            - Objects sorted by renderOrder before being rendered
+        */
     constructor(pos: any, size?: Vector2, tileSize?: Vector2, scale?: Vector2, renderOrder?: number);
     /** @property {HTMLCanvasElement}        - The canvas used by this tile layer */
     canvas: HTMLCanvasElement;
@@ -1353,7 +1390,7 @@ declare class TileLayer extends EngineObject {
 declare class ParticleEmitter extends EngineObject {
     /** Create a particle system with the given settings
      *  @param {Vector2} position           - World space position of the emitter
-     *  @param {Number}  [angle=0]          - Angle to rotate the object
+     *  @param {Number}  [angle=0]          - Angle to emit the particles
      *  @param {Number}  [emitSize=0]       - World space size of the emitter (float for circle diameter, vec2 for rect)
      *  @param {Number}  [emitTime=0]       - How long to stay alive (0 is forever)
      *  @param {Number}  [emitRate=100]     - How many particles per second to spawn, does not emit if 0
@@ -1401,7 +1438,7 @@ declare class ParticleEmitter extends EngineObject {
     randomColorLinear: boolean;
     /** @property {Number} - How long particles live */
     particleTime: number;
-    /** @property {Number} -  How big are particles at start */
+    /** @property {Number} - How big are particles at start */
     sizeStart: number;
     /** @property {Number} - How big are particles at end */
     sizeEnd: number;
@@ -1415,6 +1452,8 @@ declare class ParticleEmitter extends EngineObject {
     fadeRate: number;
     /** @property {Number} - Apply extra randomness percent */
     randomness: number;
+    /** @property {Number} - Do particles collide against tiles */
+    collideTiles: boolean;
     /** @property {Number} - Should particles use addtive blend */
     additive: boolean;
     /** @property {Number} - If set the partile is drawn as a trail, stretched in the drection of velocity */
@@ -1588,7 +1627,7 @@ declare const gl_VERTEX_BYTE_STRIDE: number;
 /** Name of engine */
 declare const engineName: "LittleJS";
 /** Version of engine */
-declare const engineVersion: "1.2.3";
+declare const engineVersion: "1.3.3";
 /** Frames per second to update objects
  *  @default */
 declare const frameRate: 60;

package/examples/breakout/index.html

@@ -5,6 +5,6 @@
 <link rel=icon type=image/png href=../../favicon.png>
 </head><body>
 
-<script src=../../engine/engine.all.js?102></script>
-<script src=game.js?102></script>
-<script src=gameObjects.js?102></script>
+<script src=../../engine/engine.all.js?108></script>
+<script src=game.js?108></script>
+<script src=gameObjects.js?108></script>