littlejsengine 1.11.13 → 1.12.4

package/examples/platformer/gameObjects.js

@@ -8,7 +8,13 @@
 
 'use strict';
 
-class GameObject extends EngineObject 
+// import LittleJS module
+import * as LJS from '../../dist/littlejs.esm.js';
+import * as GameEffects from './gameEffects.js';
+import * as Game from './game.js';
+const {vec2, hsl, rgb, Timer} = LJS;
+
+export class GameObject extends LJS.EngineObject 
 {
     constructor(pos, size, tileInfo, angle)
     {
@@ -25,7 +31,7 @@ class GameObject extends EngineObject
         // flash white when damaged
         let brightness = 0;
         if (!this.isDead() && this.damageTimer.isSet())
-            brightness = .5*percent(this.damageTimer, .15, 0);
+            brightness = .5*LJS.percent(this.damageTimer, .15, 0);
         this.additiveColor = hsl(0,0,brightness,0);
 
         // kill if below level
@@ -35,7 +41,7 @@ class GameObject extends EngineObject
 
     damage(damage, damagingObject)
     {
-        ASSERT(damage >= 0);
+        LJS.ASSERT(damage >= 0);
         if (this.isDead())
             return 0;
         
@@ -45,7 +51,7 @@ class GameObject extends EngineObject
             child.damageTimer && child.damageTimer.set();
 
         // apply damage and kill if necessary
-        const newHealth = max(this.health - damage, 0);
+        const newHealth = LJS.max(this.health - damage, 0);
         if (!newHealth)
             this.kill(damagingObject);
 
@@ -59,13 +65,13 @@ class GameObject extends EngineObject
 
 ///////////////////////////////////////////////////////////////////////////////
 
-class Crate extends GameObject 
+export class Crate extends GameObject 
 {
     constructor(pos) 
     { 
-        super(pos, vec2(.999), spriteAtlas.crate, (randInt(4))*PI/2);
+        super(pos, vec2(.999), Game.spriteAtlas.crate, (LJS.randInt(4))*LJS.PI/2);
 
-        this.color = hsl(rand(),1,.8);
+        this.color = hsl(LJS.rand(),1,.8);
         this.health = 5;
 
         // make it a solid object for collision
@@ -77,59 +83,59 @@ class Crate extends GameObject
         if (this.destroyed)
             return;
 
-        sound_destroyObject.play(this.pos);
-        makeDebris(this.pos, this.color, 30);
+        GameEffects.sound_destroyObject.play(this.pos);
+        GameEffects.makeDebris(this.pos, this.color, 30);
         this.destroy();
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-class Coin extends EngineObject 
+export class Coin extends LJS.EngineObject 
 {
     constructor(pos) 
     { 
-        super(pos, vec2(1), spriteAtlas.coin);
+        super(pos, vec2(1), Game.spriteAtlas.coin);
         this.color = hsl(.15,1,.5);
     }
 
     render()
     {
         // make it appear to spin
-        const t = time+this.pos.x/4+this.pos.y/4;
-        drawTile(this.pos, vec2(.1, .6), 0, this.color); // edge of coin
-        drawTile(this.pos, vec2(.5+.5*Math.sin(t*2*PI), 1), this.tileInfo, this.color);
+        const t = LJS.time+this.pos.x/4+this.pos.y/4;
+        LJS.drawTile(this.pos, vec2(.1, .6), 0, this.color); // edge of coin
+        LJS.drawTile(this.pos, vec2(.5+.5*Math.sin(t*2*LJS.PI), 1), this.tileInfo, this.color);
     }
 
     update()
     {
-        if (!player)
+        if (!Game.player)
             return;
 
         // check if player in range
-        const d = this.pos.distanceSquared(player.pos);
+        const d = this.pos.distanceSquared(Game.player.pos);
         if (d > .5)
             return; 
         
         // award points and destroy
-        ++score;
-        sound_score.play(this.pos);
+        Game.addToScore();
+        GameEffects.sound_score.play(this.pos);
         this.destroy();
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-class Enemy extends GameObject 
+export class Enemy extends GameObject 
 {
     constructor(pos) 
     { 
-        super(pos, vec2(.9,.9), spriteAtlas.enemy);
+        super(pos, vec2(.9,.9), Game.spriteAtlas.enemy);
 
         this.drawSize = vec2(1);
-        this.color = hsl(rand(), 1, .7);
+        this.color = hsl(LJS.rand(), 1, .7);
         this.health = 5;
-        this.bounceTime = new Timer(rand(1e3));
+        this.bounceTime = new Timer(LJS.rand(1e3));
         this.setCollision(true, false);
     }
 
@@ -137,16 +143,16 @@ class Enemy extends GameObject
     {
         super.update();
         
-        if (!player)
+        if (!Game.player)
             return;
 
         // jump around randomly
-        if (this.groundObject && rand() < .01 && this.pos.distance(player.pos) < 20)
-            this.velocity = vec2(rand(.1,-.1), rand(.4,.2));
+        if (this.groundObject && LJS.rand() < .01 && this.pos.distance(Game.player.pos) < 20)
+            this.velocity = vec2(LJS.rand(.1,-.1), LJS.rand(.4,.2));
 
         // damage player if touching
-        if (isOverlapping(this.pos, this.size, player.pos, player.size))
-            player.damage(1, this);
+        if (LJS.isOverlapping(this.pos, this.size, Game.player.pos, Game.player.size))
+            Game.player.damage(1, this);
     }
 
     kill()
@@ -154,9 +160,9 @@ class Enemy extends GameObject
         if (this.destroyed)
             return;
 
-        ++score;
-        sound_score.play(this.pos);
-        makeDebris(this.pos, this.color);
+        Game.addToScore();
+        GameEffects.sound_score.play(this.pos);
+        GameEffects.makeDebris(this.pos, this.color);
         this.destroy();
     }
        
@@ -169,17 +175,17 @@ class Enemy extends GameObject
         // make bottom flush
         let bodyPos = this.pos;
         bodyPos = bodyPos.add(vec2(0,(this.drawSize.y-this.size.y)/2));
-        drawTile(bodyPos, this.drawSize, this.tileInfo, this.color, this.angle, this.mirror, this.additiveColor);
+        LJS.drawTile(bodyPos, this.drawSize, this.tileInfo, this.color, this.angle, this.mirror, this.additiveColor);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-class Grenade extends GameObject
+export class Grenade extends GameObject
 {
     constructor(pos) 
     {
-        super(pos, vec2(.2), spriteAtlas.grenade);
+        super(pos, vec2(.2), Game.spriteAtlas.grenade);
 
         this.beepTimer = new Timer(1);
         this.elasticity   = .3;
@@ -195,35 +201,35 @@ class Grenade extends GameObject
 
         if (this.getAliveTime() > 3)
         {
-            explosion(this.pos);
+            GameEffects.explosion(this.pos);
             this.destroy();
         }
         else if (this.beepTimer.elapsed())
         {
-            sound_grenade.play(this.pos)
+            GameEffects.sound_grenade.play(this.pos)
             this.beepTimer.set(1);
         }
     }
        
     render()
     {
-        drawTile(this.pos, vec2(.5), this.tileInfo, this.color, this.angle);
+        LJS.drawTile(this.pos, vec2(.5), this.tileInfo, this.color, this.angle);
 
         // draw additive flash exploding
-        setBlendMode(true);
-        const flash = Math.cos(this.getAliveTime()*2*PI);
-        drawTile(this.pos, vec2(2), spriteAtlas.circle, hsl(0,1,.5,.2-.2*flash));
-        setBlendMode(false);
+        LJS.setBlendMode(true);
+        const flash = Math.cos(this.getAliveTime()*2*LJS.PI);
+        LJS.drawTile(this.pos, vec2(2), Game.spriteAtlas.circle, hsl(0,1,.5,.2-.2*flash));
+        LJS.setBlendMode(false);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-class Weapon extends EngineObject 
+export class Weapon extends LJS.EngineObject 
 {
     constructor(pos, parent) 
     { 
-        super(pos, vec2(.6), spriteAtlas.gun);
+        super(pos, vec2(.6), Game.spriteAtlas.gun);
 
         // weapon settings
         this.fireRate      = 8;
@@ -238,7 +244,7 @@ class Weapon extends EngineObject
         parent.addChild(this, vec2(.6,0));
 
         // shell effect
-        this.addChild(this.shellEmitter = new ParticleEmitter(
+        this.addChild(this.shellEmitter = new LJS.ParticleEmitter(
             vec2(), 0, 0, 0, 0, .1,  // pos, angle, emitSize, emitTime, emitRate, emitCone
             0,                       // tileInfo
             rgb(1,.8,.5), rgb(.9,.7,.5), // colorStartA, colorStartB
@@ -248,7 +254,7 @@ class Weapon extends EngineObject
             .1, 1               // randomness, collide, additive, colorLinear, renderOrder
         ), vec2(.1,0), -.8);
         this.shellEmitter.elasticity = .5;
-        this.shellEmitter.particleDestroyCallback = persistentParticleDestroyCallback;
+        this.shellEmitter.particleDestroyCallback = GameEffects.persistentParticleDestroyCallback;
     }
 
     update()
@@ -257,21 +263,21 @@ class Weapon extends EngineObject
 
         // update recoil
         if (this.recoilTimer.active())
-            this.localAngle = lerp(this.recoilTimer.getPercent(), this.localAngle, 0);
+            this.localAngle = LJS.lerp(this.recoilTimer.getPercent(), this.localAngle, 0);
 
         this.mirror = this.parent.mirror;
-        this.fireTimeBuffer += timeDelta;
+        this.fireTimeBuffer += LJS.timeDelta;
         if (this.triggerIsDown)
         {
             // try to fire
             for (; this.fireTimeBuffer > 0; this.fireTimeBuffer -= 1/this.fireRate)
             {
                 // create bullet
-                sound_shoot.play(this.pos);
-                this.localAngle = -rand(.2,.25);
+                GameEffects.sound_shoot.play(this.pos);
+                this.localAngle = -LJS.rand(.2,.25);
                 this.recoilTimer.set(.1);
                 const direction = vec2(this.bulletSpeed*this.getMirrorSign(), 0);
-                const velocity = direction.rotate(rand(-1,1)*this.bulletSpread);
+                const velocity = direction.rotate(LJS.rand(-1,1)*this.bulletSpread);
                 new Bullet(this.pos, this.parent, velocity, this.damage);
 
                 // spawn shell particle
@@ -279,13 +285,13 @@ class Weapon extends EngineObject
             }
         }
         else
-            this.fireTimeBuffer = min(this.fireTimeBuffer, 0);
+            this.fireTimeBuffer = LJS.min(this.fireTimeBuffer, 0);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-class Bullet extends EngineObject 
+export class Bullet extends LJS.EngineObject 
 {
     constructor(pos, attacker, velocity, damage) 
     { 
@@ -305,7 +311,7 @@ class Bullet extends EngineObject
     update()
     {
         // check if hit someone
-        engineObjectsCallback(this.pos, this.size, (o)=>
+        LJS.engineObjectsCallback(this.pos, this.size, (o)=>
         {
             if (o.isGameObject)
                 this.collideWithObject(o)
@@ -317,12 +323,12 @@ class Bullet extends EngineObject
         this.range -= this.velocity.length();
         if (this.range < 0)
         {
-            new ParticleEmitter(
-                this.pos, 0, .2, .1, 50, PI, spriteAtlas.circle, // pos, emit info, tileInfo
-                rgb(1,1,.1), rgb(1,1,1),    // colorStartA, colorStartB
-                rgb(1,1,.1,0), rgb(1,1,1,0),// colorEndA, colorEndB
+            new LJS.ParticleEmitter(
+                this.pos, 0, .2, .1, 50, 3.14, Game.spriteAtlas.circle, // pos, emit info, tileInfo
+                rgb(1,1,.1), rgb(1,1,1),   // colorStartA, colorStartB
+                rgb(1,1,.1,0), rgb(1,1,1,0), // colorEndA, colorEndB
                 .1, .5, .1, .05, 0, // particleTime, sizeStart, sizeEnd, speed, angleSpeed
-                1, 1, .5, PI, .1,   // damping, angleDamping, gravityScale, cone, fadeRate, 
+                1, 1, .5, 3.14, .1, // damping, angleDamping, gravityScale, cone, fadeRate, 
                 .5, 0, 1            // randomness, collide, additive, randomColorLinear
             );
 
@@ -347,7 +353,7 @@ class Bullet extends EngineObject
         if (data <= 0)
             return false;
             
-        destroyTile(pos);
+        GameEffects.destroyTile(pos);
         this.kill();
         return true; 
     }
@@ -359,17 +365,17 @@ class Bullet extends EngineObject
         this.destroy();
 
         // spark effects
-        const emitter = new ParticleEmitter(
+        const emitter = new LJS.ParticleEmitter(
             this.pos, 0, 0, .1, 100, .5, // pos, angle, emitSize, emitTime, emitRate, emitCone
-            0,                      // tileInfo
+            0,                           // tileInfo
             rgb(1,1,0), rgb(1,0,0), // colorStartA, colorStartB
             rgb(1,1,0), rgb(1,0,0), // colorEndA, colorEndB
-            .2, .2, 0, .1, .1, // time, sizeStart, sizeEnd, speed, angleSpeed
-            1, 1, .5, PI, .1,  // damp, angleDamp, gravityScale, particleCone, fade, 
-            .5, 1, 1           // randomness, collide, additive, colorLinear, renderOrder
+            .2, .2, 0, .1, .1,  // time, sizeStart, sizeEnd, speed, angleSpeed
+            1, 1, .5, 3.14, .1, // damp, angleDamp, gravityScale, particleCone, fade, 
+            .5, 1, 1            // randomness, collide, additive, colorLinear, renderOrder
         );
         emitter.trailScale = 1;
         emitter.elasticity = .3;
-        emitter.angle = this.velocity.angle() + PI;
+        emitter.angle = this.velocity.angle() + LJS.PI;
     }
 }

package/examples/platformer/gamePlayer.js

@@ -9,22 +9,27 @@
 
 'use strict';
 
-class Player extends Character
+// import LittleJS module
+import * as LJS from '../../dist/littlejs.esm.js';
+import * as GameCharacter from './gameCharacter.js';
+import * as Game from './game.js';
+
+export class Player extends GameCharacter.Character
 {
     update()
     {
         // movement control
-        this.moveInput     = isUsingGamepad ? gamepadStick(0) : keyDirection();
-        this.holdingJump   = keyIsDown('ArrowUp') || gamepadIsDown(0);
-        this.holdingShoot  = !isUsingGamepad && mouseIsDown(0) || keyIsDown('KeyZ') || gamepadIsDown(2);
-        this.pressingThrow = keyIsDown('KeyC') || mouseIsDown(1) || gamepadIsDown(1);
-        this.pressedDodge  = keyIsDown('KeyX') || mouseIsDown(2) || gamepadIsDown(3);
+        this.moveInput     = LJS.isUsingGamepad ? LJS.gamepadStick(0) : LJS.keyDirection();
+        this.holdingJump   = LJS.keyIsDown('ArrowUp') || LJS.gamepadIsDown(0);
+        this.holdingShoot  = !LJS.isUsingGamepad && LJS.mouseIsDown(0) || LJS.keyIsDown('KeyZ') || LJS.gamepadIsDown(2);
+        this.pressingThrow = LJS.keyIsDown('KeyC') || LJS.mouseIsDown(1) || LJS.gamepadIsDown(1);
+        this.pressedDodge  = LJS.keyIsDown('KeyX') || LJS.mouseIsDown(2) || LJS.gamepadIsDown(3);
         super.update();
     }
 
     kill()
     {
-        ++deaths;
+        Game.addToDeaths();
         super.kill();
     }
 }

package/examples/platformer/index.html

@@ -6,12 +6,4 @@
 <meta name=mobile-web-app-capable content=yes>
 <link rel=icon type=image/png href=../favicon.png>
 </head><body>
-
-<script src=../../dist/littlejs.js?1117></script>
-<script src=gameObjects.js?1117></script>
-<script src=gameCharacter.js?1117></script>
-<script src=gamePlayer.js?1117></script>
-<script src=gameEffects.js?1117></script>
-<script src=gameLevel.js?1117></script>
-<script src=gameLevelData.js?1117></script>
-<script src=game.js?1117></script>
+<script src=game.js type=module></script>

package/examples/puzzle/game.js

@@ -8,12 +8,14 @@
 
 'use strict';
 
-// show the LittleJS splash screen
-setShowSplashScreen(true);
+// import LittleJS module
+import * as LJS from '../../dist/littlejs.esm.js';
+const {vec2, rgb, hsl, tile} = LJS;
 
+///////////////////////////////////////////////////////////////////////////////
 // do not use pixelated rendering
-setCanvasPixelated(false);
-setTilesPixelated(false);
+LJS.setCanvasPixelated(false);
+LJS.setTilesPixelated(false);
 
 const fallTime = .2;
 const cameraOffset = vec2(0,-.5);
@@ -22,9 +24,9 @@ const minMatchCount = 3;
 const highScoreKey = 'puzzleBestScore';
 
 // sound effects
-const sound_goodMove = new Sound([.4,.2,250,.04,,.04,,,1,,,,,3]);
-const sound_badMove = new Sound([,,700,,,.07,,,,3.7,,,,3,,,.1]);
-const sound_fall = new Sound([.2,,1900,,,.01,,1.4,,91,,,,,,,,,,.7]);
+const sound_goodMove = new LJS.Sound([.4,.2,250,.04,,.04,,,1,,,,,3]);
+const sound_badMove  = new LJS.Sound([,,700,,,.07,,,,3.7,,,,3,,,.1]);
+const sound_fall     = new LJS.Sound([.2,,1900,,,.01,,1.4,,91,,,,,,,,,,.7]);
 
 let level, levelSize, levelFall, fallTimer, dragStartPos, comboCount, score, bestScore;
 
@@ -46,29 +48,40 @@ const getTile = (pos)       => level[pos.x + pos.y * levelSize.x];
 const setTile = (pos, data) => level[pos.x + pos.y * levelSize.x] = data;
 
 ///////////////////////////////////////////////////////////////////////////////
-function gameInit()
+function gameReset()
 {
-    // setup canvas
-    canvasFixedSize = vec2(1920, 1080); // 1080p
-    mainCanvas.style.background = backgroundColor;
-
-    // load high score
-    bestScore = localStorage[highScoreKey] || 0;
+    // reset game objects
+    LJS.engineObjectsDestroy();
 
     // randomize level
     level = [];
-    levelSize = vec2(12,6);
     const pos = vec2();
     for (pos.x = levelSize.x; pos.x--;)
     for (pos.y = levelSize.y; pos.y--;)
-        setTile(pos, randInt(tileTypeCount));
+        setTile(pos, LJS.randInt(tileTypeCount));
 
-    // setup game
-    cameraPos = levelSize.scale(.5).add(cameraOffset);
-    cameraScale = 900/levelSize.y;
-    gravity = -.004;
-    fallTimer = new Timer;
     comboCount = score = 0;
+    fallTimer = new LJS.Timer;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+function gameInit()
+{
+    // setup canvas
+    LJS.setCanvasFixedSize(vec2(1920, 1080)); // 1080p
+    LJS.mainCanvas.style.background = backgroundColor;
+
+    // load high score
+    bestScore = localStorage[highScoreKey] || 0;
+
+    // setup game
+    levelSize = vec2(12,6);
+    LJS.setCameraPos(levelSize.scale(.5).add(cameraOffset));
+    LJS.setCameraScale(900/levelSize.y);
+    LJS.setGravity(vec2(0,-.004));
+
+    // start a new game
+    gameReset();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -81,7 +94,7 @@ function gameUpdate()
         {
             // add more blocks in the top
             for (let x = 0; x < levelSize.x; ++x)
-                setTile(vec2(x,levelSize.y),randInt(tileTypeCount));
+                setTile(vec2(x,levelSize.y), LJS.randInt(tileTypeCount));
         }
         
         // allow blocks to fall
@@ -107,7 +120,7 @@ function gameUpdate()
 
             if (keepFalling)
             {
-                const p = percent(comboCount, 9, 0);
+                const p = LJS.percent(comboCount, 9, 0);
                 fallTimer.set(fallTime*p);
                 sound_fall.play();
             }
@@ -122,22 +135,22 @@ function gameUpdate()
         if (!fallTimer.isSet())
         {
             // mouse/touch control
-            const mouseTilePos = mousePos.floor();
-            if (!mousePos.arrayCheck(levelSize))
+            const mouseTilePos = LJS.mousePos.floor();
+            if (!LJS.mousePos.arrayCheck(levelSize))
             {
                 // cancel drag if mouse is not in the level bounds
                 dragStartPos = 0;
             }
-            else if (mouseWasPressed(0) && !dragStartPos)
+            else if (LJS.mouseWasPressed(0) && !dragStartPos)
             {
                 // start drag
                 dragStartPos = mouseTilePos.copy();
             }
-            else if (mouseIsDown(0) && dragStartPos)
+            else if (LJS.mouseIsDown(0) && dragStartPos)
             {
                 // if dragging to a neighbor tile
-                const dx = abs(dragStartPos.x - mouseTilePos.x);
-                const dy = abs(dragStartPos.y - mouseTilePos.y);
+                const dx = LJS.abs(dragStartPos.x - mouseTilePos.x);
+                const dy = LJS.abs(dragStartPos.y - mouseTilePos.y);
                 if (dx == 1 && dy == 0 || dx == 0 && dy == 1)
                 {
                     const startTile = getTile(dragStartPos);
@@ -175,6 +188,9 @@ function gameUpdate()
         bestScore = score;
         localStorage[highScoreKey] = bestScore;
     }
+
+    if (LJS.keyWasPressed('KeyR'))
+        gameReset();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -187,7 +203,7 @@ function gameUpdatePost()
 function gameRender()
 {
     // draw a black square for the background
-    drawRect(cameraPos.subtract(cameraOffset), levelSize, hsl(0,0,0));
+    LJS.drawRect(LJS.cameraPos.subtract(cameraOffset), levelSize, hsl(0,0,0));
 
     // draw the blocks
     const pos = vec2();
@@ -201,7 +217,7 @@ function gameRender()
         // highlight drag start
         const drawPos = pos.add(vec2(.5));
         if (dragStartPos && pos.x == dragStartPos.x && pos.y == dragStartPos.y)
-            drawRect(drawPos, vec2(1.05));
+            LJS.drawRect(drawPos, vec2(1.05));
 
         // make pieces fall gradually
         if (fallTimer.active() && levelFall[pos.x + pos.y*levelSize.x])
@@ -209,28 +225,28 @@ function gameRender()
 
         // draw background
         const color = tileColors[data];
-        drawRect(drawPos, vec2(.95), color);
+        LJS.drawRect(drawPos, vec2(.95), color);
         
         // use darker color for icon
         const color2 = color.scale(.8, 1);
-        drawTile(drawPos, vec2(.5), tile(data, 64), color2);
+        LJS.drawTile(drawPos, vec2(.5), tile(data, 64), color2);
     }
 
     // draw a grey square at top to cover up incoming tiles
-    drawRect(cameraPos.subtract(cameraOffset).add(vec2(0,levelSize.y)), levelSize, backgroundColor);
+    LJS.drawRect(LJS.cameraPos.subtract(cameraOffset).add(vec2(0,levelSize.y)), levelSize, backgroundColor);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 function gameRenderPost()
 {
     // draw text on top of everything
-    drawTextOverlay('Score: ' + score,    cameraPos.add(vec2(-3,-3.1)), .9, hsl(), .1);
-    drawTextOverlay('Best: ' + bestScore, cameraPos.add(vec2( 3,-3.1)), .9, hsl(), .1);
+    LJS.drawTextOverlay('Score: ' + score,    LJS.cameraPos.add(vec2(-3,-3.1)), .9, hsl(), .1);
+    LJS.drawTextOverlay('Best: ' + bestScore, LJS.cameraPos.add(vec2( 3,-3.1)), .9, hsl(), .1);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Startup LittleJS Engine
-engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, ['tiles.png']);
+LJS.engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, ['tiles.png']);
 
 ///////////////////////////////////////////////////////////////////////////////
 // find and remove all runs of 3 or higher
@@ -292,14 +308,14 @@ function clearMatches()
             // spawn particles
             const color1 = tileColors[data];
             const color2 = color1.lerp(hsl(), .5);
-            new ParticleEmitter(
-                pos.add(vec2(.5)), 0,  // pos, angle
-                .5, .1, 200, PI,       // emitSize, emitTime, emitRate, emitCone
-                0,                     // tileInfo
+            new LJS.ParticleEmitter(
+                pos.add(vec2(.5)), 0, // pos, angle
+                .5, .1, 200, 3.14,    // emitSize, emitTime, emitRate, emitCone
+                0,                    // tileInfo
                 color1, color2,                      // colorStartA, colorStartB
                 color1.scale(1,0), color2.scale(1,0),// colorEndA, colorEndB
                 .5, .3, .2, .05, .05, // particleTime, sizeStart, sizeEnd, speed, angleSpeed
-                .99, 1, 1, PI, .05,   // damp, angleDamp, gravityScale, particleCone, fadeRate
+                .99, 1, 1, 3.14, .05, // damp, angleDamp, gravityScale, particleCone, fadeRate
                 .5, 0, 1              // randomness, collide, additive, colorLinear, renderOrder
             );
         }

package/examples/puzzle/index.html

@@ -5,6 +5,4 @@
 <meta name=mobile-web-app-capable content=yes>
 <link rel=icon type=image/png href=../favicon.png>
 </head><body>
-
-<script src=../../dist/littlejs.js?1117></script>
-<script src=game.js?1117></script>
+<script src=game.js type=module></script>

package/examples/shorts/base.html

@@ -1,5 +1,5 @@
 <!DOCTYPE html><meta charset=utf-8><body>
-<script src=../../dist/littlejs.js?1117></script>
+<script src=../../dist/littlejs.js?1120></script>
 <script>
 
 'use strict';
@@ -23,4 +23,4 @@ function gameUpdatePost() {}
 function gameRender() {}
 function gameRenderPost() {}
 
-</script>
+</script>

package/examples/shorts/particles.js

@@ -1,6 +1,6 @@
 function gameInit()
 {
-    gravity = -.01; // set default gravity
+    gravity.y = -.01; // set default gravity
 
     // fire
     new ParticleEmitter(

package/examples/shorts/platformer.js

@@ -32,7 +32,7 @@ class Player extends PhysicsObject
 function gameInit()
 {
     // setup level
-    gravity = -.05;
+    gravity.y = -.05;
     new Player(vec2(0,4));
 
     // create random objects