littlejsengine 1.11.13 → 1.12.4

package/examples/box2d/game.js

@@ -11,25 +11,54 @@
 
 'use strict';
 
-// show the LittleJS splash screen
-setShowSplashScreen(true);
-//box2dDebug = 1; // enable box2d debug draw
+// import LittleJS module
+import * as LJS from '../../dist/littlejs.esm.js';
+import * as GameObjects from './gameObjects.js';
+import * as Scenes from './scenes.js';
+const {vec2, hsl} = LJS;
 
+///////////////////////////////////////////////////////////////////////////////
 // game variables
+
+//LJS.box2dSetDebug(true); // enable box2d debug draw
+
 const maxScenes = 11;
-let scene = 0;
-let sceneName;
-let spriteAtlas;
-let groundObject;
-let mouseJoint;
-let car;
-let repeatSpawnTimer = new Timer;
+export let scene = 0, sceneName;
+export let spriteAtlas, groundObject, car, mouseJoint, repeatSpawnTimer = new LJS.Timer;
+const sound_click = new LJS.Sound([.2,.1,,,,.01,,,,,,,,,,,,,,,-500]);
+
+export function setSceneName(name) { sceneName = name; }
+export function setCarObject(carObject) { car = carObject; }
+
+///////////////////////////////////////////////////////////////////////////////
+function setScene(_scene)
+{
+    scene = _scene;
+
+    // setup
+    LJS.setCameraPos(vec2(20,10));
+    LJS.setGravity(vec2(0,-20));
+
+    // destroy old scene
+    LJS.engineObjectsDestroy();
+    mouseJoint = 0;
+    car = 0;
+    
+    // create walls
+    groundObject = GameObjects.spawnBox(vec2(0,-4), vec2(1e3,8), hsl(0,0,.2), LJS.box2d.bodyTypeStatic);
+    GameObjects.spawnBox(vec2(-4, 0), vec2(8,1e3), LJS.BLACK, LJS.box2d.bodyTypeStatic);
+    GameObjects.spawnBox(vec2(44, 0), vec2(8,1e3), LJS.BLACK, LJS.box2d.bodyTypeStatic);
+    GameObjects.spawnBox(vec2(0,100), vec2(1e3,8), LJS.BLACK, LJS.box2d.bodyTypeStatic);
+
+    // load the scene
+    Scenes.loadScene(scene);
+}
 
 ///////////////////////////////////////////////////////////////////////////////
 function gameInit()
 {
     // create a table of all sprites
-    const gameTile = (i)=>  tile(i, 16, 0, 1);
+    const gameTile = (i)=> LJS.tile(i, 16, 0, 1);
     spriteAtlas =
     {
         circle:         gameTile(0),
@@ -41,65 +70,64 @@ function gameInit()
         squareOutline2: gameTile(6),
     };
 
-    loadScene(scene);
+    setScene(scene);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 function gameUpdate()
 {
     // scale canvas to fit based on 1080p
-    cameraScale = mainCanvasSize.y * 48 / 1080;
+    LJS.setCameraScale(LJS.mainCanvasSize.y * 48 / 1080);
 
     // mouse controls
-    if (mouseWasPressed(0))
+    if (LJS.mouseWasPressed(0))
     {
         // grab object
-        sound_click.play(mousePos);
-        const object = box2dPointCast(mousePos);
+        sound_click.play(LJS.mousePos);
+        const object = LJS.box2d.pointCast(LJS.mousePos);
         if (object)
-            mouseJoint = box2dCreateMouseJoint(object, groundObject, mousePos);
+            mouseJoint = new LJS.Box2dTargetJoint(object, groundObject, LJS.mousePos);
     }
-    if (mouseWasReleased(0))
+    if (LJS.mouseWasReleased(0))
     {
         // release object
-        sound_click.play(mousePos, 1, .5);
+        sound_click.play(LJS.mousePos, 1, .5);
         if (mouseJoint)
         {
-            box2dDestroyJoint(mouseJoint);
+            mouseJoint.destroy();
             mouseJoint = 0;
         }
     }
-    if (mouseIsDown(1) || mouseIsDown('KeyZ'))
+    if (LJS.mouseIsDown(1) || LJS.mouseIsDown('KeyZ'))
     {
         const isSet = repeatSpawnTimer.isSet();
         if (!isSet || repeatSpawnTimer.elapsed())
         {
             // spawn continuously after a delay
             isSet || repeatSpawnTimer.set(.5);
-            spawnRandomObject(mousePos);
+            GameObjects.spawnRandomObject(LJS.mousePos);
         }
     }
     else
         repeatSpawnTimer.unset();
-    if (mouseWasPressed(2) || keyWasPressed('KeyX'))
-        explosion(mousePos);
+    if (LJS.mouseWasPressed(2) || LJS.keyWasPressed('KeyX'))
+        GameObjects.explosion(LJS.mousePos);
     if (mouseJoint)
-        mouseJoint.SetTarget(mousePos.getBox2d());
+        mouseJoint.setTarget(LJS.mousePos);
 
-    if (keyWasPressed('KeyR'))
-        loadScene(scene); // reset scene
-    if (keyWasPressed('ArrowUp') || keyWasPressed('ArrowDown'))
+    if (LJS.keyWasPressed('KeyR'))
+        setScene(scene); // reset scene
+    if (LJS.keyWasPressed('ArrowUp') || LJS.keyWasPressed('ArrowDown'))
     {
         // change scene
-        scene += keyWasPressed('ArrowUp') ? 1 : -1;
-        scene = mod(scene, maxScenes);
-        loadScene(scene);
+        scene += LJS.keyWasPressed('ArrowUp') ? 1 : -1;
+        scene = LJS.mod(scene, maxScenes);
+        setScene(scene);
     }
-
     if (car)
     {
-        // update car control
-        const input = keyDirection();
+        // update car controls
+        const input = LJS.keyDirection();
         car.applyMotorInput(-input.x);
     }
 }
@@ -114,7 +142,7 @@ function gameUpdatePost()
 function gameRender()
 {
     // draw a grey square in the background without using webgl
-    drawRect(vec2(20,8), vec2(100), hsl(0,0,.8), 0, 0);
+    LJS.drawRect(vec2(20,8), vec2(100), hsl(0,0,.8), 0, 0);
 
     if (scene == 5)
     {
@@ -123,11 +151,11 @@ function gameRender()
         const distance = 10;
         for (let i=count;i--;)
         {
-            const start = mousePos;
-            const end = mousePos.add(vec2(distance,0).rotate(i/count*PI*2));
-            const result = box2dRaycast(start, end);
+            const start = LJS.mousePos;
+            const end = start.add(vec2(distance,0).rotate(i/count*LJS.PI*2));
+            const result = LJS.box2d.raycast(start, end);
             const color = result ? hsl(0,1,.5,.5) : hsl(.5,1,.5,.5);
-            drawLine(start, result ? result.point : end, .1, color);
+            LJS.drawLine(start, result ? result.point : end, .1, color);
         }
     }
 }
@@ -138,13 +166,13 @@ function gameRenderPost()
     if (mouseJoint)
     {
         // draw mouse joint
-        const ab = vec2(mouseJoint.GetAnchorB());
-        drawTile(ab, vec2(.3), spriteAtlas.circle, BLACK);
-        drawLine(mousePos, ab, .1, BLACK);
+        const ab = mouseJoint.getAnchorB();
+        LJS.drawTile(ab, vec2(.3), spriteAtlas.circle, LJS.BLACK);
+        LJS.drawLine(LJS.mousePos, ab, .1, LJS.BLACK);
     }
 
     // draw to overlay canvas for hud rendering
-    const pos = vec2(mainCanvasSize.x/2, 50);
+    const pos = vec2(LJS.mainCanvasSize.x/2, 50);
     drawText('LittleJS Box2D Demo', 80, 80);
     drawText(sceneName, 60, 100);
     if (scene == 0)
@@ -161,10 +189,10 @@ function gameRenderPost()
     }
 
     function drawText(text, size=40, gap=50)
-    { drawTextScreen(text, pos, size, WHITE, size*.1); pos.y += gap; }
+    { LJS.drawTextScreen(text, pos, size, LJS.WHITE, size*.1); pos.y += gap; }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Startup LittleJS Engine with Box2D
 
-box2dEngineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, ['tiles.png']);
+LJS.box2dEngineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, ['tiles.png']);

package/examples/box2d/gameObjects.js

@@ -6,97 +6,102 @@
 
 'use strict';
 
+// import LittleJS module
+import * as LJS from '../../dist/littlejs.esm.js';
+import * as Game from './game.js';
+const {vec2, hsl} = LJS;
+
 ///////////////////////////////////////////////////////////////////////////////
 // spawn object functions
 
-function spawnBox(pos, size=1, color=WHITE, type=box2dBodyTypeDynamic, applyTexture=true, angle=0)
+export function spawnBox(pos, size=1, color=LJS.WHITE, type=LJS.box2d.bodyTypeDynamic, applyTexture=true, angle=0)
 {
     size = typeof size == 'number' ? vec2(size) : size; // square
-    const o = new Box2dObject(pos, size, applyTexture && spriteAtlas.squareOutline, angle, color, type);
+    const o = new LJS.Box2dObject(pos, size, applyTexture && Game.spriteAtlas.squareOutline, angle, color, type);
     o.drawSize = size.scale(1.02); // slightly enlarge to cover gaps
     o.addBox(size);
     return o;
 }
 
-function spawnCircle(pos, diameter=1, color=WHITE, type=box2dBodyTypeDynamic, applyTexture=true, angle=0)
+export function spawnCircle(pos, diameter=1, color=LJS.WHITE, type=LJS.box2d.bodyTypeDynamic, applyTexture=true, angle=0)
 {
     const size = vec2(diameter);
-    const o = new Box2dObject(pos, size, applyTexture && spriteAtlas.circleOutline, angle, color, type);
+    const o = new LJS.Box2dObject(pos, size, applyTexture && Game.spriteAtlas.circleOutline, angle, color, type);
     o.addCircle(diameter);
     return o;
 }
 
-function spawnRandomPoly(pos, diameter=1, color=WHITE, type=box2dBodyTypeDynamic, angle=0)
+export function spawnRandomPoly(pos, diameter=1, color=LJS.WHITE, type=LJS.box2d.bodyTypeDynamic, angle=0)
 {
-    const o = new Box2dObject(pos, vec2(), 0, angle, color, type);
+    const o = new LJS.Box2dObject(pos, vec2(), 0, angle, color, type);
     o.addRandomPoly(diameter);
     return o;
 }
 
-function spawnRandomObject(pos, scale=1, type=box2dBodyTypeDynamic, angle=0)
+export function spawnRandomObject(pos, scale=1, type=LJS.box2d.bodyTypeDynamic, angle=0)
 {
-    if (randInt(2))
+    if (LJS.randInt(2))
     {
-        const size = vec2(scale*rand(.5,1), scale*rand(.5,1));
-        return spawnBox(pos, size, randColor(), type, true, angle);
+        const size = vec2(scale*LJS.rand(.5,1), scale*LJS.rand(.5,1));
+        return spawnBox(pos, size, LJS.randColor(), type, true, angle);
     }
     else
     {
-        const diameter = scale*rand(.5,1);
-        return spawnCircle(pos, diameter, randColor(), type, true, angle);
+        const diameter = scale*LJS.rand(.5,1);
+        return spawnCircle(pos, diameter, LJS.randColor(), type, true, angle);
     }
 }
 
-function spawnPyramid(pos, count)
+export function spawnPyramid(pos, count)
 {
     for (let i=count+1;i--;)
     for (let j=i;j--;)
-        spawnBox(pos.add(vec2(j-i/2+.5,count-i+.5)), 1, randColor());
+        spawnBox(pos.add(vec2(j-i/2+.5,count-i+.5)), 1, LJS.randColor());
 }
 
-function spawnDominoes(pos, count, size=vec2(.5,2))
+export function spawnDominoes(pos, count, size=vec2(.5,2))
 {
     for (let i=count; i--;)
-        spawnBox(pos.add(vec2(i*size.y*.9,size.y/2)), size, randColor());
+        spawnBox(pos.add(vec2(i*size.y*.9,size.y/2)), size, LJS.randColor());
 }
 
-function spawnRandomEdges()
+export function spawnRandomEdges()
 {
     // edge list along bottom
     const edgePoints = [];
     edgePoints.push(vec2(40,0));
     for (let i=40, y=0; i--;)
-        edgePoints.push(vec2(i, y=clamp(y+rand(-2,2),0,5)));
+        edgePoints.push(vec2(i, y=LJS.clamp(y+LJS.rand(-2,2),0,5)));
     edgePoints.push(vec2(0,0));
-    const o = new Box2dObject(vec2(), vec2(), 0, 0, BLACK, box2dBodyTypeStatic);
+    const o = new LJS.Box2dObject(vec2(), vec2(), 0, 0, LJS.BLACK, LJS.box2d.bodyTypeStatic);
     o.addEdgeList(edgePoints);
 }
 
-function spawnRope(startPos, count, angle=PI, color=WHITE, size=vec2(.3,1))
+export function spawnRope(startPos, count, angle=PI, color=LJS.WHITE, size=vec2(.3,1))
 {
-    let lastObject = groundObject;
+    let lastObject = Game.groundObject;
     for (let i=0; i<count; ++i)
     {
         const pos = startPos.add(size.multiply(vec2(0,i+.5)).rotate(-angle));
-        const o = spawnBox(pos, size, color, box2dBodyTypeDynamic, false, angle);
+        const o = spawnBox(pos, size, color, LJS.box2d.bodyTypeDynamic, false, angle);
         o.setFilterData(2, 2);
         const anchorPos = pos.add(vec2(0,-size.y/2).rotate(-angle));
-        box2dCreateRevoluteJoint(lastObject, o, anchorPos);
+        new LJS.Box2dRevoluteJoint(lastObject, o, anchorPos);
         lastObject = o;
     }
     const endPos = lastObject.localToWorld(vec2(0,-size.y/2));
-    box2dCreateRopeJoint(groundObject, lastObject, startPos, endPos);
+    new LJS.Box2dRopeJoint(Game.groundObject, lastObject, startPos, endPos);
     return lastObject;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // simple car vehicle using wheel joints
-class CarObject extends Box2dObject
+export class CarObject extends LJS.Box2dObject
 {
     constructor(pos)
     {
-        super(pos, vec2(), 0, 0, randColor());
+        super(pos, vec2(), 0, 0, LJS.randColor());
         const carPoints = [
             vec2(-1.5,-.5),
             vec2(1.5, -.5),
@@ -116,22 +121,22 @@ class CarObject extends Box2dObject
             const damping     = .7;
             const frequencyHz = 4;
             const maxTorque   = 50;
-            const sprite      = spriteAtlas.wheel;
+            const sprite      = Game.spriteAtlas.wheel;
 
             // create wheels
             this.wheels = [];
             const makeWheel = (pos, isMotor) =>
             {
-                const wheel = new Box2dObject(pos, vec2(diameter), sprite);
+                const wheel = new LJS.Box2dObject(pos, vec2(diameter), sprite);
                 wheel.addCircle(diameter, vec2(), density, friction, restitution);
                 this.wheels.push(wheel);
-                const joint = box2dCreateWheelJoint(this, wheel);
-                joint.SetSpringDampingRatio(damping);
-                joint.SetSpringFrequencyHz(frequencyHz);
+                const joint = new LJS.Box2dWheelJoint(this, wheel);
+                joint.setSpringDampingRatio(damping);
+                joint.setSpringFrequencyHz(frequencyHz);
                 if (isMotor)
                 {
-                    joint.SetMaxMotorTorque(maxTorque);
-                    joint.EnableMotor(true);
+                    joint.setMaxMotorTorque(maxTorque);
+                    joint.enableMotor(true);
                     this.wheelMotorJoint = joint;
                 }
             }
@@ -144,9 +149,9 @@ class CarObject extends Box2dObject
     {
         const maxSpeed = 40;
         const brakeAmount = .8;
-        let s = this.wheelMotorJoint.GetMotorSpeed();
-        s = input ? clamp(s + input, -maxSpeed, maxSpeed) : s * brakeAmount;
-        this.wheelMotorJoint.SetMotorSpeed(s);
+        let s = this.wheelMotorJoint.getMotorSpeed();
+        s = input ? LJS.clamp(s + input, -maxSpeed, maxSpeed) : s * brakeAmount;
+        this.wheelMotorJoint.setMotorSpeed(s);
     }
     destroy()
     {
@@ -158,27 +163,27 @@ class CarObject extends Box2dObject
 ///////////////////////////////////////////////////////////////////////////////
 
 // changes objects color when touched
-class ContactTester extends Box2dObject
+export class ContactTester extends LJS.Box2dObject
 {
     constructor(pos, size, color, contactColor, isCircle=true, isSensor=true)
     {
-        super(pos, size, 0, 0, color, box2dBodyTypeStatic);
+        super(pos, size, 0, 0, color, LJS.box2d.bodyTypeStatic);
         isCircle ? this.addCircle(size.x) : this.addBox(size);
         this.setSensor(isSensor);
         this.contactColor = contactColor;
     }
     beginContact(other) { other.color = this.contactColor; }
-    endContact(other)   { other.color = WHITE; }
+    endContact(other)   { other.color = LJS.WHITE; }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // balanced recursive mobile object with revolve joints
-class MobileObject extends Box2dObject
+export class MobileObject extends LJS.Box2dObject
 {
     constructor(anchor, w, h, depth)
     {
-        super(anchor, vec2(w, h), 0, 0, randColor());
+        super(anchor, vec2(w, h), 0, 0, LJS.randColor());
         this.addBox(vec2(h/4, h), vec2(0, -h/2));
         this.childMobiles = [];
         if (--depth)
@@ -190,7 +195,7 @@ class MobileObject extends Box2dObject
                 // spawn smaller mobiles attached to each side
                 const a = anchor.add(vec2( w/(i?2:-2), -h));
                 const o = new MobileObject(a, w/2, h, depth);
-                box2dCreateRevoluteJoint(this, o, a);
+                new LJS.Box2dRevoluteJoint(this, o, a);
                 this.childMobiles.push(o);
             }
         }
@@ -205,11 +210,11 @@ class MobileObject extends Box2dObject
 ///////////////////////////////////////////////////////////////////////////////
 
 // pulley object renders a rope to connected point
-class PulleyJointObjects extends Box2dObject
+export class PulleyJointObjects extends LJS.Box2dObject
 {
     constructor(pos, size, color, connectionPos)
     {
-        super(pos, size, spriteAtlas.squareOutline, 0, color);
+        super(pos, size, Game.spriteAtlas.squareOutline, 0, color);
         this.addBox(size);
         this.connectionPos = connectionPos;
     }
@@ -217,7 +222,7 @@ class PulleyJointObjects extends Box2dObject
     {
         // draw rope
         const topPos = this.localToWorld(vec2(0,this.size.y/2));
-        drawLine(topPos, this.connectionPos, .2, BLACK);
+        LJS.drawLine(topPos, this.connectionPos, .2, LJS.BLACK);
         super.render();
     }
 }
@@ -225,22 +230,22 @@ class PulleyJointObjects extends Box2dObject
 ///////////////////////////////////////////////////////////////////////////////
 
 // motor object renders a rope to connected point
-class MotorJointObject extends Box2dObject
+export class MotorJointObject extends LJS.Box2dObject
 {
     constructor(pos, size, color, otherObject)
     {
-        super(pos, size, spriteAtlas.wheel, 0, color);
+        super(pos, size, Game.spriteAtlas.wheel, 0, color);
         this.addCircle(size.x);
         this.connectionPos = pos;
-        const joint = box2dCreateMotorJoint(otherObject, this);
-        joint.SetMaxForce(500);
-        joint.SetMaxTorque(500);
+        const joint = new LJS.Box2dMotorJoint(otherObject, this);
+        joint.setMaxForce(500);
+        joint.setMaxTorque(500);
     }
     render()
     {
         // draw rope
         const width = 2/(1+this.pos.distance(this.connectionPos));
-        drawLine(this.pos, this.connectionPos, width, BLACK);
+        LJS.drawLine(this.pos, this.connectionPos, width, LJS.BLACK);
         super.render();
     }
 }
@@ -248,14 +253,14 @@ class MotorJointObject extends Box2dObject
 ///////////////////////////////////////////////////////////////////////////////
 
 // soft body sim using grid of weld joints
-class SoftBodyObject extends Box2dObject
+export class SoftBodyObject extends LJS.Box2dObject
 {
     constructor(pos, scale, sizeCount, color)
     {
         super(pos, vec2());
         const nodeSize = sizeCount.subtract(vec2(1));
         const spacing = scale.divide(nodeSize);
-        const objectDiameter = min(spacing.x, spacing.y);
+        const objectDiameter = LJS.min(spacing.x, spacing.y);
         this.sizeCount = sizeCount.copy();
 
         // create nodes
@@ -266,7 +271,7 @@ class SoftBodyObject extends Box2dObject
             const mass = .1;
             const center = vec2(x-nodeSize.x/2, y-nodeSize.y/2);
             const p = pos.add(center.multiply(spacing));
-            const o = new Box2dObject(p, vec2(objectDiameter*1.1), spriteAtlas.circle, 0, color);
+            const o = new LJS.Box2dObject(p, vec2(objectDiameter*1.1), Game.spriteAtlas.circle, 0, color);
             o.addCircle(objectDiameter);
             o.setMass(mass);
             o.setAngularDamping(10);
@@ -281,7 +286,7 @@ class SoftBodyObject extends Box2dObject
             const tryAddJoint = (xo, yo) =>
             {
                 const o2 = this.getNode(x+xo, y+yo);
-                const joint = o2 ? box2dCreateWeldJoint(o, o2) : 0;
+                const joint = o2 ? new LJS.Box2dWeldJoint(o, o2) : 0;
                 o.joints.push(joint);
             }
 
@@ -300,7 +305,7 @@ class SoftBodyObject extends Box2dObject
         for (let y = 0; y < sy.y; ++y) poly.push(this.getNode(sx-1, y).pos);
         for (let x = sx; x--;) poly.push(this.getNode(x, sy-1).pos);
         for (let y = sy; y--;) poly.push(this.getNode(0, y).pos);
-        box2dDrawPoly(vec2(), 0, poly, BLACK)
+        LJS.box2d.drawPoly(vec2(), 0, poly, LJS.BLACK)
     }
     getNode(x, y) 
     {
@@ -317,14 +322,14 @@ class SoftBodyObject extends Box2dObject
 ///////////////////////////////////////////////////////////////////////////////
 
 // cloth sim using grid of rope joints
-class ClothObject extends Box2dObject
+export class ClothObject extends LJS.Box2dObject
 {
     constructor(pos, scale, sizeCount, color, maxJointStress=10)
     {
-        super(pos, vec2(), 0, 0, color, box2dBodyTypeStatic);
+        super(pos, vec2(), 0, 0, color, LJS.box2d.bodyTypeStatic);
         const nodeSize = sizeCount.subtract(vec2(1));
         const spacing = scale.divide(nodeSize);
-        const objectDiameter = min(spacing.x, spacing.y);
+        const objectDiameter = LJS.min(spacing.x, spacing.y);
         this.sizeCount = sizeCount.copy();
         this.maxJointStress = maxJointStress;
         this.lineWidth = .1;
@@ -337,7 +342,7 @@ class ClothObject extends Box2dObject
             const mass = .5;
             const center = vec2(x-nodeSize.x/2, y-nodeSize.y/2);
             const p = pos.add(center.multiply(spacing));
-            const o = new Box2dObject(p, vec2(.4), spriteAtlas.circle, 0, color);
+            const o = new LJS.Box2dObject(p, vec2(.4), Game.spriteAtlas.circle, 0, color);
             o.addCircle(objectDiameter);
             o.setFilterData(2, 2);
             o.setLinearDamping(1);
@@ -357,7 +362,7 @@ class ClothObject extends Box2dObject
             const tryAddJoint = (xo, yo) =>
             {
                 const o2 = this.getNode(x2+xo, y+yo);
-                const joint = o2 ? box2dCreateRopeJoint(o, o2) : 0;
+                const joint = o2 ? new LJS.Box2dRopeJoint(o, o2) : 0;
                 o.joints.push(joint);
             }
 
@@ -374,7 +379,7 @@ class ClothObject extends Box2dObject
                 tryAddJoint( d, 1);
 
                 // attach pin joint to top row
-                y || box2dCreatePinJoint(this, this.getNode(x, y));
+                y || new LJS.Box2dPinJoint(this.getNode(x, y), this);
             }
         }
     }
@@ -398,15 +403,15 @@ class ClothObject extends Box2dObject
                 const j = joints[i];
                 if (!j) continue;
 
-                const oA = j.GetBodyA().object;
-                const oB = j.GetBodyB().object;
+                const oA = j.getObjectA();
+                const oB = j.getObjectB();
                 const d2 = oA.pos.distanceSquared(oB.pos);
-                const maxLength2 = j.GetMaxLength()**2;
-                const stress = vec2(j.GetReactionForce(1)).length();
+                const maxLength2 = j.getMaxLength()**2;
+                const stress = j.getReactionForce(1).length();
                 if (stress > this.maxJointStress || d2 > maxLength2*4)
                 {
                     // remove stressed joint
-                    box2dDestroyJoint(j);
+                    j.destroy();
                     joints[i] = 0;
                 }
             }
@@ -428,9 +433,9 @@ class ClothObject extends Box2dObject
             for (const joint of o.joints)
             {
                 if (!joint) continue;
-                const oA = joint.GetBodyA().object;
-                const oB = joint.GetBodyB().object;
-                drawLine(oA.pos, oB.pos, this.lineWidth, BLACK);
+                const oA = joint.getObjectA();
+                const oB = joint.getObjectB();
+                LJS.drawLine(oA.pos, oB.pos, this.lineWidth, LJS.BLACK);
             }
         }
     }
@@ -444,43 +449,42 @@ class ClothObject extends Box2dObject
 ///////////////////////////////////////////////////////////////////////////////
 // Effects
 
-const sound_click = new Sound([.2,.1,,,,.01,,,,,,,,,,,,,,,-500]); // Loaded Sound 0
-const sound_explosion = new Sound([.5,.2,72,.01,.01,.2,4,,,,,,,1,,.5,.1,.5,.02]);
+const sound_explosion = new LJS.Sound([.5,.2,72,.01,.01,.2,4,,,,,,,1,,.5,.1,.5,.02]);
 
-function explosion(pos, radius=3, strength=300)
+export function explosion(pos, radius=3, strength=300)
 {
     sound_explosion.play(pos);
-    const objects = box2dCircleCastAll(pos, (radius*2));
-    const newColor = randColor();
+    const objects = LJS.box2d.circleCastAll(pos, (radius*2));
+    const newColor = LJS.randColor();
     for (const o of objects)
     {
-        const p = percent(o.pos.distance(pos), 2*radius, radius);
+        const p = LJS.percent(o.pos.distance(pos), 2*radius, radius);
         const force = o.pos.subtract(pos).normalize(p*radius*strength);
         o.applyForce(force);
         o.color = newColor;
     }
 
     // smoke
-    new ParticleEmitter(
-        pos, 0,                     // pos, angle
-        radius/2, .2, 50*radius, PI,// emitSize, emitTime, emitRate, emitCone
-        spriteAtlas.dot,            // tileInfo
-        hsl(0,0,0),   hsl(0,0,0),   // colorStartA, colorStartB
-        hsl(0,0,0,0), hsl(0,0,0,0), // colorEndA, colorEndB
-        1, 1, 2, .1, .1,    // time, sizeStart, sizeEnd, speed, angleSpeed
-        .9, 1, -.5, PI, .1, // damp, angleDamp, gravity, particleCone, fade
-        1, 0, 0, 0, 1e8     // randomness, collide, additive, colorLinear, renderOrder
+    new LJS.ParticleEmitter(
+        pos, 0,                       // pos, angle
+        radius/2, .2, 50*radius, 3.14,// emitSize, emitTime, emitRate, emitCone
+        Game.spriteAtlas.dot,         // tileInfo
+        hsl(0,0,0),   hsl(0,0,0),     // colorStartA, colorStartB
+        hsl(0,0,0,0), hsl(0,0,0,0),   // colorEndA, colorEndB
+        1, 1, 2, .1, .1,      // time, sizeStart, sizeEnd, speed, angleSpeed
+        .9, 1, -.5, 3.14, .1, // damp, angleDamp, gravity, particleCone, fade
+        1, 0, 0, 0, 1e8       // randomness, collide, additive, colorLinear, renderOrder
     );
 
     // fire
-    new ParticleEmitter(
+    new LJS.ParticleEmitter(
         pos, 0,                         // pos, angle
-        radius, .1, 100*radius, PI,     // emitSize, emitTime, emitRate, emitCone
-        spriteAtlas.dot,                // tileInfo
+        radius, .1, 100*radius, 3.14,   // emitSize, emitTime, emitRate, emitCone
+        Game.spriteAtlas.dot,           // tileInfo
         hsl(0,1,.5),   hsl(.15,1,.5),   // colorStartA, colorStartB
         hsl(0,1,.5,0), hsl(.1, 1,.5,0), // colorEndA, colorEndB
-        .7, 1, .5, .1, .1, // time, sizeStart, sizeEnd, speed, angleSpeed
-        .9, 1, 0, PI, .05, // damp, angleDamp, gravity, particleCone, fade
-        1, 0, 1, 0, 1e9    // randomness, collide, additive, colorLinear, renderOrder
+        .7, 1, .5, .1, .1,   // time, sizeStart, sizeEnd, speed, angleSpeed
+        .9, 1, 0, 3.14, .05, // damp, angleDamp, gravity, particleCone, fade
+        1, 0, 1, 0, 1e9      // randomness, collide, additive, colorLinear, renderOrder
     );
-}
+}