littlejsengine 1.8.9 → 1.9.1

package/src/engineInput.js

@@ -10,28 +10,37 @@
 'use strict';
 
 /** Returns true if device key is down
- *  @param {Number} key
- *  @param {Number} [device=0]
+ *  @param {String|Number} key
+ *  @param {Number} [device]
  *  @return {Boolean}
  *  @memberof Input */
 function keyIsDown(key, device=0)
-{ return inputData[device] && inputData[device][key] & 1; }
+{ 
+    ASSERT(device > 0 || typeof key !== 'number' || key < 3, 'use code string for keyboard');
+    return inputData[device] && !!(inputData[device][key] & 1); 
+}
 
 /** Returns true if device key was pressed this frame
- *  @param {Number} key
- *  @param {Number} [device=0]
+ *  @param {String|Number} key
+ *  @param {Number} [device]
  *  @return {Boolean}
  *  @memberof Input */
 function keyWasPressed(key, device=0)
-{ return inputData[device] && inputData[device][key] & 2 ? 1 : 0; }
+{ 
+    ASSERT(device > 0 || typeof key !== 'number' || key < 3, 'use code string for keyboard');
+    return inputData[device] && !!(inputData[device][key] & 2); 
+}
 
 /** Returns true if device key was released this frame
- *  @param {Number} key
- *  @param {Number} [device=0]
+ *  @param {String|Number} key
+ *  @param {Number} [device]
  *  @return {Boolean}
  *  @memberof Input */
 function keyWasReleased(key, device=0)
-{ return inputData[device] && inputData[device][key] & 4 ? 1 : 0; }
+{ 
+    ASSERT(device > 0 || typeof key !== 'number' || key < 3, 'use code string for keyboard');
+    return inputData[device] && !!(inputData[device][key] & 4);
+}
 
 /** Clears all input
  *  @memberof Input */
@@ -76,16 +85,16 @@ let mouseWheel = 0;
 /** Returns true if user is using gamepad (has more recently pressed a gamepad button)
  *  @type {Boolean}
  *  @memberof Input */
-let isUsingGamepad = 0;
+let isUsingGamepad = false;
 
 /** Prevents input continuing to the default browser handling (false by default)
  *  @type {Boolean}
  *  @memberof Input */
-let preventDefaultInput = 0;
+let preventDefaultInput = false;
 
 /** Returns true if gamepad button is down
  *  @param {Number} button
- *  @param {Number} [gamepad=0]
+ *  @param {Number} [gamepad]
  *  @return {Boolean}
  *  @memberof Input */
 function gamepadIsDown(button, gamepad=0)
@@ -93,7 +102,7 @@ function gamepadIsDown(button, gamepad=0)
 
 /** Returns true if gamepad button was pressed
  *  @param {Number} button
- *  @param {Number} [gamepad=0]
+ *  @param {Number} [gamepad]
  *  @return {Boolean}
  *  @memberof Input */
 function gamepadWasPressed(button, gamepad=0)
@@ -101,7 +110,7 @@ function gamepadWasPressed(button, gamepad=0)
 
 /** Returns true if gamepad button was released
  *  @param {Number} button
- *  @param {Number} [gamepad=0]
+ *  @param {Number} [gamepad]
  *  @return {Boolean}
  *  @memberof Input */
 function gamepadWasReleased(button, gamepad=0)
@@ -109,7 +118,7 @@ function gamepadWasReleased(button, gamepad=0)
 
 /** Returns gamepad stick value
  *  @param {Number} stick
- *  @param {Number} [gamepad=0]
+ *  @param {Number} [gamepad]
  *  @return {Vector2}
  *  @memberof Input */
 function gamepadStick(stick,  gamepad=0)
@@ -152,9 +161,10 @@ function inputUpdatePost()
         if (debug && e.target != document.body) return;
         if (!e.repeat)
         {
-            inputData[isUsingGamepad = 0][e.which] = 3;
+            isUsingGamepad = false;
+            inputData[0][e.code] = 3;
             if (inputWASDEmulateDirection)
-                inputData[0][remapKey(e.which)] = 3;
+                inputData[0][remapKey(e.code)] = 3;
         }
         preventDefaultInput && e.preventDefault();
     }
@@ -162,26 +172,29 @@ function inputUpdatePost()
     onkeyup = (e)=>
     {
         if (debug && e.target != document.body) return;
-        inputData[0][e.which] = 4;
+        inputData[0][e.code] = 4;
         if (inputWASDEmulateDirection)
-            inputData[0][remapKey(e.which)] = 4;
+            inputData[0][remapKey(e.code)] = 4;
     }
 
     // handle remapping wasd keys to directions
     function remapKey(c)
-    { 
+    {
         return inputWASDEmulateDirection ? 
-            c==87?38 : c==83?40 : c==65?37 : c==68?39 : c : c; 
+            c == 'KeyW' ? 'ArrowUp' : 
+            c == 'KeyS' ? 'ArrowDown' : 
+            c == 'KeyA' ? 'ArrowLeft' : 
+            c == 'KeyD' ? 'ArrowRight' : c : c;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Mouse event handlers
 
-onmousedown = (e)=> {inputData[isUsingGamepad = 0][e.button] = 3; onmousemove(e); e.button && e.preventDefault();}
+onmousedown = (e)=> {isUsingGamepad = false; inputData[0][e.button] = 3; mousePosScreen = mouseToScreen(e); e.button && e.preventDefault();}
 onmouseup   = (e)=> inputData[0][e.button] = inputData[0][e.button] & 2 | 4;
 onmousemove = (e)=> mousePosScreen = mouseToScreen(e);
-onwheel = (e)=> e.ctrlKey || (mouseWheel = sign(e.deltaY));
+onwheel     = (e)=> mouseWheel = e.ctrlKey ? 0 : sign(e.deltaY);
 oncontextmenu = (e)=> false; // prevent right click menu
 
 // convert a mouse or touch event position to screen space
@@ -219,7 +232,7 @@ function gamepadsUpdate()
             for (let i=10; i--;)
             {
                 const j = i == 3 ? 2 : i == 2 ? 3 : i; // fix button locations
-                data[j] = touchGamepadButtons[i] ? 1 + 2*!gamepadIsDown(j,0) : 4*gamepadIsDown(j,0);
+                data[j] = touchGamepadButtons[i] ? gamepadIsDown(j,0) ? 1 : 3 : gamepadIsDown(j,0) ? 4 : 0;
             }
         }
     }
@@ -251,18 +264,23 @@ function gamepadsUpdate()
             for (let j = gamepad.buttons.length; j--;)
             {
                 const button = gamepad.buttons[j];
-                data[j] = button.pressed ? 1 + 2*!gamepadIsDown(j,i) : 4*gamepadIsDown(j,i);
-                isUsingGamepad |= !i && button.pressed;
-                touchGamepadEnable && touchGamepadTimer.unset(); // disable touch gamepad if using real gamepad
+                const wasDown = gamepadIsDown(j,i);
+                data[j] = button.pressed ? wasDown ? 1 : 3 : wasDown ? 4 : 0;
+                isUsingGamepad ||= !i && button.pressed;
             }
 
             if (gamepadDirectionEmulateStick)
             {
                 // copy dpad to left analog stick when pressed
-                const dpad = vec2(gamepadIsDown(15,i) - gamepadIsDown(14,i), gamepadIsDown(12,i) - gamepadIsDown(13,i));
+                const dpad = vec2(
+                    (gamepadIsDown(15,i)&&1) - (gamepadIsDown(14,i)&&1), 
+                    (gamepadIsDown(12,i)&&1) - (gamepadIsDown(13,i)&&1));
                 if (dpad.lengthSquared())
                     sticks[0] = dpad.clampLength();
             }
+
+            // disable touch gamepad if using real gamepad
+            touchGamepadEnable && isUsingGamepad && touchGamepadTimer.unset(); 
         }
     }
 }
@@ -270,9 +288,9 @@ function gamepadsUpdate()
 ///////////////////////////////////////////////////////////////////////////////
 
 /** Pulse the vibration hardware if it exists
- *  @param {Number} [pattern=100] - a single value in miliseconds or vibration interval array
+ *  @param {Number|Array} [pattern] - single value in ms or vibration interval array
  *  @memberof Input */
-function vibrate(pattern)
+function vibrate(pattern=100)
 { vibrateEnable && navigator && navigator.vibrate && navigator.vibrate(pattern); }
 
 /** Cancel any ongoing vibration
@@ -290,29 +308,28 @@ const isTouchDevice = window.ontouchstart !== undefined;
 if (isTouchDevice)
 {
     // override mouse events
-    let wasTouching, mouseDown = onmousedown, mouseUp = onmouseup;
+    let wasTouching;
     onmousedown = onmouseup = ()=> 0;
 
     // handle all touch events the same way
     ontouchstart = ontouchmove = ontouchend = (e)=>
     {
-        e.button = 0; // all touches are left click
-
         // fix stalled audio on mobile
         if (soundEnable)
             audioContext ? audioContext.resume() : zzfx(0);
 
         // check if touching and pass to mouse events
         const touching = e.touches.length;
+        const button = 0; // all touches are left mouse button
         if (touching)
         {
             // set event pos and pass it along
-            e.x = e.touches[0].clientX;
-            e.y = e.touches[0].clientY;
-            wasTouching ? onmousemove(e) : mouseDown(e);
+            const p = vec2(e.touches[0].clientX, e.touches[0].clientY);
+            mousePosScreen = mouseToScreen(p);
+            wasTouching ? isUsingGamepad = false : inputData[0][button] = 3;
         }
         else if (wasTouching)
-            mouseUp(e);
+            inputData[0][button] = inputData[0][button] & 2 | 4;
 
         // set was touching
         wasTouching = touching;
@@ -393,8 +410,8 @@ function createTouchGamepad()
         }
 
         // call default touch handler and set to using gamepad
-        touchHandler(e);
-        isUsingGamepad = 1;
+        touchHandler.bind(window)(e);
+        isUsingGamepad = true;
         
         // must return true so the document will get focus
         return true;
@@ -408,7 +425,7 @@ function touchGamepadRender()
         return;
     
     // fade off when not touching or paused
-    const alpha = percent(touchGamepadTimer, 4, 3);
+    const alpha = percent(touchGamepadTimer.get(), 4, 3);
     if (!alpha || paused)
         return;
 

package/src/engineMedals.js

@@ -48,7 +48,7 @@ class Medal
      *  @param {Number} id            - The unique identifier of the medal
      *  @param {String} name          - Name of the medal
      *  @param {String} [description] - Description of the medal
-     *  @param {String} [icon='🏆']  - Icon for the medal
+     *  @param {String} [icon]        - Icon for the medal
      *  @param {String} [src]         - Image location for the medal
      */
     constructor(id, name, description='', icon='🏆', src)
@@ -71,14 +71,14 @@ class Medal
             return;
 
         // save the medal
-        ASSERT(medalsSaveName); // save name must be set
+        ASSERT(medalsSaveName, 'save name must be set');
         localStorage[this.storageKey()] = this.unlocked = 1;
         medalsDisplayQueue.push(this);
         newgrounds && newgrounds.unlockMedal(this.id);
     }
 
     /** Render a medal
-     *  @param {Number} [hidePercent=0] - How much to slide the medal off screen
+     *  @param {Number} [hidePercent] - How much to slide the medal off screen
      */
     render(hidePercent=0)
     {
@@ -90,25 +90,25 @@ class Medal
         // draw containing rect and clip to that region
         context.save();
         context.beginPath();
-        context.fillStyle = new Color(.9,.9,.9);
-        context.strokeStyle = new Color(0,0,0);
+        context.fillStyle = rgb(.9,.9,.9).toString();
+        context.strokeStyle = rgb(0,0,0).toString();
         context.lineWidth = 3;
-        context.fill(context.rect(x, y, width, medalDisplaySize.y));
+        context.rect(x, y, width, medalDisplaySize.y);
+        context.fill();
         context.stroke();
         context.clip();
 
         // draw the icon and text
         this.renderIcon(vec2(x+15+medalDisplayIconSize/2, y+medalDisplaySize.y/2));
         const pos = vec2(x+medalDisplayIconSize+30, y+28);
-        drawTextScreen(this.name, pos, 38, new Color(0,0,0), 0, 0, 'left');
+        drawTextScreen(this.name, pos, 38, new Color(0,0,0), 0, undefined, 'left');
         pos.y += 32;
-        drawTextScreen(this.description, pos, 24, new Color(0,0,0), 0, 0, 'left');
+        drawTextScreen(this.description, pos, 24, new Color(0,0,0), 0, undefined, 'left');
         context.restore();
     }
 
     /** Render the icon for a medal
-     *  @param {Number} x - Screen space X position
-     *  @param {Number} y - Screen space Y position
+     *  @param {Vector2} pos - Screen space position
      *  @param {Number} [size=medalDisplayIconSize] - Screen space size
      */
     renderIcon(pos, size=medalDisplayIconSize)
@@ -136,7 +136,10 @@ function medalsRender()
     if (!medalsDisplayTimeLast)
         medalsDisplayTimeLast = timeReal;
     else if (time > medalDisplayTime)
-        medalsDisplayQueue.shift(medalsDisplayTimeLast = 0);
+    {
+        medalsDisplayTimeLast = 0;
+        medalsDisplayQueue.shift();
+    }
     else
     {
         // slide on/off medals
@@ -176,8 +179,8 @@ class Newgrounds
      *  @param {Object} [cryptoJS] - An instance of CryptoJS, if there is a cipher */
     constructor(app_id, cipher, cryptoJS)
     {
-        ASSERT(!newgrounds && app_id); // can only be one newgrounds object
-        ASSERT(!cipher || cryptoJS);   // must provide cryptojs if there is a cipher
+        ASSERT(!newgrounds && app_id>0, 'there can only be one newgrounds object');
+        ASSERT(!cipher || cryptoJS, 'must provide cryptojs if there is a cipher');
 
         this.app_id = app_id;
         this.cipher = cipher;
@@ -220,39 +223,39 @@ class Newgrounds
         debugMedals && console.log(this.scoreboards);
 
         const keepAliveMS = 5 * 60 * 1e3;
-        setInterval(()=>this.call('Gateway.ping', 0, 1), keepAliveMS);
+        setInterval(()=>this.call('Gateway.ping', 0, true), keepAliveMS);
     }
 
     /** Send message to unlock a medal by id
      * @param {Number} id - The medal id */
-    unlockMedal(id) { return this.call('Medal.unlock', {'id':id}, 1); }
+    unlockMedal(id) { return this.call('Medal.unlock', {'id':id}, true); }
 
     /** Send message to post score
      * @param {Number} id    - The scoreboard id
      * @param {Number} value - The score value */
-    postScore(id, value) { return this.call('ScoreBoard.postScore', {'id':id, 'value':value}, 1); }
+    postScore(id, value) { return this.call('ScoreBoard.postScore', {'id':id, 'value':value}, true); }
 
     /** Get scores from a scoreboard
-     * @param {Number} id         - The scoreboard id
-     * @param {String} [user=0]   - A user's id or name
-     * @param {Number} [social=0] - If true, only social scores will be loaded
-     * @param {Number} [skip=0]   - Number of scores to skip before start
-     * @param {Number} [limit=10] - Number of scores to include in the list
-     * @return {Object}           - The response JSON object
+     * @param {Number} id       - The scoreboard id
+     * @param {String} [user]   - A user's id or name
+     * @param {Number} [social] - If true, only social scores will be loaded
+     * @param {Number} [skip]   - Number of scores to skip before start
+     * @param {Number} [limit]  - Number of scores to include in the list
+     * @return {Object}         - The response JSON object
      */
-    getScores(id, user=0, social=0, skip=0, limit=10)
+    getScores(id, user, social=0, skip=0, limit=10)
     { return this.call('ScoreBoard.getScores', {'id':id, 'user':user, 'social':social, 'skip':skip, 'limit':limit}); }
 
     /** Send message to log a view */
-    logView() { return this.call('App.logView', {'host':this.host}, 1); }
+    logView() { return this.call('App.logView', {'host':this.host}, true); }
 
     /** Send a message to call a component of the Newgrounds API
-     * @param {String}  component      - Name of the component
-     * @param {Object}  [parameters=0] - Parameters to use for call
-     * @param {Boolean} [async=0]      - If true, don't wait for response before continuing (avoid stall)
-     * @return {Object}                - The response JSON object
+     * @param {String}  component    - Name of the component
+     * @param {Object}  [parameters] - Parameters to use for call
+     * @param {Boolean} [async]      - If true, don't wait for response before continuing
+     * @return {Object}              - The response JSON object
      */
-    call(component, parameters=0, async=0)
+    call(component, parameters, async=false)
     {
         const call = {'component':component, 'parameters':parameters};
         if (this.cipher)

package/src/engineObject.js

@@ -32,27 +32,25 @@
 class EngineObject
 {
     /** Create an engine object and adds it to the list of objects
-     *  @param {Vector2} [pos=Vector2()]            - World space position of the object
-     *  @param {Vector2} [size=Vector2(1,1)]        - World space size of the object
-     *  @param {TileInfo} [tileInfo]                - Tile info to render object (undefined is untextured)
-     *  @param {Number}  [angle=0]                  - Angle the object is rotated by
-     *  @param {Color}   [color=Color()]            - Color to apply to tile when rendered
-     *  @param {Number}  [renderOrder=0]            - Objects sorted by renderOrder before being rendered
+     *  @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 {Color}    [color=(1,1,1,1)] - Color to apply to tile when rendered
+     *  @param {Number}   [renderOrder]     - Objects sorted by renderOrder before being rendered
      */
     constructor(pos=vec2(), size=vec2(1), tileInfo, angle=0, color, renderOrder=0)
     {
         // set passed in params
-        ASSERT(isVector2(pos) && isVector2(size)); // ensure pos and size are vec2s
-        ASSERT(typeof tileInfo !== 'number' || !tileInfo); // prevent old style calls
-        ASSERT(!(renderOrder instanceof Color)); // prevent old style calls
-        // to fix old calls, replace with tile(tileIndex, tileSize)
+        ASSERT(isVector2(pos) && isVector2(size), 'ensure pos and size are vec2s');
+        ASSERT(typeof tileInfo !== 'number' || !tileInfo, 'old style tile setup');
 
         /** @property {Vector2} - World space position of the object */
         this.pos = pos.copy();
         /** @property {Vector2} - World space width and height of the object */
         this.size = size;
         /** @property {Vector2} - Size of object used for drawing, uses size if not set */
-        this.drawSize;
+        this.drawSize = undefined;
         /** @property {TileInfo} - Tile info to render object (undefined is untextured) */
         this.tileInfo = tileInfo;
         /** @property {Number}  - Angle to rotate the object */
@@ -60,9 +58,11 @@ class EngineObject
         /** @property {Color}   - Color to apply when rendered */
         this.color = color;
         /** @property {Color}   - Additive color to apply when rendered */
-        this.additiveColor;
+        this.additiveColor = undefined;
+        /** @property {Boolean} - Should it flip along y axis when rendered */
+        this.mirror = false;
 
-        // set object defaults
+        // physical properties
         /** @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) */
@@ -73,19 +73,34 @@ class EngineObject
         this.elasticity   = objectDefaultElasticity;
         /** @property {Number} [friction=objectDefaultFriction]         - How much friction to apply when sliding (0-1) */
         this.friction     = objectDefaultFriction;
-        /** @property {Number} [gravityScale=1]                         - 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} [renderOrder=0]                          - Objects are sorted by render order */
+        /** @property {Number}  - Objects are sorted by render order */
         this.renderOrder = renderOrder;
-        /** @property {Vector2} [velocity=Vector2()]                    - Velocity of the object */
+        /** @property {Vector2} - Velocity of the object */
         this.velocity = vec2();
-        /** @property {Number} [angleVelocity=0]                        - Angular velocity of the object */
+        /** @property {Number}  - Angular velocity of the object */
         this.angleVelocity = 0;
-
-        // init other internal object stuff
+        /** @property {Number}  - Track when object was created  */
         this.spawnTime = time;
+        /** @property {Array}   - List of children of this object */
         this.children = [];
+
+        // 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  */
+        this.localAngle = 0;
+
+        // collision flags
+        /** @property {Boolean} - Object collides with the tile collision */
         this.collideTiles = false;
+        /** @property {Boolean} - Object collides with solid objects */
+        this.collideSolidObjects = false;
+        /** @property {Boolean} - Object collides with and blocks other objects */
+        this.isSolid = false;
 
         // add to list of objects
         engineObjects.push(this);
@@ -302,7 +317,7 @@ class EngineObject
      *  @param {EngineObject} object - the object to test against
      *  @return {Boolean}            - true if the collision should be resolved
      */
-    collideWithObject(object)         { return 1; }
+    collideWithObject(object)         { return true; }
 
     /** How long since the object was created
      *  @return {Number} */
@@ -322,8 +337,8 @@ class EngineObject
 
     /** Attaches a child to this with a given local transform
      *  @param {EngineObject} child
-     *  @param {Vector2}      [localPos=Vector2()]
-     *  @param {Number}       [localAngle=0] */
+     *  @param {Vector2}      [localPos=(0,0)]
+     *  @param {Number}       [localAngle] */
     addChild(child, localPos=vec2(), localAngle=0)
     {
         ASSERT(!child.parent && !this.children.includes(child));
@@ -343,12 +358,12 @@ 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 */
-    setCollision(collideSolidObjects=1, isSolid=1, collideTiles=1)
+     *  @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 */
+    setCollision(collideSolidObjects=true, isSolid=true, collideTiles=true)
     {
-        ASSERT(collideSolidObjects || !isSolid); // solid objects must be set to collide
+        ASSERT(collideSolidObjects || !isSolid, 'solid objects must be set to collide');
 
         this.collideSolidObjects = collideSolidObjects;
         this.isSolid = isSolid;