littlejsengine 1.1.2 → 1.1.3

package/engine/engineParticles.js

@@ -9,37 +9,50 @@
 
 /**
  * Particle Emitter - Spawns particles with the given settings
+ * @extends EngineObject
+ * @example
+ * // create a particle emitter
+ * let pos = vec2(2,3);
+ * let particleEmiter = new ParticleEmitter
+ * (
+ *     pos, 1, 0, 500, PI,  // pos, emitSize, emitTime, emitRate, emiteCone
+ *     0, vec2(16),                            // tileIndex, tileSize
+ *     new Color, new Color(0,0,0),            // colorStartA, colorStartB
+ *     new Color(1,1,1,0), new Color(0,0,0,0), // colorEndA, colorEndB
+ *     2, .2, .2, .1, .05,  // particleTime, sizeStart, sizeEnd, particleSpeed, particleAngleSpeed
+ *     .99, 1, 1, PI, .05,  // damping, angleDamping, gravityScale, particleCone, fadeRate, 
+ *     .5, 1                // randomness, collide, additive, randomColorLinear, renderOrder
+ * );
  */
 class ParticleEmitter extends EngineObject
 {
-    /**
-     * Create a particle system with the given settings
-     * @param {Vector2} position          - World space position of the emitter
-     * @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
-     * @param {Number}  [emitConeAngle=PI] - Local angle to apply velocity to particles from emitter
-     * @param {Number}  [tileIndex=-1]     - Index into tile sheet, if <0 no texture is applied
-     * @param {Number}  [tileSize=defaultTileSize]    - Tile size for particles
-     * @param {Color}   [colorStartA=new Color(1,1,1)] - Color at start of life 1, randomized between start colors
-     * @param {Color}   [colorStartB=new Color(1,1,1)] - Color at start of life 2, randomized between start colors
-     * @param {Color}   [colorEndA=new Color(1,1,1,0)] - Color at end of life 1, randomized between end colors
-     * @param {Color}   [colorEndB=new Color(1,1,1,0)] - Color at end of life 2, randomized between end colors
-     * @param {Number}  [particleTime=.5]      - How long particles live
-     * @param {Number}  [sizeStart=.1]         - How big are particles at start
-     * @param {Number}  [sizeEnd=1]            - How big are particles at end
-     * @param {Number}  [speed=.1]             - How fast are particles when spawned
-     * @param {Number}  [angleSpeed=.05]       - How fast are particles rotating
-     * @param {Number}  [damping=1]            - How much to dampen particle speed
-     * @param {Number}  [angleDamping=1]       - How much to dampen particle angular speed
-     * @param {Number}  [gravityScale=0]       - How much does gravity effect particles
-     * @param {Number}  [particleConeAngle=PI] - Cone for start particle angle
-     * @param {Number}  [fadeRate=.1]          - How quick to fade in particles at start/end in percent of life
-     * @param {Number}  [randomness=.2]        - Apply extra randomness percent
-     * @param {Boolean} [collideTiles=0]      - Do particles collide against tiles
-     * @param {Boolean} [additive=0]          - Should particles use addtive blend
-     * @param {Boolean} [randomColorLinear=0] - Should color be randomized linearly or across each component
-     * @param {Number}  [renderOrder=0]        - Render order for particles (additive is above other stuff by default)
+    /** Create a particle system with the given settings
+     *  @param {Vector2} position           - World space position of the emitter
+     *  @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
+     *  @param {Number}  [emitConeAngle=PI] - Local angle to apply velocity to particles from emitter
+     *  @param {Number}  [tileIndex=-1]     - Index into tile sheet, if <0 no texture is applied
+     *  @param {Number}  [tileSize=tileSizeDefault]     - Tile size for particles
+     *  @param {Color}   [colorStartA=new Color(1,1,1)] - Color at start of life 1, randomized between start colors
+     *  @param {Color}   [colorStartB=new Color(1,1,1)] - Color at start of life 2, randomized between start colors
+     *  @param {Color}   [colorEndA=new Color(1,1,1,0)] - Color at end of life 1, randomized between end colors
+     *  @param {Color}   [colorEndB=new Color(1,1,1,0)] - Color at end of life 2, randomized between end colors
+     *  @param {Number}  [particleTime=.5]      - How long particles live
+     *  @param {Number}  [sizeStart=.1]         - How big are particles at start
+     *  @param {Number}  [sizeEnd=1]            - How big are particles at end
+     *  @param {Number}  [speed=.1]             - How fast are particles when spawned
+     *  @param {Number}  [angleSpeed=.05]       - How fast are particles rotating
+     *  @param {Number}  [damping=1]            - How much to dampen particle speed
+     *  @param {Number}  [angleDamping=1]       - How much to dampen particle angular speed
+     *  @param {Number}  [gravityScale=0]       - How much does gravity effect particles
+     *  @param {Number}  [particleConeAngle=PI] - Cone for start particle angle
+     *  @param {Number}  [fadeRate=.1]          - How quick to fade in particles at start/end in percent of life
+     *  @param {Number}  [randomness=.2]        - Apply extra randomness percent
+     *  @param {Boolean} [collideTiles=0]       - Do particles collide against tiles
+     *  @param {Boolean} [additive=0]           - Should particles use addtive blend
+     *  @param {Boolean} [randomColorLinear=1]  - Should color be randomized linearly or across each component
+     *  @param {Number}  [renderOrder=0]        - Render order for particles (additive is above other stuff by default)
      */
     constructor
     ( 
@@ -49,7 +62,7 @@ class ParticleEmitter extends EngineObject
         emitRate = 100,
         emitConeAngle = PI,
         tileIndex = -1,
-        tileSize = defaultTileSize,
+        tileSize = tileSizeDefault,
         colorStartA = new Color,
         colorStartB = new Color,
         colorEndA = new Color(1,1,1,0),
@@ -71,37 +84,61 @@ class ParticleEmitter extends EngineObject
         renderOrder = additive ? 1e9 : 0
     )
     {
-        super(pos, new Vector2, tileIndex, tileSize);
+        super(pos, new Vector2, tileIndex, tileSize, 0, undefined, renderOrder);
 
         // emitter settings
+        /** @property {Number} - World space size of the emitter (float for circle diameter, vec2 for rect) */
         this.emitSize = emitSize
+        /** @property {Number} - How long to stay alive (0 is forever) */
         this.emitTime = emitTime;
+        /** @property {Number} - How many particles per second to spawn, does not emit if 0 */
         this.emitRate = emitRate;
+        /** @property {Number} - Local angle to apply velocity to particles from emitter */
         this.emitConeAngle = emitConeAngle;
 
         // color settings
+        /** @property {Color} - Color at start of life 1, randomized between start colors */
         this.colorStartA = colorStartA;
+        /** @property {Color} - Color at start of life 2, randomized between start colors */
         this.colorStartB = colorStartB;
+        /** @property {Color} - Color at end of life 1, randomized between end colors */
         this.colorEndA   = colorEndA;
+        /** @property {Color} - Color at end of life 2, randomized between end colors */
         this.colorEndB   = colorEndB;
+        /** @property {Boolean} - Should color be randomized linearly or across each component */
         this.randomColorLinear = randomColorLinear;
 
         // particle settings
+        /** @property {Number} - How long particles live */
         this.particleTime      = particleTime;
+        /** @property {Number} -  How big are particles at start */
         this.sizeStart         = sizeStart;
+        /** @property {Number} - How big are particles at end */
         this.sizeEnd           = sizeEnd;
+        /** @property {Number} - How fast are particles when spawned */
         this.speed             = speed;
+        /** @property {Number} - How fast are particles rotating */
         this.angleSpeed        = angleSpeed;
+        /** @property {Number} - How much to dampen particle speed */
         this.damping           = damping;
+        /** @property {Number} - How much to dampen particle angular speed */
         this.angleDamping      = angleDamping;
+        /** @property {Number} - How much does gravity effect particles */
         this.gravityScale      = gravityScale;
+        /** @property {Number} - Cone for start particle angle */
         this.particleConeAngle = particleConeAngle;
+        /** @property {Number} - How quick to fade in particles at start/end in percent of life */
         this.fadeRate          = fadeRate;
+        /** @property {Number} - Apply extra randomness percent */
         this.randomness        = randomness;
+        /** @property {Number} - Do particles collide against tiles */
         this.collideTiles      = collideTiles;
+        /** @property {Number} - Should particles use addtive blend */
         this.additive          = additive;
-        this.renderOrder       = renderOrder;
-        this.trailScale        =  
+        /** @property {Number} - If set the partile is drawn as a trail, stretched in the drection of velocity */
+        this.trailScale        = 0;
+
+        // internal variables
         this.emitTimeBuffer    = 0;
     }
     
@@ -115,9 +152,9 @@ class ParticleEmitter extends EngineObject
         if (!this.emitTime || this.getAliveTime() <= this.emitTime)
         {
             // emit particles
-            if (this.emitRate)
+            if (this.emitRate * particleEmitRateScale)
             {
-                const rate = 1/this.emitRate;
+                const rate = 1/this.emitRate/particleEmitRateScale;
                 for (this.emitTimeBuffer += timeDelta; this.emitTimeBuffer > 0; this.emitTimeBuffer -= rate)
                     this.emitParticle();
             }
@@ -144,34 +181,34 @@ class ParticleEmitter extends EngineObject
         const randomizeScale = (v)=> v + v*rand(randomness, -randomness);
 
         // randomize particle settings
-        const particleTime  = randomizeScale(this.particleTime);
-        const sizeStart     = randomizeScale(this.sizeStart);
-        const sizeEnd       = randomizeScale(this.sizeEnd);
-        const speed         = randomizeScale(this.speed);
-        const angleSpeed    = randomizeScale(this.angleSpeed) * randSign();
-        const coneAngle     = rand(this.emitConeAngle, -this.emitConeAngle);
-        const colorStart    = randColor(this.colorStartA, this.colorStartB, this.randomColorLinear);
-        const colorEnd      = randColor(this.colorEndA,   this.colorEndB, this.randomColorLinear);
+        const particleTime = randomizeScale(this.particleTime);
+        const sizeStart    = randomizeScale(this.sizeStart);
+        const sizeEnd      = randomizeScale(this.sizeEnd);
+        const speed        = randomizeScale(this.speed);
+        const angleSpeed   = randomizeScale(this.angleSpeed) * randSign();
+        const coneAngle    = rand(this.emitConeAngle, -this.emitConeAngle);
+        const colorStart   = randColor(this.colorStartA, this.colorStartB, this.randomColorLinear);
+        const colorEnd     = randColor(this.colorEndA,   this.colorEndB, this.randomColorLinear);
 
         // build particle settings
-        particle.colorStart      = colorStart;
-        particle.colorEndDelta   = colorEnd.subtract(colorStart);
-        particle.velocity        = (new Vector2).setAngle(this.angle + coneAngle, speed);
-        particle.angleVelocity   = angleSpeed;
-        particle.lifeTime        = particleTime;
-        particle.sizeStart       = sizeStart;
-        particle.sizeEndDelta    = sizeEnd - sizeStart;
-        particle.fadeRate        = this.fadeRate;
-        particle.damping         = this.damping;
-        particle.angleDamping    = this.angleDamping;
-        particle.elasticity      = this.elasticity;
-        particle.friction        = this.friction;
-        particle.gravityScale    = this.gravityScale;
-        particle.collideTiles    = this.collideTiles;
-        particle.additive        = this.additive;
-        particle.renderOrder     = this.renderOrder;
-        particle.trailScale      = this.trailScale;
-        particle.mirror          = rand()<.5;
+        particle.colorStart    = colorStart;
+        particle.colorEndDelta = colorEnd.subtract(colorStart);
+        particle.velocity      = (new Vector2).setAngle(this.angle + coneAngle, speed);
+        particle.angleVelocity = angleSpeed;
+        particle.lifeTime      = particleTime;
+        particle.sizeStart     = sizeStart;
+        particle.sizeEndDelta  = sizeEnd - sizeStart;
+        particle.fadeRate      = this.fadeRate;
+        particle.damping       = this.damping;
+        particle.angleDamping  = this.angleDamping;
+        particle.elasticity    = this.elasticity;
+        particle.friction      = this.friction;
+        particle.gravityScale  = this.gravityScale;
+        particle.collideTiles  = this.collideTiles;
+        particle.additive      = this.additive;
+        particle.renderOrder   = this.renderOrder;
+        particle.trailScale    = this.trailScale;
+        particle.mirror        = rand()<.5;
 
         // setup callbacks for particles
         particle.destroyCallback = this.particleDestroyCallback;
@@ -188,15 +225,16 @@ class ParticleEmitter extends EngineObject
 ///////////////////////////////////////////////////////////////////////////////
 /**
  * Particle Object - Created automatically by Particle Emitters
+ * @extends EngineObject
  */
 class Particle extends EngineObject
 {
     /**
      * Create a particle with the given settings
      * @param {Vector2} position                   - World space position of the particle
-     * @param {Number}  [tileIndex=-1]              - Tile to use to render, untextured if -1
-     * @param {Vector2} [tileSize=defaultTileSize] - Size of tile in source pixels
-     * @param {Number}  [angle=0]                   - Angle to rotate the particle
+     * @param {Number}  [tileIndex=-1]             - Tile to use to render, untextured if -1
+     * @param {Vector2} [tileSize=tileSizeDefault] - Size of tile in source pixels
+     * @param {Number}  [angle=0]                  - Angle to rotate the particle
      */
     constructor(pos, tileIndex, tileSize, angle) { super(pos, new Vector2, tileIndex, tileSize, angle); }
 

package/engine/engineRelease.js

@@ -1,5 +1,7 @@
 /*
-    LittleJS - Release build include file
+    LittleJS - Release Build
+    MIT License - Copyright 2021 Frank Force
+    
     - This file is used for release builds in place of engineDebug.js
     - Debug functionality will be disabled to lower size and increase performance
 */
@@ -26,5 +28,6 @@ const debugCircle     = ()=> {}
 const debugPoint      = ()=> {}
 const debugLine       = ()=> {}
 const debugAABB       = ()=> {}
+const debugText       = ()=> {}
 const debugClear      = ()=> {}
 const debugSaveCanvas = ()=> {}

package/engine/engineSettings.js

@@ -1,6 +1,6 @@
 /**
- *  LittleJS Engine Settings
- *  @namespace Settings
+ * LittleJS Engine Settings
+ * @namespace Settings
  */
 
 'use strict';
@@ -8,35 +8,27 @@
 ///////////////////////////////////////////////////////////////////////////////
 // Display settings
 
-/** The max width of the canvas, centered if window is larger
- *  @default
- *  @memberof Settings */
-const maxWidth = 1920;
-
-/** The max height of the canvas, centered if window is larger
- *  @default
- *  @memberof Settings */
-const maxHeight = 1200; // up to 1080p and 16:10
-
-/** Fixed witdh, if enabled cavnvas size never changes
+/** The max size of the canvas, centered if window is larger
+ *  @type {Vector2} 
  *  @default
  *  @memberof Settings */
-let fixedWidth = 0;
+let canvasMaxSize = vec2(1920, 1200);
 
-/** Fixed height, if enabled cavnvas size never changes
+/** Fixed size of the canvas, if enabled cavnvas size never changes
+ *  @type {Vector2} 
  *  @default
  *  @memberof Settings */
-let fixedHeight = 0;
+let canvasFixedSize = vec2();
 
-/** Fit to canvas to window by adding space on top or bottom if necessary
+/** Disables anti aliasing for pixel art if true
  *  @default
  *  @memberof Settings */
-let fixedFitToWindow = 1;
+let cavasPixelated = 1;
 
 /** Default font used for text rendering
  *  @default
  *  @memberof Settings */
-let defaultFont = 'arial';
+let fontDefault = 'arial';
 
 ///////////////////////////////////////////////////////////////////////////////
 // Tile sheet settings
@@ -45,17 +37,12 @@ let defaultFont = 'arial';
  *  @type {Vector2} 
  *  @default
  *  @memberof Settings */
-const defaultTileSize = vec2(16);
+let tileSizeDefault = vec2(16);
 
 /** Prevent tile bleeding from neighbors in pixels
  *  @default
  *  @memberof Settings */
-const tileBleedShrinkFix = .3;
-
-/** Use crisp pixels for pixel art if true
- *  @default
- *  @memberof Settings */
-let pixelated = 1;
+let tileFixBleedScale = .3;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Object settings
@@ -64,43 +51,48 @@ let pixelated = 1;
  *  @type {Vector2} 
  *  @default
  *  @memberof Settings */
-const defaultObjectSize = vec2(1);
+let objectDefaultSize = vec2(1);
 
 /** Default object mass for collison calcuations (how heavy objects are)
  *  @default
  *  @memberof Settings */
-const defaultObjectMass = 1;
+let objectDefaultMass = 1;
 
 /** How much to slow velocity by each frame (0-1)
  *  @default
  *  @memberof Settings */
-const defaultObjectDamping = .99;
+let objectDefaultDamping = .99;
 
 /** How much to slow angular velocity each frame (0-1)
  *  @default
  *  @memberof Settings */
-const defaultObjectAngleDamping = .99;
+let objectDefaultAngleDamping = .99;
 
 /** How much to bounce when a collision occurs (0-1)
  *  @default
  *  @memberof Settings */
-const defaultObjectElasticity = 0;
+let objectDefaultElasticity = 0;
 
 /** How much to slow when touching (0-1)
  *  @default
  *  @memberof Settings */
-const defaultObjectFriction = .8;
+let objectDefaultFriction = .8;
 
 /** Clamp max speed to avoid fast objects missing collisions
  *  @default
  *  @memberof Settings */
-const maxObjectSpeed = 1;
+let objectMaxSpeed = 1;
 
 /** How much gravity to apply to objects along the Y axis, negative is down
  *  @default
  *  @memberof Settings */
 let gravity = 0;
 
+/** Scales emit rate of particles, useful for low graphics mode (0 disables particle emitters)
+ *  @default
+ *  @memberof Settings */
+let particleEmitRateScale = 1;
+
 ///////////////////////////////////////////////////////////////////////////////
 // Camera settings
 
@@ -113,7 +105,7 @@ let cameraPos = vec2();
 /** Scale of camera in world space
  *  @default
  *  @memberof Settings */
-let cameraScale = max(defaultTileSize.x, defaultTileSize.y);
+let cameraScale = max(tileSizeDefault.x, tileSizeDefault.y);
 
 ///////////////////////////////////////////////////////////////////////////////
 // WebGL settings
@@ -121,7 +113,7 @@ let cameraScale = max(defaultTileSize.x, defaultTileSize.y);
 /** Enable webgl rendering, webgl can be disabled and removed from build (with some features disabled)
  *  @default
  *  @memberof Settings */
-const glEnable = 1;
+let glEnable = 1;
 
 /** Fixes slow rendering in some browsers by not compositing the WebGL canvas
  *  @default
@@ -134,45 +126,62 @@ let glOverlay = 1;
 /** Should gamepads be allowed
  *  @default
  *  @memberof Settings */
-const gamepadsEnable = 1;
+let gamepadsEnable = 1;
 
-/** If true touch input is routed to mouse functions
+/** If true, the dpad input is also routed to the left analog stick (for better accessability)
  *  @default
  *  @memberof Settings */
-const touchInputEnable = 1;
+let gamepadDirectionEmulateStick = 1;
 
-/** Allow players to use dpad as analog stick
+/** If true the WASD keys are also routed to the direction keys (for better accessability)
  *  @default
  *  @memberof Settings */
-const copyGamepadDirectionToStick = 1;
+let inputWASDEmulateDirection = 1;
 
-/** allow players to use WASD as direction keys
+/** True if touch gamepad should appear on mobile devices
+ *  <br> - Supports left analog stick, 4 face buttons and start button (button 9)
+ *  <br> - Must be set by end of gameInit to be activated
  *  @default
  *  @memberof Settings */
-const copyWASDToDpad = 1;
+let touchGamepadEnable = 0;
+
+/** Size of virutal gamepad for touch devices in pixels
+ *  @default
+ *  @memberof Settings */
+let touchGamepadSize = 80;
+
+/** Transparency of touch gamepad overlay
+ *  @default
+ *  @memberof Settings */
+let touchGamepadAlpha = .3;
+
+/** Allow vibration hardware if it exists
+ *  @default
+ *  @memberof Settings */
+let vibrateEnable = 1;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Audio settings
 
-/** All audio code can be disabled and removed from build
+/** Volume scale to apply to all sound, music and speech
  *  @default
  *  @memberof Settings */
-const soundEnable = 1;
+let soundVolume = .5;
 
-/** Volume scale to apply to all sound, music and speech
+/** All audio code can be disabled and removed from build
  *  @default
  *  @memberof Settings */
-let audioVolume = .5;
+let soundEnable = 1;
 
 /** Default range where sound no longer plays
  *  @default
  *  @memberof Settings */
-const defaultSoundRange = 30;
+let soundDefaultRange = 30;
 
 /** Default range percent to start tapering off sound (0-1)
  *  @default
  *  @memberof Settings */
-const defaultSoundTaper = .7;
+let soundDefaultTaper = .7;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Medals settings
@@ -180,24 +189,24 @@ const defaultSoundTaper = .7;
 /** How long to show medals for in seconds
  *  @default
  *  @memberof Settings */
-const medalDisplayTime = 5;
+let medalDisplayTime = 5;
 
 /** How quickly to slide on/off medals in seconds
  *  @default
  *  @memberof Settings */
-const medalDisplaySlideTime = .5;
+let medalDisplaySlideTime = .5;
 
 /** Width of medal display
  *  @default
  *  @memberof Settings */
-const medalDisplayWidth = 640;
+let medalDisplayWidth = 640;
 
 /** Height of medal display
  *  @default
  *  @memberof Settings */
-const medalDisplayHeight = 99;
+let medalDisplayHeight = 80;
 
 /** Size of icon in medal display
  *  @default
  *  @memberof Settings */
-const medalDisplayIconSize = 80;
+let medalDisplayIconSize = 50;