littlejsengine 1.10.4 → 1.11.1

package/dist/littlejs.release.js

@@ -239,7 +239,8 @@ function formatTime(t) { return (t/60|0) + ':' + (t%60<10?'0':'') + (t%60|0); }
  *  @memberof Random */
 function rand(valueA=1, valueB=0) { return valueB + Math.random() * (valueA-valueB); }
 
-/** Returns a floored random value the two values passed in
+/** Returns a floored random value between the two values passed in
+ *  The upper bound is exclusive. (If 2 is passed in, result will be 0 or 1)
  *  @param {Number} valueA
  *  @param {Number} [valueB]
  *  @return {Number}
@@ -368,18 +369,24 @@ class Vector2
      *  @param {Number} [y] - Y axis location */
     constructor(x=0, y=0)
     {
-        ASSERT(typeof x == 'number' && typeof y == 'number');
         /** @property {Number} - X axis location */
         this.x = x;
         /** @property {Number} - Y axis location */
         this.y = y;
+        ASSERT(this.isValid());
     }
 
     /** Sets values of this vector and returns self
      *  @param {Number} [x] - X axis location
      *  @param {Number} [y] - Y axis location
      *  @return {Vector2} */
-    set(x=0, y=0) { this.x=x; this.y=y; return this; }
+    set(x=0, y=0)
+    {
+        this.x = x;
+        this.y = y;
+        ASSERT(this.isValid());
+        return this;
+    }
 
     /** Returns a new vector that is a copy of this
      *  @return {Vector2} */
@@ -571,6 +578,14 @@ class Vector2
         if (debug)
             return `(${(this.x<0?'':' ') + this.x.toFixed(digits)},${(this.y<0?'':' ') + this.y.toFixed(digits)} )`;
     }
+
+    /** Checks if this is a valid vector
+     * @return {Boolean} */
+    isValid()
+    {
+        return typeof this.x == 'number' && !isNaN(this.x)
+            && typeof this.y == 'number' && !isNaN(this.y);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -631,6 +646,7 @@ class Color
         this.b = b;
         /** @property {Number} - Alpha */
         this.a = a;
+        ASSERT(this.isValid());
     }
 
     /** Sets values of this color and returns self
@@ -640,7 +656,14 @@ class Color
      *  @param {Number} [a] - alpha
      *  @return {Color} */
     set(r=1, g=1, b=1, a=1)
-    { this.r=r; this.g=g; this.b=b; this.a=a; return this; }
+    {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+        ASSERT(this.isValid());
+        return this;
+    }
 
     /** Returns a new color that is a copy of this
      * @return {Color} */
@@ -723,6 +746,7 @@ class Color
         this.g = f(p, q, h);
         this.b = f(p, q, h - 1/3);
         this.a = a;
+        ASSERT(this.isValid());
         return this;
     }
 
@@ -750,7 +774,6 @@ class Color
             else if (b == max)
                 h =  (r - g) / d + 4;
         }
-
         return [h / 6, s, l, a];
     }
 
@@ -783,11 +806,27 @@ class Color
      * @return {Color} */
     setHex(hex)
     {
-        const fromHex = (c)=> clamp(parseInt(hex.slice(c,c+2),16)/255);
-        this.r = fromHex(1);
-        this.g = fromHex(3),
-        this.b = fromHex(5);
-        this.a = hex.length > 7 ? fromHex(7) : 1;
+        ASSERT(typeof hex == 'string' && hex[0] == '#');
+        ASSERT([4,5,7,9].includes(hex.length), 'Invalid hex');
+
+        if (hex.length < 6)
+        {
+            const fromHex = (c)=> clamp(parseInt(hex[c],16)/15);
+            this.r = fromHex(1);
+            this.g = fromHex(2),
+            this.b = fromHex(3);
+            this.a = hex.length == 5 ? fromHex(4) : 1;
+        }
+        else
+        {
+            const fromHex = (c)=> clamp(parseInt(hex.slice(c,c+2),16)/255);
+            this.r = fromHex(1);
+            this.g = fromHex(3),
+            this.b = fromHex(5);
+            this.a = hex.length == 9 ? fromHex(7) : 1;
+        }
+
+        ASSERT(this.isValid());
         return this;
     }
     
@@ -801,6 +840,16 @@ class Color
         const a = clamp(this.a)*255<<24;
         return r + g + b + a;
     }
+
+    /** Checks if this is a valid color
+     * @return {Boolean} */
+    isValid()
+    {
+        return typeof this.r == 'number' && !isNaN(this.r)
+            && typeof this.g == 'number' && !isNaN(this.g)
+            && typeof this.b == 'number' && !isNaN(this.b)
+            && typeof this.a == 'number' && !isNaN(this.a);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -952,12 +1001,18 @@ let canvasMaxSize = vec2(1920, 1080);
  *  @memberof Settings */
 let canvasFixedSize = vec2();
 
-/** Disables filtering for crisper pixel art if true
+/** Use nearest neighbor scaling algorithm for canvas for more pixelated look
  *  @type {Boolean}
  *  @default
  *  @memberof Settings */
 let canvasPixelated = true;
 
+/** Disables texture filtering for crisper pixel art
+ *  @type {Boolean}
+ *  @default
+ *  @memberof Settings */
+let tilesPixelated = true;
+
 /** Default font used for text rendering
  *  @type {String}
  *  @default
@@ -1206,11 +1261,16 @@ function setCanvasMaxSize(size) { canvasMaxSize = size; }
  *  @memberof Settings */
 function setCanvasFixedSize(size) { canvasFixedSize = size; }
 
-/** Disables anti aliasing for pixel art if true
+/** Use nearest neighbor scaling algorithm for canvas for more pixelated look
  *  @param {Boolean} pixelated
  *  @memberof Settings */
 function setCanvasPixelated(pixelated) { canvasPixelated = pixelated; }
 
+/** Disables texture filtering for crisper pixel art
+ *  @param {Boolean} pixelated
+ *  @memberof Settings */
+function setTilesPixelated(pixelated) { tilesPixelated = pixelated; }
+
 /** Set default font used for text rendering
  *  @param {String} font
  *  @memberof Settings */
@@ -1436,7 +1496,7 @@ class EngineObject
      *  @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)
+    constructor(pos=vec2(), size=vec2(1), tileInfo, angle=0, color=new Color, renderOrder=0)
     {
         // set passed in params
         ASSERT(isVector2(pos) && isVector2(size), 'ensure pos and size are vec2s');
@@ -1550,15 +1610,18 @@ class EngineObject
 
         // apply physics
         const oldPos = this.pos.copy();
-        this.pos.x += this.velocity.x *= this.damping;
-        this.pos.y += this.velocity.y = this.damping * this.velocity.y 
-            + gravity * this.gravityScale;
+        this.velocity.x *= this.damping;
+        this.velocity.y *= this.damping;
+        if (this.mass) // dont apply gravity to static objects
+            this.velocity.y += gravity * this.gravityScale;
+        this.pos.x += this.velocity.x;
+        this.pos.y += this.velocity.y;
         this.angle += this.angleVelocity *= this.angleDamping;
 
         // physics sanity checks
         ASSERT(this.angleDamping >= 0 && this.angleDamping <= 1);
         ASSERT(this.damping >= 0 && this.damping <= 1);
-        if (!enablePhysicsSolver || !this.mass) // dont do collision for fixed objects
+        if (!enablePhysicsSolver || !this.mass) // dont do collision for static objects
             return;
 
         const wasMovingDown = this.velocity.y < 0;
@@ -1919,7 +1982,7 @@ let drawCount;
  * tile(2)                       // a tile at index 2 using the default tile size of 16
  * tile(5, 8)                    // a tile at index 5 using a tile size of 8
  * tile(1, 16, 3)                // a tile at index 1 of size 16 on texture 3
- * tile(vec2(4,8), vec2(30,10))  // a tile at pixel location (4,8) with a size of (30,10)
+ * tile(vec2(4,8), vec2(30,10))  // a tile at index (4,8) with a size of (30,10)
  * @memberof Draw
  */
 function tile(pos=vec2(), size=tileSizeDefault, textureIndex=0, padding=0)
@@ -2264,6 +2327,24 @@ function setBlendMode(additive, useWebGL=glEnable, context)
     }
 }
 
+/** Draw text on main canvas in world space
+ *  Automatically splits new lines into rows
+ *  @param {String}  text
+ *  @param {Vector2} pos
+ *  @param {Number}  [size]
+ *  @param {Color}   [color=(1,1,1,1)]
+ *  @param {Number}  [lineWidth]
+ *  @param {Color}   [lineColor=(0,0,0,1)]
+ *  @param {CanvasTextAlign}  [textAlign='center']
+ *  @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)
+{
+    drawTextScreen(text, worldToScreen(pos), size*cameraScale, color, lineWidth*cameraScale, lineColor, textAlign, font, maxWidth, context);
+}
+
 /** Draw text on overlay canvas in world space
  *  Automatically splits new lines into rows
  *  @param {String}  text
@@ -2274,12 +2355,11 @@ function setBlendMode(additive, useWebGL=glEnable, context)
  *  @param {Color}   [lineColor=(0,0,0,1)]
  *  @param {CanvasTextAlign}  [textAlign='center']
  *  @param {String}  [font=fontDefault]
- *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=overlayContext]
  *  @param {Number}  [maxWidth]
  *  @memberof Draw */
-function drawText(text, pos, size=1, color, lineWidth=0, lineColor, textAlign, font, context, maxWidth)
+function drawTextOverlay(text, pos, size=1, color, lineWidth=0, lineColor, textAlign, font, maxWidth)
 {
-    drawTextScreen(text, worldToScreen(pos), size*cameraScale, color, lineWidth*cameraScale, lineColor, textAlign, font, context, maxWidth);
+    drawText(text, pos, size, color, lineWidth, lineColor, textAlign, font, maxWidth, overlayContext);
 }
 
 /** Draw text on overlay canvas in screen space
@@ -2292,10 +2372,10 @@ function drawText(text, pos, size=1, color, lineWidth=0, lineColor, textAlign, f
  *  @param {Color}   [lineColor=(0,0,0,1)]
  *  @param {CanvasTextAlign}  [textAlign]
  *  @param {String}  [font=fontDefault]
- *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=overlayContext]
  *  @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, context=overlayContext, maxWidth=undefined)
+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)
 {
     context.fillStyle = color.toString();
     context.lineWidth = lineWidth;
@@ -2371,7 +2451,6 @@ class FontImage
     {
         const context = this.context;
         context.save();
-        context.imageSmoothingEnabled = !canvasPixelated;
 
         const size = this.tileSize;
         const drawSize = size.add(this.paddingSize).scale(scale);
@@ -2468,7 +2547,7 @@ function keyWasReleased(key, device=0)
 
 /** Clears all input
  *  @memberof Input */
-function clearInput() { inputData = [[]]; }
+function clearInput() { inputData = [[]]; touchGamepadButtons = []; }
 
 /** Returns true if mouse button is down
  *  @function
@@ -2633,6 +2712,7 @@ function inputInit()
     onmousemove   = (e)=> mousePosScreen = mouseToScreen(e);
     onwheel       = (e)=> mouseWheel = e.ctrlKey ? 0 : sign(e.deltaY);
     oncontextmenu = (e)=> false; // prevent right click menu
+    onblur        = (e) => clearInput(); // reset input when focus is lost
 
     // init touch input
     if (isTouchDevice && touchInputEnable)
@@ -2831,10 +2911,13 @@ function touchInputInit()
         if (touching)
         {
             touchGamepadTimer.set();
-            if (paused)
+            if (paused && !wasTouching)
             {
                 // touch anywhere to press start when paused
                 touchGamepadButtons[9] = 1;
+
+                // call default touch handler so normal touch events still work
+                handleTouchDefault(e);
                 return;
             }
         }
@@ -2859,7 +2942,7 @@ function touchInputInit()
                 const button = touchPos.subtract(buttonCenter).direction();
                 touchGamepadButtons[button] = 1;
             }
-            else if (touchPos.distance(startCenter) < touchGamepadSize)
+            else if (touchPos.distance(startCenter) < touchGamepadSize && !wasTouching)
             {
                 // virtual start button in center
                 touchGamepadButtons[9] = 1;
@@ -2947,7 +3030,7 @@ function touchGamepadRender()
 /** Audio context used by the engine
  *  @type {AudioContext}
  *  @memberof Audio */
-let audioContext;
+let audioContext = new AudioContext;
 
 /** Master gain node for all audio to pass through
  *  @type {GainNode}
@@ -2958,14 +3041,10 @@ function audioInit()
 {
     if (!soundEnable || headlessMode) return;
     
-    // create audio context
-    audioContext = new AudioContext;
-
-    // create and connect gain node
     // (createGain is more widely spported then GainNode construtor)
     audioGainNode = audioContext.createGain();
     audioGainNode.connect(audioContext.destination);
-    setSoundVolume(soundVolume); // update gain volume
+    audioGainNode.gain.value = soundVolume; // set starting value
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -3005,7 +3084,7 @@ class Sound
         {
             // generate zzfx sound now for fast playback
             const defaultRandomness = .05;
-            this.randomness = zzfxSound[1] || defaultRandomness;
+            this.randomness = zzfxSound[1] != undefined ? zzfxSound[1] : defaultRandomness;
             zzfxSound[1] = 0; // generate without randomness
             this.sampleChannels = [zzfxG(...zzfxSound)];
             this.sampleRate = zzfxR;
@@ -3047,10 +3126,11 @@ class Sound
         // play the sound
         const playbackRate = pitch + pitch * this.randomness*randomnessScale*rand(-1,1);
         this.gainNode = audioContext.createGain();
-        return this.source = playSamples(this.sampleChannels, volume, playbackRate, pan, loop, this.sampleRate, this.gainNode);
+        this.source = playSamples(this.sampleChannels, volume, playbackRate, pan, loop, this.sampleRate, this.gainNode);
+        return this.source;
     }
 
-    /** Set the sound volume
+    /** Set the sound volume of the most recently played instance of this sound
      *  @param {Number}  [volume] - How much to scale volume by
      */
     setVolume(volume=1)
@@ -3541,18 +3621,18 @@ function zzfxM(instruments, patterns, sequence, BPM = 125)
 
 
 
-/** The tile collision layer array, use setTileCollisionData and getTileCollisionData to access
+/** The tile collision layer grid, use setTileCollisionData and getTileCollisionData to access
  *  @type {Array} 
  *  @memberof TileCollision */
 let tileCollision = [];
 
-/** Size of the tile collision layer
+/** Size of the tile collision layer 2d grid
  *  @type {Vector2} 
  *  @memberof TileCollision */
 let tileCollisionSize = vec2();
 
 /** Clear and initialize tile collision
- *  @param {Vector2} size
+ *  @param {Vector2} size - width and height of tile collision 2d grid
  *  @memberof TileCollision */
 function initTileCollision(size)
 {
@@ -3562,7 +3642,7 @@ function initTileCollision(size)
         tileCollision[i] = 0;
 }
 
-/** Set tile collision data
+/** Set tile collision data for a given cell in the grid
  *  @param {Vector2} pos
  *  @param {Number}  [data]
  *  @memberof TileCollision */
@@ -3571,7 +3651,7 @@ function setTileCollisionData(pos, data=0)
     pos.arrayCheck(tileCollisionSize) && (tileCollision[(pos.y|0)*tileCollisionSize.x+pos.x|0] = data);
 }
 
-/** Get tile collision data
+/** Get tile collision data for a given cell in the grid
  *  @param {Vector2} pos
  *  @return {Number}
  *  @memberof TileCollision */
@@ -3602,7 +3682,8 @@ function tileCollisionTest(pos, size=vec2(), object)
     return false;
 }
 
-/** Return the center of first tile hit (does not return the exact intersection)
+/** Return the center of first tile hit, undefined if nothing was hit.
+ *  This does not return the exact intersection, but the center of the tile hit.
  *  @param {Vector2}      posStart
  *  @param {Vector2}      posEnd
  *  @param {EngineObject} [object]
@@ -3810,7 +3891,7 @@ class TileLayer extends EngineObject
         }
 
         // disable smoothing for pixel art
-        this.context.imageSmoothingEnabled = !canvasPixelated;
+        this.context.imageSmoothingEnabled = !tilesPixelated;
 
         // setup gl rendering if enabled
         glPreRender();
@@ -3847,8 +3928,8 @@ class TileLayer extends EngineObject
         const d = this.getData(layerPos);
         if (d.tile != undefined)
         {
-            const pos = this.pos.add(layerPos).add(vec2(.5));
             ASSERT(mainContext == this.context, 'must call redrawStart() before drawing tiles');
+            const pos = layerPos.add(vec2(.5));
             const tileInfo = tile(d.tile, s, this.tileInfo.textureIndex);
             drawTile(pos, vec2(1), tileInfo, d.color, d.direction*PI/2, d.mirror);
         }
@@ -4277,7 +4358,7 @@ function medalsInit(saveName)
     // check if medals are unlocked
     medalsSaveName = saveName;
     if (!debugMedals)
-        medalsForEach(medal=> medal.unlocked = (localStorage[medal.storageKey()] | 0));
+        medalsForEach(medal=> medal.unlocked = !!localStorage[medal.storageKey()]);
 
     // engine automatically renders medals
     engineAddPlugin(undefined, medalsRender);
@@ -4340,14 +4421,28 @@ class Medal
     constructor(id, name, description='', icon='🏆', src)
     {
         ASSERT(id >= 0 && !medals[id]);
-
-        // save attributes and add to list of medals
-        medals[this.id = id] = this;
+        
+        /** @property {Number} - The unique identifier of the medal */
+        this.id = id;
+        
+        /** @property {String} - Name of the medal */
         this.name = name;
+        
+        /** @property {String} - Description of the medal */
         this.description = description;
+        
+        /** @property {String} - Icon for the medal */
         this.icon = icon;
+        
+        /** @property {Boolean} - Is the medal unlocked? */
+        this.unlocked = false;
+
+        // load the source image if provided
         if (src)
             (this.image = new Image).src = src;
+
+        // add this to list of medals
+        medals[id] = this;
     }
 
     /** Unlocks a medal if not already unlocked */
@@ -4358,7 +4453,7 @@ class Medal
 
         // save the medal
         ASSERT(medalsSaveName, 'save name must be set');
-        localStorage[this.storageKey()] = this.unlocked = 1;
+        localStorage[this.storageKey()] = this.unlocked = true;
         medalsDisplayQueue.push(this);
     }
 
@@ -4617,7 +4712,7 @@ function glCreateTexture(image)
     }
 
     // use point filtering for pixelated rendering
-    const filter = canvasPixelated ? gl_NEAREST : gl_LINEAR;
+    const filter = tilesPixelated ? gl_NEAREST : gl_LINEAR;
     glContext.texParameteri(gl_TEXTURE_2D, gl_TEXTURE_MIN_FILTER, filter);
     glContext.texParameteri(gl_TEXTURE_2D, gl_TEXTURE_MAG_FILTER, filter);
     return texture;
@@ -4766,7 +4861,7 @@ const engineName = 'LittleJS';
  *  @type {String}
  *  @default
  *  @memberof Engine */
-const engineVersion = '1.10.4';
+const engineVersion = '1.11.1';
 
 /** Frames per second to update
  *  @type {Number}
@@ -4829,6 +4924,8 @@ const pluginUpdateList = [], pluginRenderList = [];
  *  @memberof Engine */
 function engineAddPlugin(updateFunction, renderFunction)
 {
+    ASSERT(!pluginUpdateList.includes(updateFunction));
+    ASSERT(!pluginRenderList.includes(renderFunction));
     updateFunction && pluginUpdateList.push(updateFunction);
     renderFunction && pluginRenderList.push(renderFunction);
 }
@@ -4837,12 +4934,12 @@ function engineAddPlugin(updateFunction, renderFunction)
 // Main engine functions
 
 /** Startup LittleJS engine with your callback functions
- *  @param {Function} gameInit       - Called once after the engine starts up, setup the game
- *  @param {Function} gameUpdate     - Called every frame at 60 frames per second, handle input and update the game state
- *  @param {Function} gameUpdatePost - Called after physics and objects are updated, setup camera and prepare for render
- *  @param {Function} gameRender     - Called before objects are rendered, draw any background effects that appear behind objects
- *  @param {Function} gameRenderPost - Called after objects are rendered, draw effects or hud that appear above all objects
- *  @param {Array} [imageSources=[]] - Image to load
+ *  @param {Function|function():Promise} gameInit - Called once after the engine starts up
+ *  @param {Function} gameUpdate - Called every frame before objects are updated
+ *  @param {Function} gameUpdatePost - Called after physics and objects are updated, even when paused
+ *  @param {Function} gameRender - Called before objects are rendered, for drawing the background
+ *  @param {Function} gameRenderPost - Called after objects are rendered, useful for drawing UI
+ *  @param {Array} [imageSources=[]] - List of images to load
  *  @param {HTMLElement} [rootElement] - Root element to attach to, the document body by default
  *  @memberof Engine */
 function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, imageSources=[], rootElement=document.body)
@@ -4856,7 +4953,8 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
         mainCanvasSize = vec2(mainCanvas.width, mainCanvas.height);
 
         // disable smoothing for pixel art
-        mainContext.imageSmoothingEnabled = !canvasPixelated;
+        overlayContext.imageSmoothingEnabled = 
+            mainContext.imageSmoothingEnabled = !tilesPixelated;
 
         // setup gl rendering if enabled
         glPreRender();
@@ -4992,8 +5090,7 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
 
     function startEngine()
     {
-        gameInit();
-        engineUpdate();
+        new Promise((resolve) => resolve(gameInit())).then(engineUpdate);
     }
 
     if (headlessMode)
@@ -5008,9 +5105,9 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
         'width:100vw;height:100vh;' + // fill the window
         'display:flex;' +             // use flexbox
         'align-items:center;' +       // horizontal center
-        (canvasPixelated ? 'image-rendering:pixelated;' : '') + // pixel art
         'justify-content:center;' +   // vertical center
         'background:#000;' +          // set background color
+        (canvasPixelated ? 'image-rendering:pixelated;' : '') + // pixel art
         'user-select:none;' +         // prevent hold to select
         '-webkit-user-select:none;' + // compatibility for ios
         (!touchInputEnable ? '' :     // no touch css setttings
@@ -5346,4 +5443,5 @@ function drawEngineSplashScreen(t)
     }
     
     x.restore();
-}
+}
+

package/examples/box2d/game.js

@@ -15,13 +15,11 @@
 setShowSplashScreen(true);
 //box2dDebug = 1; // enable box2d debug draw
 
-// fix texture bleeding by shrinking tile slightly
-tileFixBleedScale = .2;
-
 // game variables
 const maxScenes = 11;
 let scene = 0;
 let sceneName;
+let spriteAtlas;
 let groundObject;
 let mouseJoint;
 let car;
@@ -30,6 +28,19 @@ let repeatSpawnTimer = new Timer;
 ///////////////////////////////////////////////////////////////////////////////
 function gameInit()
 {
+    // create a table of all sprites
+    const gameTile = (i)=>  tile(i, 16, 0, 1);
+    spriteAtlas =
+    {
+        circle:         gameTile(0),
+        dot:            gameTile(1),
+        circleOutline:  gameTile(2),
+        squareOutline:  gameTile(3),
+        wheel:          gameTile(4),
+        gear:           gameTile(5),
+        squareOutline2: gameTile(6),
+    };
+
     loadScene(scene);
 }
 
@@ -128,7 +139,7 @@ function gameRenderPost()
     {
         // draw mouse joint
         const ab = vec2(mouseJoint.GetAnchorB());
-        drawTile(ab, vec2(.3), tile(0), BLACK);
+        drawTile(ab, vec2(.3), spriteAtlas.circle, BLACK);
         drawLine(mousePos, ab, .1, BLACK);
     }