littlejsengine 1.11.17 → 1.12.6

package/examples/box2d/scenes.js

@@ -17,96 +17,89 @@
 
 'use strict';
 
-function loadScene(_scene)
-{
-    scene = _scene;
+// import game module
+import * as LJS from '../../dist/littlejs.esm.js';
+import * as GameObjects from './gameObjects.js';
+import * as Game from './game.js';
+const {vec2} = LJS;
 
-    // setup
-    cameraPos = vec2(20,10);
-    setGravity(-20);
+export let scene, sceneName;
 
-    // destroy old scene
-    engineObjectsDestroy();
-    mouseJoint = 0;
-    car = 0;
-    
-    // create walls
-    groundObject = spawnBox(vec2(0,-4), vec2(1e3,8), hsl(0,0,.2), box2d.bodyTypeStatic);
-    spawnBox(vec2(-4, 0), vec2(8,1e3), BLACK, box2d.bodyTypeStatic);
-    spawnBox(vec2(44, 0), vec2(8,1e3), BLACK, box2d.bodyTypeStatic);
-    spawnBox(vec2(0,100), vec2(1e3,8), BLACK, box2d.bodyTypeStatic);
+export function loadScene(_scene)
+{
+    scene = _scene;
 
     if (scene == 0)
     {
         sceneName = 'Shapes';
-        spawnRandomEdges();
-        spawnBox(vec2(11,8), 4,  randColor(), box2d.bodyTypeStatic, false);
-        spawnCircle(vec2(20,8), 4,     randColor(), box2d.bodyTypeStatic, false);
-        spawnRandomPoly(vec2(29,8), 4, randColor(), box2d.bodyTypeStatic, false);
+        GameObjects.spawnRandomEdges();
+        GameObjects.spawnBox(vec2(11,8), 4, LJS.randColor(), LJS.box2d.bodyTypeStatic, false);
+        GameObjects.spawnCircle(vec2(20,8), 4, LJS.randColor(), LJS.box2d.bodyTypeStatic, false);
+        GameObjects.spawnRandomPoly(vec2(29,8), 4, LJS.randColor(), LJS.box2d.bodyTypeStatic, false);
         for (let i=500;i--;)
-            spawnRandomObject(vec2(rand(1,39), rand(10,50)));
+            GameObjects.spawnRandomObject(vec2(LJS.rand(1,39), LJS.rand(10,50)));
     }
     if (scene == 1)
     {
         sceneName = 'Pyramid';
-        spawnPyramid(vec2(20,0), 15);
-        spawnBox(vec2(10,2), 4, randColor());
-        spawnCircle(vec2(30,2), 4, randColor());
+        GameObjects.spawnPyramid(vec2(20,0), 15);
+        GameObjects.spawnBox(vec2(10,2), 4, LJS.randColor());
+        GameObjects.spawnCircle(vec2(30,2), 4, LJS.randColor());
     }
     if (scene == 2)
     {
         sceneName = 'Dominoes';
-        spawnDominoes(vec2(11,11), 11);
-        spawnDominoes(vec2(2,0), 13, vec2(1,3));
-        spawnCircle(vec2(10,20), 2, randColor());
-        spawnCircle(vec2(31.7,12), 2, randColor());
-        spawnBox(vec2(16,11), vec2(32,1), randColor(), box2d.bodyTypeStatic, false);
-        spawnBox(vec2(24,6.5), vec2(32,1), randColor(), box2d.bodyTypeStatic, false, -.15);
+        GameObjects.spawnDominoes(vec2(11,11), 11);
+        GameObjects.spawnDominoes(vec2(2,0), 13, vec2(1,3));
+        GameObjects.spawnCircle(vec2(10,20), 2, LJS.randColor());
+        GameObjects.spawnCircle(vec2(31.7,12), 2, LJS.randColor());
+        GameObjects.spawnBox(vec2(16,11), vec2(32,1), LJS.randColor(), LJS.box2d.bodyTypeStatic, false);
+        GameObjects.spawnBox(vec2(24,6.5), vec2(32,1), LJS.randColor(), LJS.box2d.bodyTypeStatic, false, -.15);
     }
     if (scene == 3)
     {
         sceneName = 'Car';
-        car = new CarObject(vec2(10,2));
-        spawnBox(vec2(20,0), vec2(10,2), randColor(), box2d.bodyTypeStatic, false, -.2);
-        spawnPyramid(vec2(32,0), 6);
+        new GameObjects.CarObject(vec2(10,2));
+        GameObjects.spawnBox(vec2(20,0), vec2(10,2), LJS.randColor(), LJS.box2d.bodyTypeStatic, false, -.2);
+        GameObjects.spawnPyramid(vec2(32,0), 6);
     }
     if (scene == 4)
     {
         sceneName = 'Rope';
         const startPos = vec2(20, 14);
-        const angle = PI/2;
-        const color = randColor();
+        const angle = LJS.PI/2;
+        const color = LJS.randColor();
         const count = 10;
-        const endObject = spawnRope(startPos, count, angle, color);
+        const endObject = GameObjects.spawnRope(startPos, count, angle, color);
 
         // connect box to end
         const endPos = endObject.localToWorld(vec2(0,-endObject.size.y/2));
-        const o = spawnBox(endPos, 3, randColor());
+        const o = GameObjects.spawnBox(endPos, 3, LJS.randColor());
         o.setAngularDamping(.5);
         o.setFilterData(2, 2);
-        new Box2dRevoluteJoint(endObject, o);
-        spawnPyramid(vec2(20,0), 7);
+        new LJS.Box2dRevoluteJoint(endObject, o);
+        GameObjects.spawnPyramid(vec2(20,0), 7);
     }
     if (scene == 5)
     {
         sceneName = 'Raycasts';
-        spawnRandomEdges();
+        GameObjects.spawnRandomEdges();
         for (let i=100;i--;)
-            spawnRandomObject(vec2(rand(1,39), rand(20)), 2, box2d.bodyTypeStatic, rand(PI*2));
+            GameObjects.spawnRandomObject(vec2(LJS.rand(1,39), LJS.rand(20)), 2, LJS.box2d.bodyTypeStatic, LJS.rand(LJS.PI*2));
     }
     if (scene == 6)
     {
         sceneName = 'Joints';
         {
             // prismatic joint
-            const o1 = spawnBox(vec2(20,8), vec2(3,2), randColor());
-            new Box2dPrismaticJoint(groundObject, o1, o1.pos, vec2(1,0), true);
-            const o2 = spawnBox(vec2(20,15), vec2(2,3), randColor());
-            new Box2dPrismaticJoint(groundObject, o2, o2.pos, vec2(0,1), true);
+            const o1 = GameObjects.spawnBox(vec2(20,8), vec2(3,2), LJS.randColor());
+            new LJS.Box2dPrismaticJoint(Game.groundObject, o1, o1.pos, vec2(1,0), true);
+            const o2 = GameObjects.spawnBox(vec2(20,15), vec2(2,3), LJS.randColor());
+            new LJS.Box2dPrismaticJoint(Game.groundObject, o2, o2.pos, vec2(0,1), true);
 
             // lines to make it look line a track
-            const l1 = new EngineObject(vec2(20, 8), vec2(39,.5), 0, 0, GRAY);
-            const l2 = new EngineObject(vec2(20,50), vec2(.5,99), 0, 0, GRAY);
+            const l1 = new LJS.EngineObject(vec2(20, 8), vec2(39,.5), 0, 0, LJS.GRAY);
+            const l2 = new LJS.EngineObject(vec2(20,50), vec2(.5,99), 0, 0, LJS.GRAY);
             l1.gravityScale = l2.gravityScale = 0;
             l1.renderOrder = l2.renderOrder = -2;
         }
@@ -114,52 +107,53 @@ function loadScene(_scene)
             // pulley joint
             const anchorA = vec2(14,15);
             const anchorB = vec2(26,15);
-            const oA = new PulleyJointObjects(vec2(15,8), vec2(1,2), randColor(), anchorA);
-            const oB = new PulleyJointObjects(vec2(25,8), vec2(1,2), randColor(), anchorB);
-            const aA = spawnCircle(anchorA, 2, randColor(), box2d.bodyTypeStatic);
-            const aB = spawnCircle(anchorB, 2, randColor(), box2d.bodyTypeStatic);
+            const oA = new GameObjects.PulleyJointObjects(vec2(15,8), vec2(1,2), LJS.randColor(), anchorA);
+            const oB = new GameObjects.PulleyJointObjects(vec2(25,8), vec2(1,2), LJS.randColor(), anchorB);
+            const aA = GameObjects.spawnCircle(anchorA, 2, LJS.randColor(), LJS.box2d.bodyTypeStatic);
+            const aB = GameObjects.spawnCircle(anchorB, 2, LJS.randColor(), LJS.box2d.bodyTypeStatic);
             const oaA = oA.localToWorld(vec2(0,oA.size.y/2));
             const oaB = oB.localToWorld(vec2(0,oB.size.y/2));
-            new Box2dPulleyJoint(oA, oB, aA.pos, aB.pos, oaA, oaB);
+            new LJS.Box2dPulleyJoint(oA, oB, aA.pos, aB.pos, oaA, oaB);
 
             // a line to make it look like connecting rope
-            const line = new EngineObject(vec2(20,15), vec2(10,.2), 0, 0, BLACK);
+            const line = new LJS.EngineObject(vec2(20,15), vec2(10,.2), 0, 0, LJS.BLACK);
             line.gravityScale = 0;
             line.renderOrder = -1;
         }
         {
             // gear joint
-            const o1 = spawnCircle(vec2(23.5,3), 3, randColor());
-            const j1 = new Box2dRevoluteJoint(groundObject, o1, o1.pos);
-            const o2 = spawnCircle(vec2(28,3), 6, randColor());
-            o1.tileInfo = o2.tileInfo = spriteAtlas.gear;
-            const j2 = new Box2dRevoluteJoint(groundObject, o2, o2.pos);
-            new Box2dGearJoint(o1, o2, j1, j2, 2);
+            const o1 = GameObjects.spawnCircle(vec2(23.5,3), 3, LJS.randColor());
+            const j1 = new LJS.Box2dRevoluteJoint(Game.groundObject, o1, o1.pos);
+            const o2 = GameObjects.spawnCircle(vec2(28,3), 6, LJS.randColor());
+            o1.tileInfo = o2.tileInfo = Game.spriteAtlas.gear;
+            const j2 = new LJS.Box2dRevoluteJoint(Game.groundObject, o2, o2.pos);
+            new LJS.Box2dGearJoint(o1, o2, j1, j2, 2);
         }
         {
             // weld joint
-            const o1 = spawnBox(vec2(15,2),   4, randColor());
-            const o2 = spawnBox(vec2(17,2), 2, randColor());
-            new Box2dWeldJoint(o1, o2);
+            const o1 = GameObjects.spawnBox(vec2(15,2), 4, LJS.randColor());
+            const o2 = GameObjects.spawnBox(vec2(17,2), 2, LJS.randColor());
+            new LJS.Box2dWeldJoint(o1, o2);
         }
         {
             // distance joint
-            const o1 = new Box2dObject(vec2(30,11), vec2(4), spriteAtlas.circleOutline, 0, randColor(), box2d.bodyTypeStatic);
+            const o1 = new LJS.Box2dObject(vec2(30,11), vec2(4), Game.spriteAtlas.circleOutline, 0, LJS.randColor(), LJS.box2d.bodyTypeStatic);
             o1.renderOrder = -2;
-            const o2 = spawnCircle(vec2(30,8), 2, randColor());
-            new Box2dDistanceJoint(o1, o2);
+            const o2 = GameObjects.spawnCircle(vec2(30,8), 2, LJS.randColor());
+            new LJS.Box2dDistanceJoint(o1, o2);
         }
         {
             // motor joint
-            const o = new Box2dObject(vec2(10,8), vec2(4), spriteAtlas.circleOutline, 0, randColor(), box2d.bodyTypeStatic);
+            const o = new LJS.Box2dObject(vec2(10,8), vec2(4), Game.spriteAtlas.circleOutline, 0, LJS.randColor(), LJS.box2d.bodyTypeStatic);
             o.renderOrder = -2;
-            new MotorJointObject(vec2(10,8), vec2(2), randColor(), o);
+            new GameObjects.MotorJointObject(vec2(10,8), vec2(2), LJS.randColor(), o);
         }
         {
             // friction joint
-            const o = spawnBox(vec2(10,15), 3, randColor());
-            o.tileInfo = spriteAtlas.squareOutline2;
-            const joint = new Box2dFrictionJoint(groundObject, o);
+            const o = GameObjects.spawnBox(vec2(10,15), 3, LJS.randColor());
+            o.tileInfo = Game.spriteAtlas.squareOutline2;
+            o.setGravityScale(0);
+            const joint = new LJS.Box2dFrictionJoint(Game.groundObject, o);
             joint.setMaxForce(200);
             joint.setMaxTorque(200);
         }
@@ -167,27 +161,27 @@ function loadScene(_scene)
     if (scene == 7)
     {
         sceneName = 'Contacts';
-        new ContactTester(vec2(15,8), vec2(5), RED,  RED);
-        new ContactTester(vec2(25,8), vec2(5), CYAN, CYAN, false, false);
+        new GameObjects.ContactTester(vec2(15,8), vec2(5), LJS.RED, LJS.RED);
+        new GameObjects.ContactTester(vec2(25,8), vec2(5), LJS.CYAN, LJS.CYAN, false, false);
         for (let i=200;i--;)
-            spawnRandomObject(vec2(rand(1,39), rand(10,50)));
+            GameObjects.spawnRandomObject(vec2(LJS.rand(1,39), LJS.rand(10,50)));
     }
     if (scene == 8)
     {
         sceneName = 'Mobile';
         const pos = vec2(20, 16);
-        const mobile = new MobileObject(pos, 12, 2, 5);
-        new Box2dRevoluteJoint(groundObject, mobile, pos);
+        const mobile = new GameObjects.MobileObject(pos, 12, 2, 5);
+        new LJS.Box2dRevoluteJoint(Game.groundObject, mobile, pos);
     }
     if (scene == 9)
     {
-        sceneName = 'Cloth';
-        new ClothObject(vec2(20, 9), vec2(15), vec2(24), randColor());
+        sceneName = 'Cloth'
+        new GameObjects.ClothObject(vec2(20, 9), vec2(15), vec2(24), LJS.randColor());
     }
     if (scene == 10)
     {
         sceneName = 'Softbodies';
         for(let i=3;i--;)
-            new SoftBodyObject(vec2(20, 3+i*7), vec2(6-i), vec2(9-i), randColor());
+            new GameObjects.SoftBodyObject(vec2(20, 3+i*7), vec2(6-i), vec2(9-i), LJS.randColor());
     }
 }

package/examples/breakout/game.js

@@ -8,46 +8,81 @@
 
 'use strict';
 
-let levelSize, ball, paddle, score, brickCount;
+// import LittleJS module
+import * as LJS from '../../dist/littlejs.esm.js';
+import * as GameObjects from './gameObjects.js';
+const {vec2, hsl} = LJS;
 
-// sound effects
-const sound_start  = new Sound([,0,500,,.04,.3,1,2,,,570,.02,.02,,,,.04]);
-const sound_break  = new Sound([,,90,,.01,.03,4,,,,,,,9,50,.2,,.2,.01]);
-const sound_bounce = new Sound([,,1e3,,.03,.02,1,2,,,940,.03,,,,,.2,.6,,.06]);
+///////////////////////////////////////////////////////////////////////////////
+// game objects
+export let ball, score, brickCount, paddle;
+export const levelSize = vec2(38, 20);
+
+export function changeBrickCount(delta)
+{
+    brickCount += delta;
+    
+    // increase score when brick is destroyed
+    if (delta < 0)
+        score -= delta;
+}
 
 ///////////////////////////////////////////////////////////////////////////////
-function gameInit()
+function gameReset()
 {
-    canvasFixedSize = vec2(1920, 1080); // 1080p
-    levelSize = vec2(38, 20);
-    cameraPos = levelSize.scale(.5);
-    cameraScale = 48;
-    paddle = new Paddle(vec2(levelSize.x/2-12, 1));
-    score = brickCount = 0;
+    // reset game objects
+    LJS.engineObjectsDestroy();
+    score = 0;
+    brickCount = 0;
 
     // spawn bricks
     const pos = vec2();
     for (pos.x = 4; pos.x <= levelSize.x-4; pos.x += 2)
     for (pos.y = 12; pos.y <= levelSize.y-2; pos.y += 1)
-        new Brick(pos);
+        new GameObjects.Brick(pos);
 
     // create walls
-    new Wall(vec2(-.5,levelSize.y/2),            vec2(1,100)); // top
-    new Wall(vec2(levelSize.x+.5,levelSize.y/2), vec2(1,100)); // left
-    new Wall(vec2(levelSize.x/2,levelSize.y+.5), vec2(100,1)); // right
+    new GameObjects.Wall(vec2(-.5,levelSize.y/2),            vec2(1,100)); // top
+    new GameObjects.Wall(vec2(levelSize.x+.5,levelSize.y/2), vec2(1,100)); // left
+    new GameObjects.Wall(vec2(levelSize.x/2,levelSize.y+.5), vec2(100,1)); // right
+
+    // spawn player paddle
+    paddle = new GameObjects.Paddle(vec2(levelSize.x/2-12, 1));
 
-    setupPostProcess(); // set up a post processing shader
+    // reset ball
+    ball = 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+function gameInit()
+{
+    LJS.setCanvasFixedSize(vec2(1920, 1080)); // 1080p
+    LJS.setCameraPos(levelSize.scale(.5)); // center camera
+    LJS.setCameraScale(48);
+
+    // set up a post processing shader
+    setupPostProcess();
+
+    // start a new game
+    gameReset();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 function gameUpdate()
 {
     // spawn ball
-    if (!ball && (mouseWasPressed(0) || gamepadWasPressed(0)))
+    if (!ball && (LJS.mouseWasPressed(0) || LJS.gamepadWasPressed(0)))
+        ball = new GameObjects.Ball(vec2(levelSize.x/2, levelSize.y/2));
+
+    if (ball && ball.pos.y < -1)
     {
-        ball = new Ball(vec2(levelSize.x/2, levelSize.y/2));
-        sound_start.play();
+        // destroy ball if it goes below the level
+        ball.destroy();
+        ball = 0;
     }
+
+    if (LJS.keyWasPressed('KeyR'))
+        gameReset();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -60,20 +95,20 @@ function gameUpdatePost()
 function gameRender()
 {
     // draw a the background
-    drawRect(cameraPos, levelSize.scale(2), hsl(0,0,.5));
-    drawRect(cameraPos, levelSize, hsl(0,0,.02));
+    LJS.drawRect(LJS.cameraPos, levelSize.scale(2), hsl(0,0,.5));
+    LJS.drawRect(LJS.cameraPos, levelSize, hsl(0,0,.02));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 function gameRenderPost()
 {
     // use built in image font for text
-    const font = new FontImage;
-    font.drawText('Score: ' + score, cameraPos.add(vec2(0,9.7)), .15, true);
+    const font = new LJS.FontImage;
+    font.drawText('Score: ' + score, LJS.cameraPos.add(vec2(0,10)), .15, true);
     if (!brickCount)
-        font.drawText('You Win!', cameraPos.add(vec2(0,-5)), .2, true);
+        font.drawText('You Win!', LJS.cameraPos.add(vec2(0,-5)), .2, true);
     else if (!ball)
-        font.drawText('Click to Play', cameraPos.add(vec2(0,-5)), .2, true);
+        font.drawText('Click to Play', LJS.cameraPos.add(vec2(0,-5)), .2, true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -128,9 +163,9 @@ function setupPostProcess()
     }`;
 
     const includeOverlay = true;
-    new PostProcessPlugin(televisionShader, includeOverlay);
+    new LJS.PostProcessPlugin(televisionShader, includeOverlay);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Startup LittleJS Engine
-engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, ['tiles.png']);
+LJS.engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, ['tiles.png']);

package/examples/breakout/gameObjects.js

@@ -4,8 +4,19 @@
 
 'use strict';
 
+// import LittleJS module
+import * as LJS from '../../dist/littlejs.esm.js';
+import * as Game from './game.js';
+const {tile, vec2, hsl} = LJS;
+
+///////////////////////////////////////////////////////////////////////////////
+// sound effects
+const sound_start  = new LJS.Sound([,0,500,,.04,.3,1,2,,,570,.02,.02,,,,.04]);
+const sound_break  = new LJS.Sound([,,90,,.01,.03,4,,,,,,,9,50,.2,,.2,.01]);
+const sound_bounce = new LJS.Sound([,,1e3,,.03,.02,1,2,,,940,.03,,,,,.2,.6,,.06]);
+
 ///////////////////////////////////////////////////////////////////////////////
-class PhysicsObject extends EngineObject
+export class PhysicsObject extends LJS.EngineObject
 {
     constructor(pos, size, tileInfo, angle, color)
     {
@@ -16,16 +27,16 @@ class PhysicsObject extends EngineObject
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-class Wall extends PhysicsObject
+export class Wall extends PhysicsObject
 {
     constructor(pos, size)
     {
-        super(pos, size, 0, 0, new Color(0,0,0,0));
+        super(pos, size, 0, 0, hsl(0,0,0));
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-class Paddle extends PhysicsObject
+export class Paddle extends PhysicsObject
 {
     constructor(pos)
     {
@@ -35,41 +46,40 @@ class Paddle extends PhysicsObject
     update()
     {
         // control with gamepad or mouse
-        this.pos.x = isUsingGamepad ? this.pos.x + gamepadStick(0).x : mousePos.x;
+        this.pos.x = LJS.isUsingGamepad ? this.pos.x + LJS.gamepadStick(0).x : LJS.mousePos.x;
 
         // keep paddle in bounds of level
-        this.pos.x = clamp(this.pos.x, this.size.x/2, levelSize.x - this.size.x/2);
+        this.pos.x = LJS.clamp(this.pos.x, this.size.x/2, Game.levelSize.x - this.size.x/2);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-class Brick extends PhysicsObject 
+export class Brick extends PhysicsObject 
 {
     constructor(pos)
     {
-        super(pos, vec2(2,1), tile(1, vec2(32,16)), 0, randColor());
-        ++brickCount;
+        super(pos, vec2(2,1), tile(1, vec2(32,16)), 0, LJS.randColor());
+        Game.changeBrickCount(1);
     }
 
     collideWithObject(o)              
     {
         // destroy brick when hit with ball
         this.destroy();
-        ++score;
-        --brickCount;
+        Game.changeBrickCount(-1);
         sound_break.play(this.pos);
 
         // make explosion effect
         const color1 = this.color;
         const color2 = color1.lerp(hsl(), .5);
-        new ParticleEmitter(
+        new LJS.ParticleEmitter(
             this.pos, 0,                          // pos, angle
-            this.size, .1, 200, PI,               // emitSize, emitTime, emitRate, emitCone
+            this.size, .1, 200, 3.14,             // emitSize, emitTime, emitRate, emitCone
             tile(0, 16),                          // tileIndex, tileSize
             color1, color2,                       // colorStartA, colorStartB
             color1.scale(1,0), color2.scale(1,0), // colorEndA, colorEndB
             .3, .8, .3, .05, .05,// time, sizeStart, sizeEnd, speed, angleSpeed
-            .99, .95, .4, PI,    // damp, angleDamp, gravity, cone
+            .99, .95, .4, 3.14,  // damp, angleDamp, gravity, cone
             .1, .8, 0, 1         // fade, randomness, collide, additive
         );
 
@@ -85,7 +95,7 @@ class Brick extends PhysicsObject
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-class Ball extends PhysicsObject 
+export class Ball extends PhysicsObject 
 {
     constructor(pos)
     {
@@ -98,52 +108,40 @@ class Ball extends PhysicsObject
         
         // attach a trail effect
         const color = hsl(0,0,.2);
-        this.trailEffect = new ParticleEmitter(
+        this.trailEffect = new LJS.ParticleEmitter(
             this.pos, 0,                          // pos, angle
-            this.size, 0, 80, PI,                 // emitSize, emitTime, emitRate, emitCone
+            this.size, 0, 80, 3.14,               // emitSize, emitTime, emitRate, emitCone
             tile(0, 16),                          // tileIndex, tileSize
             color, color,                         // colorStartA, colorStartB
             color.scale(0), color.scale(0),       // colorEndA, colorEndB
             2, .4, 1, .001, .05,// time, sizeStart, sizeEnd, speed, angleSpeed
-            .99, .95, 0, PI,    // damp, angleDamp, gravity, cone
+            .99, .95, 0, 3.14,  // damp, angleDamp, gravity, cone
             .1, .5, 0, 1        // fade, randomness, collide, additive
         );
         this.addChild(this.trailEffect);
-    }
-
-    update()
-    {
-        if (this.pos.y < -1)
-        {
-            // destroy ball if it goes below the level
-            ball = 0;
-            this.destroy();
-        }
-
-        // update physics
-        super.update();
+        sound_start.play(this.pos);
     }
 
     collideWithObject(o)              
     {
+        // only need special handling when colliding with paddle
+        if (o != Game.paddle)
+            return true;
+
         // prevent colliding with paddle if moving upwards
-        if (o == paddle && this.velocity.y > 0)
+        if (this.velocity.y > 0)
             return false;
 
-        if (o == paddle)
-        {
-            // put english on the ball when it collides with paddle
-            this.velocity = this.velocity.rotate(.2 * (o.pos.x - this.pos.x));
-            this.velocity.y = max(-this.velocity.y, .2);
-
-            // speed up
-            const speed = min(1.04*this.velocity.length(), .5);
-            this.velocity = this.velocity.normalize(speed);
-            sound_bounce.play(this.pos, 1, speed*2);
-            
-            return false; // prevent default collision code
-        }
-        
-        return true;
+        // put english on the ball when it collides with paddle
+        this.velocity = this.velocity.rotate(.2 * (o.pos.x - this.pos.x));
+        this.velocity.y = LJS.max(-this.velocity.y, .2);
+
+        // speed up
+        const speed = LJS.min(1.04*this.velocity.length(), .5);
+        this.velocity = this.velocity.normalize(speed);
+        sound_bounce.play(this.pos, 1, speed*2);
+
+        // prevent default collision code
+        return false;
     }
 }

package/examples/breakout/index.html

@@ -5,8 +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?11115></script>
-<script src=../../plugins/postProcess.js?11115></script>
-<script src=gameObjects.js?11115></script>
-<script src=game.js?11115></script>
+<script src=game.js type=module></script>