littlejsengine 1.4.91 → 1.5.1

package/engine/engineExport.js

@@ -4,43 +4,187 @@
  */
 
 // Setters for all variables that devs will need to modify
-const setCameraPos =                    (v)=> cameraPos = v;
-const setCameraScale =                  (v)=> cameraScale = v;
-const setCanvasMaxSize =                (v)=> canvasMaxSize = v;
-const setCanvasFixedSize =              (v)=> canvasFixedSize = v;
-const setCavasPixelated =               (v)=> cavasPixelated = v;
-const setFontDefault =                  (v)=> fontDefault = v;
-const setGlEnable =                     (v)=> glEnable = v;
-const setGlOverlay =                    (v)=> glOverlay = v;
-const setTileSizeDefault =              (v)=> tileSizeDefault = v;
-const setTileFixBleedScale =            (v)=> tileFixBleedScale = v;
-const setObjectDefaultSize =            (v)=> objectDefaultSize = v;
-const setEnablePhysicsSolver =          (v)=> enablePhysicsSolver = v;
-const setObjectDefaultMass =            (v)=> objectDefaultMass = v;
-const setObjectDefaultDamping =         (v)=> objectDefaultDamping = v;
-const setObjectDefaultAngleDamping =    (v)=> objectDefaultAngleDamping = v;
-const setObjectDefaultElasticity =      (v)=> objectDefaultElasticity = v;
-const setObjectDefaultFriction =        (v)=> objectDefaultFriction = v;
-const setObjectMaxSpeed =               (v)=> objectMaxSpeed = v;
-const setGravity =                      (v)=> gravity = v;
-const setParticleEmitRateScale =        (v)=> particleEmitRateScale = v;
-const setGamepadsEnable =               (v)=> gamepadsEnable = v;
-const setGamepadDirectionEmulateStick = (v)=> gamepadDirectionEmulateStick = v;
-const setInputWASDEmulateDirection =    (v)=> inputWASDEmulateDirection = v;
-const setTouchGamepadEnable =           (v)=> touchGamepadEnable = v;
-const setTouchGamepadAnalog =           (v)=> touchGamepadAnalog = v;
-const setTouchGamepadSize =             (v)=> touchGamepadSize = v;
-const setTouchGamepadAlpha =            (v)=> touchGamepadAlpha = v;
-const setVibrateEnable =                (v)=> vibrateEnable = v;
-const setSoundEnable =                  (v)=> soundEnable = v;
-const setSoundVolume =                  (v)=> soundVolume = v;
-const setSoundDefaultRange =            (v)=> soundDefaultRange = v;
-const setSoundDefaultTaper =            (v)=> soundDefaultTaper = v;
-const setMedalDisplayTime =             (v)=> medalDisplayTime = v;
-const setMedalDisplaySlideTime =        (v)=> medalDisplaySlideTime = v;
-const setMedalDisplaySize =            	(v)=> medalDisplaySize = v;
-const setMedalDisplayIconSize =         (v)=> medalDisplayIconSize = v;
-const setMedalsPreventUnlock =          (v)=> medalsPreventUnlock = v;
+
+
+/** Set position of camera in world space
+ *  @param {Vector2} pos
+ *  @memberof Settings */
+const setCameraPos = (pos)=> cameraPos = pos;
+
+/** Set scale of camera in world space
+ *  @param {Number} scale
+ *  @memberof Settings */
+const setCameraScale = (scale)=> cameraScale = scale;
+
+/** Set max size of the canvas
+ *  @param {Vector2} size
+ *  @memberof Settings */
+const setCanvasMaxSize = (size)=> canvasMaxSize = size;
+
+/** Set fixed size of the canvas
+ *  @param {Vector2} size
+ *  @memberof Settings */
+const setCanvasFixedSize = (size)=> canvasFixedSize = size;
+
+/** Disables anti aliasing for pixel art if true
+ *  @param {Boolean} pixelated
+ *  @memberof Settings */
+const setCavasPixelated = (pixelated)=> cavasPixelated = pixelated;
+
+/** Set default font used for text rendering
+ *  @param {String} font
+ *  @memberof Settings */
+const setFontDefault = (font)=> fontDefault = font;
+
+/** Set if webgl rendering is enabled
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setGlEnable = (enable)=> glEnable = enable;
+
+/** Set to not composite the WebGL canvas
+ *  @param {Boolean} overlay
+ *  @memberof Settings */
+const setGlOverlay = (overlay)=> glOverlay = overlay;
+
+/** Set default size of tiles in pixels
+ *  @param {Vector2} size
+ *  @memberof Settings */
+const setTileSizeDefault = (size)=> tileSizeDefault = size;
+
+/** Set to prevent tile bleeding from neighbors in pixels
+ *  @param {Number} scale
+ *  @memberof Settings */
+const setTileFixBleedScale = (scale)=> tileFixBleedScale = scale;
+
+/** Set if collisions between objects are enabled
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setEnablePhysicsSolver = (enable)=> enablePhysicsSolver = enable;
+
+/** Set default object mass for collison calcuations
+ *  @param {Number} mass
+ *  @memberof Settings */
+const setObjectDefaultMass = (mass)=> objectDefaultMass = mass;
+
+/** Set how much to slow velocity by each frame
+ *  @param {Number} damping
+ *  @memberof Settings */
+const setObjectDefaultDamping = (damp)=> objectDefaultDamping = damp;
+
+/** Set how much to slow angular velocity each frame
+ *  @param {Number} damping
+ *  @memberof Settings */
+const setObjectDefaultAngleDamping = (damp)=> objectDefaultAngleDamping = damp;
+
+/** Set how much to bounce when a collision occur
+ *  @param {Number} elasticity
+ *  @memberof Settings */
+const setObjectDefaultElasticity = (elasticity)=> objectDefaultElasticity = elasticity;
+
+/** Set how much to slow when touching
+ *  @param {Number} friction
+ *  @memberof Settings */
+const setObjectDefaultFriction = (friction)=> objectDefaultFriction = friction;
+
+/** Set max speed to avoid fast objects missing collisions
+ *  @param {Number} speed
+ *  @memberof Settings */
+const setObjectMaxSpeed = (speed)=> objectMaxSpeed = speed;
+
+/** Set how much gravity to apply to objects along the Y axis
+ *  @param {Number} gravity
+ *  @memberof Settings */
+const setGravity = (g)=> gravity = g;
+
+/** Set to scales emit rate of particles
+ *  @param {Number} scale
+ *  @memberof Settings */
+const setParticleEmitRateScale = (scale)=> particleEmitRateScale = scale;
+
+/** Set if gamepads are enabled
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setGamepadsEnable = (enable)=> gamepadsEnable = enable;
+
+/** Set if the dpad input is also routed to the left analog stick
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setGamepadDirectionEmulateStick = (enable)=> gamepadDirectionEmulateStick = enable;
+
+/** Set if true the WASD keys are also routed to the direction keys
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setInputWASDEmulateDirection = (enable)=> inputWASDEmulateDirection = enable;
+
+/** Set if touch gamepad should appear on mobile devices
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setTouchGamepadEnable = (enable)=> touchGamepadEnable = enable;
+
+/** Set if touch gamepad should be analog stick or 8 way dpad
+ *  @param {Boolean} analog
+ *  @memberof Settings */
+const setTouchGamepadAnalog = (analog)=> touchGamepadAnalog = analog;
+
+/** Set size of virutal gamepad for touch devices in pixels
+ *  @param {Number} size
+ *  @memberof Settings */
+const setTouchGamepadSize = (size)=> touchGamepadSize = size;
+
+/** Set transparency of touch gamepad overlay
+ *  @param {Number} alpha
+ *  @memberof Settings */
+const setTouchGamepadAlpha = (alpha)=> touchGamepadAlpha = alpha;
+
+/** Set to allow vibration hardware if it exists
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setVibrateEnable = (enable)=> vibrateEnable = enable;
+
+/** Set to disable all audio code
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setSoundEnable = (enable)=> soundEnable = enable;
+
+/** Set volume scale to apply to all sound, music and speech
+ *  @param {Number} volume
+ *  @memberof Settings */
+const setSoundVolume = (volume)=> soundVolume = volume;
+
+/** Set default range where sound no longer plays
+ *  @param {Number} range
+ *  @memberof Settings */
+const setSoundDefaultRange = (range)=> soundDefaultRange = range;
+
+/** Set default range percent to start tapering off sound
+ *  @param {Number} taper
+ *  @memberof Settings */
+const setSoundDefaultTaper = (taper)=> soundDefaultTaper = taper;
+
+/** Set how long to show medals for in seconds
+ *  @param {Number} time
+ *  @memberof Settings */
+const setMedalDisplayTime = (time)=> medalDisplayTime = time;
+
+/** Set how quickly to slide on/off medals in seconds
+ *  @param {Number} time
+ *  @memberof Settings */
+const setMedalDisplaySlideTime = (time)=> medalDisplaySlideTime = time;
+
+/** Set size of medal display
+ *  @param {Vector2} size
+ *  @memberof Settings */
+const setMedalDisplaySize = (size)=> medalDisplaySize = size;
+
+/** Set size of icon in medal display
+ *  @param {Number} size
+ *  @memberof Settings */
+const setMedalDisplayIconSize = (size)=> medalDisplayIconSize = size;
+
+/** Set to stop medals from being unlockable
+ *  @param {Boolean} preventUnlock
+ *  @memberof Settings */
+const setMedalsPreventUnlock = (prevent)=> medalsPreventUnlock = prevent;
 
 export {
 	// Setters for global variables
@@ -54,7 +198,6 @@ export {
 	setGlOverlay,
 	setTileSizeDefault,
 	setTileFixBleedScale,
-	setObjectDefaultSize,
 	setEnablePhysicsSolver,
 	setObjectDefaultMass,
 	setObjectDefaultDamping,
@@ -89,7 +232,6 @@ export {
 	fontDefault,
 	tileSizeDefault,
 	tileFixBleedScale,
-	objectDefaultSize,
 	enablePhysicsSolver,
 	objectDefaultMass,
 	objectDefaultDamping,
@@ -124,17 +266,9 @@ export {
 	debug,
 	showWatermark,
 	godMode,
+
 	// Debug
-	//debugPrimitives,
-	//debugOverlay,
-	//debugPhysics,
-	//debugRaycast,
-	//debugParticles,
-	//debugGamepads,
-	//debugMedals,
-	//debugTakeScreenshot,
-	//downloadLink,
-	//ASSERT,
+	ASSERT,
 	debugRect,
 	debugCircle,
 	debugPoint,
@@ -143,9 +277,6 @@ export {
 	debugText,
 	debugClear,
 	debugSaveCanvas,
-	//debugInit,
-	//debugUpdate,
-	//debugRender,
 
 	// Utilities
 	PI,
@@ -225,18 +356,6 @@ export {
 	gamepadWasPressed,
 	gamepadWasReleased,
 	gamepadStick,
-	//inputData,
-	//inputUpdate,
-	//inputUpdatePost,
-	// onkeydown,
-	// onkeyup,
-	//remapKeyCode,
-	// onmousedown,
-	// onmouseup,
-	// onmousemove,
-	// onwheel,
-	// oncontextmenu,
-	//stickData,
 	mouseToScreen,
 	gamepadsUpdate,
 	vibrate,
@@ -253,9 +372,6 @@ export {
 	audioContext,
 	playSamples,
 	zzfx,
-	//zzfxR,
-	//zzfxG,
-	//zzfxM,
 
 	// Tiles
 	tileCollision,
@@ -278,25 +394,17 @@ export {
 	medalsInit,
 	newgroundsInit,
 	Medal,
-	//medalsRender,
 	Newgrounds,
-	//CryptoJS,
 
 	// WebGL
 	glCanvas,
 	glContext,
-	//glInit,
 	glSetBlendMode,
 	glSetTexture,
 	glCompileShader,
 	glCreateProgram,
 	glCreateTexture,
-	//glPreRender,
-	//glFlush,
-	//glCopyToContext,
-	//glDraw,
 	glInitPostProcess,
-	//glRenderPostProcess,
 
 	// Engine
 	engineName,
@@ -304,7 +412,6 @@ export {
 	frameRate,
 	timeDelta,
 	engineObjects,
-	//engineObjectsCollide,
 	frame,
 	time,
 	timeReal,

package/engine/engineInput.js

@@ -35,18 +35,21 @@ const keyWasReleased = (key, device=0)=> inputData[device] && inputData[device][
 const clearInput = ()=> inputData = [[]];
 
 /** Returns true if mouse button is down
+ *  @function
  *  @param {Number} button
  *  @return {Boolean}
  *  @memberof Input */
 const mouseIsDown = keyIsDown;
 
 /** Returns true if mouse button was pressed
+ *  @function
  *  @param {Number} button
  *  @return {Boolean}
  *  @memberof Input */
 const mouseWasPressed = keyWasPressed;
 
 /** Returns true if mouse button was released
+ *  @function
  *  @param {Number} button
  *  @return {Boolean}
  *  @memberof Input */
@@ -63,14 +66,17 @@ let mousePos = vec2();
 let mousePosScreen = vec2();
 
 /** Mouse wheel delta this frame
+ *  @type {Number}
  *  @memberof Input */
 let mouseWheel = 0;
 
 /** Returns true if user is using gamepad (has more recently pressed a gamepad button)
+ *  @type {Boolean}
  *  @memberof Input */
 let isUsingGamepad = 0;
 
 /** Prevents input continuing to the default browser handling (false by default)
+ *  @type {Boolean}
  *  @memberof Input */
 let preventDefaultInput = 0;
 
@@ -246,7 +252,6 @@ const vibrateStop = ()=> vibrate(0);
 // Touch input
 
 /** True if a touch device has been detected
- *  @const {boolean}
  *  @memberof Input */
 const isTouchDevice = window.ontouchstart !== undefined;
 

package/engine/engineMedals.js

@@ -9,6 +9,7 @@
 'use strict';
 
 /** List of all medals
+ *  @type {Array}
  *  @memberof Medals */
 const medals = [];
 

package/engine/engineObject.js

@@ -32,15 +32,15 @@
 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 {Vector2} [position=Vector2()]        - World space position of the object
+     *  @param {Vector2} [size=Vector2(1,1)]         - World space size of the object
      *  @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 the object is rotated by
-     *  @param {Color}   [color]                     - Color to apply to tile when rendered
+     *  @param {Color}   [color=Color()]             - Color to apply to tile when rendered
      *  @param {Number}  [renderOrder=0]             - Objects sorted by renderOrder before being rendered
      */
-    constructor(pos=vec2(), size=objectDefaultSize, tileIndex=-1, tileSize=tileSizeDefault, angle=0, color, renderOrder=0)
+    constructor(pos=vec2(), size=vec2(1), tileIndex=-1, tileSize=tileSizeDefault, angle=0, color, renderOrder=0)
     {
         // set passed in params
         ASSERT(isVector2(pos) && isVector2(size)); // ensure pos and size are vec2s
@@ -77,7 +77,7 @@ class EngineObject
         this.gravityScale = 1;
         /** @property {Number} [renderOrder=0]                          - Objects are sorted by render order */
         this.renderOrder = renderOrder;
-        /** @property {Vector2} [velocity=new Vector2()]                - Velocity of the object */
+        /** @property {Vector2} [velocity=Vector2()]                    - Velocity of the object */
         this.velocity = new Vector2();
         /** @property {Number} [angleVelocity=0]                        - Angular velocity of the object */
         this.angleVelocity = 0;
@@ -320,7 +320,7 @@ class EngineObject
 
     /** Attaches a child to this with a given local transform
      *  @param {EngineObject} child
-     *  @param {Vector2}      [localPos=new Vector2]
+     *  @param {Vector2}      [localPos=Vector2()]
      *  @param {Number}       [localAngle=0] */
     addChild(child, localPos=vec2(), localAngle=0)
     {
@@ -341,9 +341,9 @@ class EngineObject
     }
 
     /** Set how this object collides
-     *  @param {boolean} [collideSolidObjects=1] - Does it collide with solid objects
-     *  @param {boolean} [isSolid=1]             - Does it collide with and block other objects (expensive in large numbers)
-     *  @param {boolean} [collideTiles=1]        - Does it collide with the tile collision */
+     *  @param {Boolean} [collideSolidObjects=1] - Does it collide with solid objects
+     *  @param {Boolean} [isSolid=1]             - Does it collide with and block other objects (expensive in large numbers)
+     *  @param {Boolean} [collideTiles=1]        - Does it collide with the tile collision */
     setCollision(collideSolidObjects=1, isSolid=1, collideTiles=1)
     {
         ASSERT(collideSolidObjects || !isSolid); // solid objects must be set to collide
@@ -353,6 +353,8 @@ class EngineObject
         this.collideTiles = collideTiles;
     }
 
+    /** Returns string containg info about this object for debugging
+     *  @return {String} */
     toString()
     {
         if (debug)

package/engine/engineParticles.js

@@ -34,11 +34,11 @@ class ParticleEmitter extends EngineObject
      *  @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 {Vector2} [tileSize=tileSizeDefault] - Tile size for particles
+     *  @param {Color}   [colorStartA=Color()] - Color at start of life 1, randomized between start colors
+     *  @param {Color}   [colorStartB=Color()] - Color at start of life 2, randomized between start colors
+     *  @param {Color}   [colorEndA=Color(1,1,1,0)] - Color at end of life 1, randomized between end colors
+     *  @param {Color}   [colorEndB=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