From 21affab7b1f2013a450996790e172acd6afa7cdb Mon Sep 17 00:00:00 2001
From: landgreen <rosslandgreen@gmail.com>
Date: Sun, 24 Jan 2021 08:54:26 -0800
Subject: [PATCH] renamed mech to m

to continue playing after the final boss you need to use testing mode:  "T" -> "U"
renamed mech -> m
---
 .DS_Store        |  Bin 6148 -> 6148 bytes
 index.html       |   20 +-
 js/bullet.js     |  850 ++++++++++++-------------
 js/engine.js     |   68 +-
 js/index.js      |   52 +-
 js/level.js      |   94 +--
 js/mob.js        |   78 +--
 js/player.js     | 1580 +++++++++++++++++++++++-----------------------
 js/powerup.js    |   80 +--
 js/simulation.js |  180 +++---
 js/spawn.js      |  156 ++---
 js/tech.js       |  260 ++++----
 todo.txt         |   37 +-
 13 files changed, 1725 insertions(+), 1730 deletions(-)

diff --git a/.DS_Store b/.DS_Store
index c965d31408ec332037cc30def3a5fac5adfbd266..c7f9d51c943093142f5d2e6a7ffd015430c772a3 100644
GIT binary patch
delta 22
dcmZoMXffEJ#muzp;A9<UUnao?o2!{SMF3YT2U7q5

delta 22
dcmZoMXffEJ#mp49YO)TqFO$H5&DG4EA^=gb2LAv6

diff --git a/index.html b/index.html
index cbdbe76..48f0060 100644
--- a/index.html
+++ b/index.html
@@ -53,16 +53,16 @@
 	<audio id="launcher" src="sounds\guns\launcher2.ogg" preload="auto"></audio> -->
 
     <!-- player walk -->
-    <!-- <audio id="walk1" src="sounds\mech\walk1.ogg" preload="auto"></audio>
-	<audio id="walk2" src="sounds\mech\walk2.ogg" preload="auto"></audio>
-	<audio id="walk3" src="sounds\mech\walk3.ogg" preload="auto"></audio>
-	<audio id="walk4" src="sounds\mech\walk4.ogg" preload="auto"></audio>
-	<audio id="walk5" src="sounds\mech\walk5.ogg" preload="auto"></audio>
-	<audio id="walk6" src="sounds\mech\walk6.ogg" preload="auto"></audio>
-	<audio id="walk7" src="sounds\mech\walk7.ogg" preload="auto"></audio>
-	<audio id="walk8" src="sounds\mech\walk8.ogg" preload="auto"></audio>
-	<audio id="walk9" src="sounds\mech\walk9.ogg" preload="auto"></audio>
-	<audio id="walk10" src="sounds\mech\walk10.ogg" preload="auto"></audio> -->
+    <!-- <audio id="walk1" src="sounds\m\walk1.ogg" preload="auto"></audio>
+	<audio id="walk2" src="sounds\m\walk2.ogg" preload="auto"></audio>
+	<audio id="walk3" src="sounds\m\walk3.ogg" preload="auto"></audio>
+	<audio id="walk4" src="sounds\m\walk4.ogg" preload="auto"></audio>
+	<audio id="walk5" src="sounds\m\walk5.ogg" preload="auto"></audio>
+	<audio id="walk6" src="sounds\m\walk6.ogg" preload="auto"></audio>
+	<audio id="walk7" src="sounds\m\walk7.ogg" preload="auto"></audio>
+	<audio id="walk8" src="sounds\m\walk8.ogg" preload="auto"></audio>
+	<audio id="walk9" src="sounds\m\walk9.ogg" preload="auto"></audio>
+	<audio id="walk10" src="sounds\m\walk10.ogg" preload="auto"></audio> -->
 
     <!-- player dmg -->
     <!-- <audio id="dmg0" src="sounds\dmg\dmg0.ogg" preload="auto"></audio>
diff --git a/js/bullet.js b/js/bullet.js
index e0f1bc3..46882e8 100644
--- a/js/bullet.js
+++ b/js/bullet.js
@@ -17,10 +17,10 @@ const b = {
     },
     fire() {},
     fireNormal() {
-        if (input.fire && mech.fireCDcycle < mech.cycle && (!input.field || mech.fieldFire) && b.inventory.length) {
+        if (input.fire && m.fireCDcycle < m.cycle && (!input.field || m.fieldFire) && b.inventory.length) {
             if (b.guns[b.activeGun].ammo > 0) {
                 b.guns[b.activeGun].fire();
-                if (tech.isCrouchAmmo && mech.crouch) {
+                if (tech.isCrouchAmmo && m.crouch) {
                     if (tech.isCrouchAmmo % 2) {
                         b.guns[b.activeGun].ammo--;
                         simulation.updateGunHUD();
@@ -32,26 +32,26 @@ const b = {
                 }
             } else {
                 if (tech.isAmmoFromHealth) {
-                    if (mech.health > 0.05) {
-                        mech.damage(0.05 / mech.harmReduction()); //  /mech.harmReduction() undoes  damage increase from difficulty
-                        if (!(tech.isRewindAvoidDeath && mech.energy > 0.66)) { //don't give ammo if CPT triggered
-                            for (let i = 0; i < 3; i++) powerUps.spawn(mech.pos.x, mech.pos.y, "ammo");
+                    if (m.health > 0.05) {
+                        m.damage(0.05 / m.harmReduction()); //  /m.harmReduction() undoes  damage increase from difficulty
+                        if (!(tech.isRewindAvoidDeath && m.energy > 0.66)) { //don't give ammo if CPT triggered
+                            for (let i = 0; i < 3; i++) powerUps.spawn(m.pos.x, m.pos.y, "ammo");
                         }
                     }
                 } else {
                     simulation.makeTextLog(`${b.guns[b.activeGun].name}.<span class='color-gun'>ammo</span><span class='color-symbol'>:</span> 0`);
                 }
-                mech.fireCDcycle = mech.cycle + 30; //fire cooldown        
+                m.fireCDcycle = m.cycle + 30; //fire cooldown        
             }
-            if (mech.holdingTarget) mech.drop();
+            if (m.holdingTarget) m.drop();
         }
     },
     fireNotMove() {
-        //added  && player.speed < 0.5 && mech.onGround ************************* 
-        if (input.fire && mech.fireCDcycle < mech.cycle && (!input.field || mech.fieldFire) && b.inventory.length && player.speed < 0.5 && mech.onGround && Math.abs(mech.yOff - mech.yOffGoal) < 1) {
+        //added  && player.speed < 0.5 && m.onGround ************************* 
+        if (input.fire && m.fireCDcycle < m.cycle && (!input.field || m.fieldFire) && b.inventory.length && player.speed < 0.5 && m.onGround && Math.abs(m.yOff - m.yOffGoal) < 1) {
             if (b.guns[b.activeGun].ammo > 0) {
                 b.guns[b.activeGun].fire();
-                if (tech.isCrouchAmmo && mech.crouch) {
+                if (tech.isCrouchAmmo && m.crouch) {
                     if (tech.isCrouchAmmo % 2) {
                         b.guns[b.activeGun].ammo--;
                         simulation.updateGunHUD();
@@ -63,27 +63,27 @@ const b = {
                 }
             } else {
                 if (tech.isAmmoFromHealth) {
-                    if (mech.health > 0.05) {
-                        mech.damage(0.05 / mech.harmReduction()); //  /mech.harmReduction() undoes  damage increase from difficulty
-                        if (!(tech.isRewindAvoidDeath && mech.energy > 0.66)) { //don't give ammo if CPT triggered
-                            for (let i = 0; i < 3; i++) powerUps.spawn(mech.pos.x, mech.pos.y, "ammo");
+                    if (m.health > 0.05) {
+                        m.damage(0.05 / m.harmReduction()); //  /m.harmReduction() undoes  damage increase from difficulty
+                        if (!(tech.isRewindAvoidDeath && m.energy > 0.66)) { //don't give ammo if CPT triggered
+                            for (let i = 0; i < 3; i++) powerUps.spawn(m.pos.x, m.pos.y, "ammo");
                         }
                     }
                 } else {
                     simulation.makeTextLog(`${b.guns[b.activeGun].name}.<span class='color-gun'>ammo</span><span class='color-symbol'>:</span> 0`);
                 }
-                mech.fireCDcycle = mech.cycle + 30; //fire cooldown        
+                m.fireCDcycle = m.cycle + 30; //fire cooldown        
             }
-            if (mech.holdingTarget) mech.drop();
+            if (m.holdingTarget) m.drop();
         }
     },
     fireFloat() {
-        //added  && player.speed < 0.5 && mech.onGround ************************* 
-        if (input.fire && (!input.field || mech.fieldFire) && b.inventory.length) {
-            if (mech.fireCDcycle < mech.cycle) {
+        //added  && player.speed < 0.5 && m.onGround ************************* 
+        if (input.fire && (!input.field || m.fieldFire) && b.inventory.length) {
+            if (m.fireCDcycle < m.cycle) {
                 if (b.guns[b.activeGun].ammo > 0) {
                     b.guns[b.activeGun].fire();
-                    if (tech.isCrouchAmmo && mech.crouch) {
+                    if (tech.isCrouchAmmo && m.crouch) {
                         if (tech.isCrouchAmmo % 2) {
                             b.guns[b.activeGun].ammo--;
                             simulation.updateGunHUD();
@@ -95,18 +95,18 @@ const b = {
                     }
                 } else {
                     if (tech.isAmmoFromHealth) {
-                        if (mech.health > 0.05) {
-                            mech.damage(0.05 / mech.harmReduction()); //  /mech.harmReduction() undoes  damage increase from difficulty
-                            if (!(tech.isRewindAvoidDeath && mech.energy > 0.66)) { //don't give ammo if CPT triggered
-                                for (let i = 0; i < 3; i++) powerUps.spawn(mech.pos.x, mech.pos.y, "ammo");
+                        if (m.health > 0.05) {
+                            m.damage(0.05 / m.harmReduction()); //  /m.harmReduction() undoes  damage increase from difficulty
+                            if (!(tech.isRewindAvoidDeath && m.energy > 0.66)) { //don't give ammo if CPT triggered
+                                for (let i = 0; i < 3; i++) powerUps.spawn(m.pos.x, m.pos.y, "ammo");
                             }
                         }
                     } else {
                         simulation.makeTextLog(`${b.guns[b.activeGun].name}.<span class='color-gun'>ammo</span><span class='color-symbol'>:</span> 0`);
                     }
-                    mech.fireCDcycle = mech.cycle + 30; //fire cooldown        
+                    m.fireCDcycle = m.cycle + 30; //fire cooldown        
                 }
-                if (mech.holdingTarget) mech.drop();
+                if (m.holdingTarget) m.drop();
             }
             Matter.Body.setVelocity(player, {
                 x: 0,
@@ -221,10 +221,10 @@ const b = {
         }
     },
     fireProps(cd, speed, dir, me) {
-        mech.fireCDcycle = mech.cycle + Math.floor(cd * b.fireCD); // cool down
+        m.fireCDcycle = m.cycle + Math.floor(cd * b.fireCD); // cool down
         Matter.Body.setVelocity(bullet[me], {
-            x: mech.Vx / 2 + speed * Math.cos(dir),
-            y: mech.Vy / 2 + speed * Math.sin(dir)
+            x: m.Vx / 2 + speed * Math.cos(dir),
+            y: m.Vy / 2 + speed * Math.sin(dir)
         });
         World.add(engine.world, bullet[me]); //add bullet to world
     },
@@ -273,7 +273,7 @@ const b = {
     muzzleFlash(radius = 10) {
         ctx.fillStyle = "#fb0";
         ctx.beginPath();
-        ctx.arc(mech.pos.x + 35 * Math.cos(mech.angle), mech.pos.y + 35 * Math.sin(mech.angle), radius, 0, 2 * Math.PI);
+        ctx.arc(m.pos.x + 35 * Math.cos(m.angle), m.pos.y + 35 * Math.sin(m.angle), radius, 0, 2 * Math.PI);
         ctx.fill();
     },
     removeConsBB(me) {
@@ -350,10 +350,10 @@ const b = {
 
         if (dist < radius) {
             if (tech.isImmuneExplosion) {
-                const mitigate = Math.min(1, Math.max(1 - mech.energy * 0.7, 0))
-                mech.damage(mitigate * radius * (tech.isExplosionHarm ? 0.0004 : 0.0001));
+                const mitigate = Math.min(1, Math.max(1 - m.energy * 0.7, 0))
+                m.damage(mitigate * radius * (tech.isExplosionHarm ? 0.0004 : 0.0001));
             } else {
-                mech.damage(radius * (tech.isExplosionHarm ? 0.0004 : 0.0001));
+                m.damage(radius * (tech.isExplosionHarm ? 0.0004 : 0.0001));
             }
             knock = Vector.mult(Vector.normalise(sub), -Math.sqrt(dmg) * player.mass * 0.013);
             player.force.x += knock.x;
@@ -423,17 +423,17 @@ const b = {
             }
         }
     },
-    pulse(energy, angle = mech.angle) {
+    pulse(energy, angle = m.angle) {
         let best;
         let explosionRange = 1560 * energy
         let range = 3000
         const path = [{
-                x: mech.pos.x + 20 * Math.cos(angle),
-                y: mech.pos.y + 20 * Math.sin(angle)
+                x: m.pos.x + 20 * Math.cos(angle),
+                y: m.pos.y + 20 * Math.sin(angle)
             },
             {
-                x: mech.pos.x + range * Math.cos(angle),
-                y: mech.pos.y + range * Math.sin(angle)
+                x: m.pos.x + range * Math.cos(angle),
+                y: m.pos.y + range * Math.sin(angle)
             }
         ];
         const vertexCollision = function(v1, v1End, domain) {
@@ -553,7 +553,7 @@ const b = {
 
     },
     setGrenadeMode() {
-        grenadeDefault = function(where = { x: mech.pos.x + 30 * Math.cos(mech.angle), y: mech.pos.y + 30 * Math.sin(mech.angle) }, angle = mech.angle) {
+        grenadeDefault = function(where = { x: m.pos.x + 30 * Math.cos(m.angle), y: m.pos.y + 30 * Math.sin(m.angle) }, angle = m.angle) {
             const me = bullet.length;
             bullet[me] = Bodies.circle(where.x, where.y, 15, b.fireAttributes(angle, false));
             Matter.Body.setDensity(bullet[me], 0.0005);
@@ -566,19 +566,19 @@ const b = {
             bullet[me].beforeDmg = function() {
                 this.endCycle = 0; //bullet ends cycle after doing damage  //this also triggers explosion
             };
-            speed = mech.crouch ? 43 : 32
+            speed = m.crouch ? 43 : 32
             Matter.Body.setVelocity(bullet[me], {
-                x: mech.Vx / 2 + speed * Math.cos(angle),
-                y: mech.Vy / 2 + speed * Math.sin(angle)
+                x: m.Vx / 2 + speed * Math.cos(angle),
+                y: m.Vy / 2 + speed * Math.sin(angle)
             });
-            bullet[me].endCycle = simulation.cycle + Math.floor(mech.crouch ? 120 : 80);
+            bullet[me].endCycle = simulation.cycle + Math.floor(m.crouch ? 120 : 80);
             bullet[me].restitution = 0.4;
             bullet[me].do = function() {
                 this.force.y += this.mass * 0.0025; //extra gravity for harder arcs
             };
             World.add(engine.world, bullet[me]); //add bullet to world
         }
-        grenadeRPG = function(where = { x: mech.pos.x + 30 * Math.cos(mech.angle), y: mech.pos.y + 30 * Math.sin(mech.angle) }, angle = mech.angle) {
+        grenadeRPG = function(where = { x: m.pos.x + 30 * Math.cos(m.angle), y: m.pos.y + 30 * Math.sin(m.angle) }, angle = m.angle) {
             const me = bullet.length;
             bullet[me] = Bodies.circle(where.x, where.y, 15, b.fireAttributes(angle, false));
             Matter.Body.setDensity(bullet[me], 0.0005);
@@ -591,10 +591,10 @@ const b = {
             bullet[me].beforeDmg = function() {
                 this.endCycle = 0; //bullet ends cycle after doing damage  //this also triggers explosion
             };
-            speed = mech.crouch ? 46 : 32
+            speed = m.crouch ? 46 : 32
             Matter.Body.setVelocity(bullet[me], {
-                x: mech.Vx / 2 + speed * Math.cos(angle),
-                y: mech.Vy / 2 + speed * Math.sin(angle)
+                x: m.Vx / 2 + speed * Math.cos(angle),
+                y: m.Vy / 2 + speed * Math.sin(angle)
             });
             World.add(engine.world, bullet[me]); //add bullet to world
 
@@ -613,7 +613,7 @@ const b = {
                 }
             };
         }
-        grenadeRPGVacuum = function(where = { x: mech.pos.x + 30 * Math.cos(mech.angle), y: mech.pos.y + 30 * Math.sin(mech.angle) }, angle = mech.angle) {
+        grenadeRPGVacuum = function(where = { x: m.pos.x + 30 * Math.cos(m.angle), y: m.pos.y + 30 * Math.sin(m.angle) }, angle = m.angle) {
             const me = bullet.length;
             bullet[me] = Bodies.circle(where.x, where.y, 15, b.fireAttributes(angle, false));
             Matter.Body.setDensity(bullet[me], 0.0005);
@@ -626,10 +626,10 @@ const b = {
             bullet[me].beforeDmg = function() {
                 this.endCycle = 0; //bullet ends cycle after doing damage  //this also triggers explosion
             };
-            speed = mech.crouch ? 46 : 32
+            speed = m.crouch ? 46 : 32
             Matter.Body.setVelocity(bullet[me], {
-                x: mech.Vx / 2 + speed * Math.cos(angle),
-                y: mech.Vy / 2 + speed * Math.sin(angle)
+                x: m.Vx / 2 + speed * Math.cos(angle),
+                y: m.Vy / 2 + speed * Math.sin(angle)
             });
             World.add(engine.world, bullet[me]); //add bullet to world
 
@@ -689,7 +689,7 @@ const b = {
                 }
             };
         }
-        grenadeVacuum = function(where = { x: mech.pos.x + 30 * Math.cos(mech.angle), y: mech.pos.y + 30 * Math.sin(mech.angle) }, angle = mech.angle) {
+        grenadeVacuum = function(where = { x: m.pos.x + 30 * Math.cos(m.angle), y: m.pos.y + 30 * Math.sin(m.angle) }, angle = m.angle) {
             const me = bullet.length;
             bullet[me] = Bodies.circle(where.x, where.y, 20, b.fireAttributes(angle, false));
             Matter.Body.setDensity(bullet[me], 0.0003);
@@ -749,21 +749,21 @@ const b = {
             };
             speed = 35
             bullet[me].endCycle = simulation.cycle + 70;
-            if (mech.crouch) {
+            if (m.crouch) {
                 speed += 9
                 bullet[me].endCycle += 20;
             }
             Matter.Body.setVelocity(bullet[me], {
-                x: mech.Vx / 2 + speed * Math.cos(angle),
-                y: mech.Vy / 2 + speed * Math.sin(angle)
+                x: m.Vx / 2 + speed * Math.cos(angle),
+                y: m.Vy / 2 + speed * Math.sin(angle)
             });
             World.add(engine.world, bullet[me]); //add bullet to world
         }
 
-        grenadeNeutron = function(where = { x: mech.pos.x + 30 * Math.cos(mech.angle), y: mech.pos.y + 30 * Math.sin(mech.angle) }, angle = mech.angle) {
+        grenadeNeutron = function(where = { x: m.pos.x + 30 * Math.cos(m.angle), y: m.pos.y + 30 * Math.sin(m.angle) }, angle = m.angle) {
             const me = bullet.length;
             bullet[me] = Bodies.polygon(where.x, where.y, 10, 4, b.fireAttributes(angle, false));
-            b.fireProps(mech.crouch ? 45 : 25, mech.crouch ? 35 : 20, angle, me); //cd , speed
+            b.fireProps(m.crouch ? 45 : 25, m.crouch ? 35 : 20, angle, me); //cd , speed
             Matter.Body.setDensity(bullet[me], 0.000001);
             bullet[me].endCycle = Infinity;
             bullet[me].frictionAir = 0;
@@ -782,10 +782,10 @@ const b = {
                 const SCALE = 2
                 Matter.Body.scale(bullet[me], SCALE, SCALE);
 
-                speed = mech.crouch ? 25 : 15
+                speed = m.crouch ? 25 : 15
                 Matter.Body.setVelocity(bullet[me], {
-                    x: mech.Vx / 2 + speed * Math.cos(angle),
-                    y: mech.Vy / 2 + speed * Math.sin(angle)
+                    x: m.Vx / 2 + speed * Math.cos(angle),
+                    y: m.Vy / 2 + speed * Math.sin(angle)
                 });
 
                 const MAG = 0.005
@@ -873,7 +873,7 @@ const b = {
             }
             bullet[me].radiationMode = function() { //the do code after the bullet is stuck on something,  projects a damaging radiation field
                 this.stuck(); //runs different code based on what the bullet is stuck to
-                if (!mech.isBodiesAsleep) {
+                if (!m.isBodiesAsleep) {
                     this.damageRadius = this.damageRadius * 0.85 + 0.15 * this.maxDamageRadius //smooth radius towards max
                     this.maxDamageRadius -= this.radiusDecay
                     if (this.damageRadius < 15) {
@@ -882,11 +882,11 @@ const b = {
                         //aoe damage to player
                         if (!tech.isNeutronImmune && Vector.magnitude(Vector.sub(player.position, this.position)) < this.damageRadius) {
                             const DRAIN = 0.0023
-                            if (mech.energy > DRAIN) {
-                                mech.energy -= DRAIN
+                            if (m.energy > DRAIN) {
+                                m.energy -= DRAIN
                             } else {
-                                mech.energy = 0;
-                                mech.damage(0.00015)
+                                m.energy = 0;
+                                m.damage(0.00015)
                             }
                         }
                         //aoe damage to mobs
@@ -1006,8 +1006,8 @@ const b = {
                 }
             },
             do() {
-                if (!mech.isBodiesAsleep) {
-                    if (!(mech.cycle % this.lookFrequency)) this.tryToLockOn();
+                if (!m.isBodiesAsleep) {
+                    if (!(m.cycle % this.lookFrequency)) this.tryToLockOn();
                     if (this.lockedOn) { //rotate missile towards the target
                         const face = {
                             x: Math.cos(this.angle),
@@ -1048,8 +1048,8 @@ const b = {
         });
         const thrust = 0.0066 * bullet[me].mass * (tech.missileSize ? 0.6 : 1);
         Matter.Body.setVelocity(bullet[me], {
-            x: mech.Vx / 2 + speed * Math.cos(angle),
-            y: mech.Vy / 2 + speed * Math.sin(angle)
+            x: m.Vx / 2 + speed * Math.cos(angle),
+            y: m.Vy / 2 + speed * Math.sin(angle)
         });
         World.add(engine.world, bullet[me]); //add bullet to world
     },
@@ -1059,18 +1059,18 @@ const b = {
     didExtruderDrain: false,
     canExtruderFire: true,
     extruder() {
-        const DRAIN = 0.0007 + mech.fieldRegen
-        if (mech.energy > DRAIN && b.canExtruderFire) {
-            mech.energy -= DRAIN
-            if (mech.energy < 0) {
-                mech.fieldCDcycle = mech.cycle + 120;
-                mech.energy = 0;
+        const DRAIN = 0.0007 + m.fieldRegen
+        if (m.energy > DRAIN && b.canExtruderFire) {
+            m.energy -= DRAIN
+            if (m.energy < 0) {
+                m.fieldCDcycle = m.cycle + 120;
+                m.energy = 0;
             }
             b.isExtruderOn = true
             const SPEED = 10
             const me = bullet.length;
-            const where = Vector.add(mech.pos, player.velocity)
-            bullet[me] = Bodies.polygon(where.x + 20 * Math.cos(mech.angle), where.y + 20 * Math.sin(mech.angle), 4, 0.01, {
+            const where = Vector.add(m.pos, player.velocity)
+            bullet[me] = Bodies.polygon(where.x + 20 * Math.cos(m.angle), where.y + 20 * Math.sin(m.angle), 4, 0.01, {
                 cycle: -0.5,
                 isWave: true,
                 endCycle: simulation.cycle + 10 + 40 * tech.isPlasmaRange,
@@ -1091,7 +1091,7 @@ const b = {
                 beforeDmg() {},
                 onEnd() {},
                 do() {
-                    if (!mech.isBodiesAsleep) {
+                    if (!m.isBodiesAsleep) {
                         if (this.endCycle < simulation.cycle + 1) this.isWave = false
                         if (Matter.Query.point(map, this.position).length) { //check if inside map
                             this.isBranch = true;
@@ -1116,7 +1116,7 @@ const b = {
                             }
                         }
                         this.cycle++
-                        const wiggleMag = (mech.crouch ? 6 : 12) * Math.cos(simulation.cycle * 0.09)
+                        const wiggleMag = (m.crouch ? 6 : 12) * Math.cos(simulation.cycle * 0.09)
                         const wiggle = Vector.mult(transverse, wiggleMag * Math.cos(this.cycle * 0.36)) //+ wiggleMag * Math.cos(simulation.cycle * 0.3))
                         const velocity = Vector.mult(player.velocity, 0.3) //move with player
                         Matter.Body.setPosition(this, Vector.add(velocity, Vector.add(this.position, wiggle)))
@@ -1126,37 +1126,37 @@ const b = {
             });
             World.add(engine.world, bullet[me]); //add bullet to world
             Matter.Body.setVelocity(bullet[me], {
-                x: SPEED * Math.cos(mech.angle),
-                y: SPEED * Math.sin(mech.angle)
+                x: SPEED * Math.cos(m.angle),
+                y: SPEED * Math.sin(m.angle)
             });
             const transverse = Vector.normalise(Vector.perp(bullet[me].velocity))
-            if (180 - Math.abs(Math.abs(b.lastAngle - mech.angle) - 180) > 0.3) bullet[me].isBranch = true; //don't draw stroke for this bullet
-            b.lastAngle = mech.angle //track last angle for the above angle difference calculation
+            if (180 - Math.abs(Math.abs(b.lastAngle - m.angle) - 180) > 0.3) bullet[me].isBranch = true; //don't draw stroke for this bullet
+            b.lastAngle = m.angle //track last angle for the above angle difference calculation
             if (!b.wasExtruderOn) bullet[me].isBranch = true;
         } else {
             b.canExtruderFire = false;
         }
     },
     plasma() {
-        const DRAIN = 0.00008 + mech.fieldRegen
-        if (mech.energy > DRAIN) {
-            mech.energy -= DRAIN;
-            if (mech.energy < 0) {
-                mech.fieldCDcycle = mech.cycle + 120;
-                mech.energy = 0;
+        const DRAIN = 0.00008 + m.fieldRegen
+        if (m.energy > DRAIN) {
+            m.energy -= DRAIN;
+            if (m.energy < 0) {
+                m.fieldCDcycle = m.cycle + 120;
+                m.energy = 0;
             }
 
             //calculate laser collision
             let best;
-            let range = tech.isPlasmaRange * (120 + (mech.crouch ? 400 : 300) * Math.sqrt(Math.random())) //+ 100 * Math.sin(mech.cycle * 0.3);
-            // const dir = mech.angle // + 0.04 * (Math.random() - 0.5)
+            let range = tech.isPlasmaRange * (120 + (m.crouch ? 400 : 300) * Math.sqrt(Math.random())) //+ 100 * Math.sin(m.cycle * 0.3);
+            // const dir = m.angle // + 0.04 * (Math.random() - 0.5)
             const path = [{
-                    x: mech.pos.x + 20 * Math.cos(mech.angle),
-                    y: mech.pos.y + 20 * Math.sin(mech.angle)
+                    x: m.pos.x + 20 * Math.cos(m.angle),
+                    y: m.pos.y + 20 * Math.sin(m.angle)
                 },
                 {
-                    x: mech.pos.x + range * Math.cos(mech.angle),
-                    y: mech.pos.y + range * Math.sin(mech.angle)
+                    x: m.pos.x + range * Math.cos(m.angle),
+                    y: m.pos.y + range * Math.sin(m.angle)
                 }
             ];
             const vertexCollision = function(v1, v1End, domain) {
@@ -1223,7 +1223,7 @@ const b = {
                     best.who.locatePlayer();
 
                     //push mobs away
-                    const force = Vector.mult(Vector.normalise(Vector.sub(mech.pos, path[1])), -0.01 * Math.min(5, best.who.mass))
+                    const force = Vector.mult(Vector.normalise(Vector.sub(m.pos, path[1])), -0.01 * Math.min(5, best.who.mass))
                     Matter.Body.applyForce(best.who, path[1], force)
                     Matter.Body.setVelocity(best.who, { //friction
                         x: best.who.velocity.x * 0.7,
@@ -1239,7 +1239,7 @@ const b = {
                     });
                 } else if (!best.who.isStatic) {
                     //push blocks away
-                    const force = Vector.mult(Vector.normalise(Vector.sub(mech.pos, path[1])), -0.007 * Math.sqrt(Math.sqrt(best.who.mass)))
+                    const force = Vector.mult(Vector.normalise(Vector.sub(m.pos, path[1])), -0.007 * Math.sqrt(Math.sqrt(best.who.mass)))
                     Matter.Body.applyForce(best.who, path[1], force)
                 }
             }
@@ -1256,10 +1256,10 @@ const b = {
             ctx.stroke();
 
             //draw electricity
-            const Dx = Math.cos(mech.angle);
-            const Dy = Math.sin(mech.angle);
-            let x = mech.pos.x + 20 * Dx;
-            let y = mech.pos.y + 20 * Dy;
+            const Dx = Math.cos(m.angle);
+            const Dy = Math.sin(m.angle);
+            let x = m.pos.x + 20 * Dx;
+            let y = m.pos.y + 20 * Dy;
             ctx.beginPath();
             ctx.moveTo(x, y);
             const step = Vector.magnitude(Vector.sub(path[0], path[1])) / 10
@@ -1273,11 +1273,11 @@ const b = {
         }
     },
     laser(where = {
-        x: mech.pos.x + 20 * Math.cos(mech.angle),
-        y: mech.pos.y + 20 * Math.sin(mech.angle)
+        x: m.pos.x + 20 * Math.cos(m.angle),
+        y: m.pos.y + 20 * Math.sin(m.angle)
     }, whereEnd = {
-        x: where.x + 3000 * Math.cos(mech.angle),
-        y: where.y + 3000 * Math.sin(mech.angle)
+        x: where.x + 3000 * Math.cos(m.angle),
+        y: where.y + 3000 * Math.sin(m.angle)
     }, dmg = tech.laserDamage, reflections = tech.laserReflections, isThickBeam = false, push = 1) {
         const reflectivity = 1 - 1 / (reflections * 1.5)
         let damage = b.dmgScale * dmg
@@ -1452,7 +1452,7 @@ const b = {
         const me = bullet.length;
         bullet[me] = Bodies.polygon(position.x, position.y, 3, 25, {
             bulletType: "mine",
-            angle: mech.angle,
+            angle: m.angle,
             friction: 0,
             frictionAir: 0.05,
             restitution: 0.5,
@@ -1482,7 +1482,7 @@ const b = {
                 }
             },
             do() {
-                if (!(simulation.cycle % this.lookFrequency) && mech.energy > this.drain) { //find mob targets
+                if (!(simulation.cycle % this.lookFrequency) && m.energy > this.drain) { //find mob targets
                     for (let i = 0, len = mob.length; i < len; ++i) {
                         if (
                             Vector.magnitudeSquared(Vector.sub(this.position, mob[i].position)) < 2000000 &&
@@ -1501,8 +1501,8 @@ const b = {
             reflections: Math.max(0, tech.laserReflections - 2),
             laserSpin() {
                 //drain energy
-                if (mech.energy > this.drain) {
-                    mech.energy -= this.drain
+                if (m.energy > this.drain) {
+                    m.energy -= this.drain
                     if (this.angularSpeed < 0.02) this.torque += this.inertia * this.torqueMagnitude //spin
 
                     //fire lasers
@@ -1593,7 +1593,7 @@ const b = {
                         }
                     }
                 } else {
-                    if (this.speed < 1 && this.angularSpeed < 0.01 && !mech.isBodiesAsleep) {
+                    if (this.speed < 1 && this.angularSpeed < 0.01 && !m.isBodiesAsleep) {
                         this.stillCount++
                     }
                 }
@@ -1615,7 +1615,7 @@ const b = {
                         this.lookFrequency = 10 + Math.floor(3 * Math.random())
                         this.do = function() { //overwrite the do method for this bullet
                             this.force.y += this.mass * 0.002; //extra gravity
-                            if (!(simulation.cycle % this.lookFrequency) && !mech.isBodiesAsleep) { //find mob targets
+                            if (!(simulation.cycle % this.lookFrequency) && !m.isBodiesAsleep) { //find mob targets
                                 this.endCycle -= 10
                                 b.targetedNail(this.position, 1, 45 + 5 * Math.random(), 1100, false)
                                 if (!(simulation.cycle % (this.lookFrequency * 6))) {
@@ -1714,9 +1714,9 @@ const b = {
             },
             onEnd() {
                 if (tech.isMutualism && this.isMutualismActive && !tech.isEnergyHealth) {
-                    mech.health += 0.005
-                    if (mech.health > mech.maxHealth) mech.health = mech.maxHealth;
-                    mech.displayHealth();
+                    m.health += 0.005
+                    if (m.health > m.maxHealth) m.health = m.maxHealth;
+                    m.displayHealth();
                 }
             },
             do() {
@@ -1742,10 +1742,10 @@ const b = {
                     }
                     if (tech.isSporeFollow && this.lockedOn === null) { //move towards player
                         //checking for null means that the spores don't go after the player until it has looked and not found a target
-                        const dx = this.position.x - mech.pos.x;
-                        const dy = this.position.y - mech.pos.y;
+                        const dx = this.position.x - m.pos.x;
+                        const dy = this.position.y - m.pos.y;
                         if (dx * dx + dy * dy > 10000) {
-                            this.force = Vector.mult(Vector.normalise(Vector.sub(mech.pos, Vector.add(this.playerOffPosition, this.position))), this.mass * this.thrust)
+                            this.force = Vector.mult(Vector.normalise(Vector.sub(m.pos, Vector.add(this.playerOffPosition, this.position))), this.mass * this.thrust)
                         }
                     } else {
                         this.force.y += this.mass * 0.0001; //gravity
@@ -1775,12 +1775,12 @@ const b = {
                 //   this.force = Vector.mult(Vector.normalise(Vector.sub(this.lockedOn.position, this.position)), this.mass * this.thrust)
                 // } else if (tech.isSporeFollow && this.lockedOn !== undefined) { //move towards player
                 //   //checking for undefined means that the spores don't go after the player until it has looked and not found a target
-                //   const dx = this.position.x - mech.pos.x;
-                //   const dy = this.position.y - mech.pos.y;
+                //   const dx = this.position.x - m.pos.x;
+                //   const dy = this.position.y - m.pos.y;
                 //   if (dx * dx + dy * dy > 10000) {
-                //     this.force = Vector.mult(Vector.normalise(Vector.sub(mech.pos, Vector.add(this.playerOffPosition, this.position))), this.mass * this.thrust)
+                //     this.force = Vector.mult(Vector.normalise(Vector.sub(m.pos, Vector.add(this.playerOffPosition, this.position))), this.mass * this.thrust)
                 //   }
-                //   // this.force = Vector.mult(Vector.normalise(Vector.sub(mech.pos, this.position)), this.mass * this.thrust)
+                //   // this.force = Vector.mult(Vector.normalise(Vector.sub(m.pos, this.position)), this.mass * this.thrust)
                 // } else {
                 //   this.force.y += this.mass * 0.0001; //gravity
                 // }
@@ -1794,18 +1794,18 @@ const b = {
         });
         World.add(engine.world, bullet[bIndex]); //add bullet to world
 
-        if (tech.isMutualism && mech.health > 0.02) {
-            mech.health -= 0.005
-            mech.displayHealth();
+        if (tech.isMutualism && m.health > 0.02) {
+            m.health -= 0.005
+            m.displayHealth();
             bullet[bIndex].isMutualismActive = true
         }
     },
     iceIX(speed = 0, spread = 2 * Math.PI) {
         const me = bullet.length;
         const THRUST = 0.004
-        const dir = mech.angle + spread * (Math.random() - 0.5);
+        const dir = m.angle + spread * (Math.random() - 0.5);
         const RADIUS = 18
-        bullet[me] = Bodies.polygon(mech.pos.x + 30 * Math.cos(mech.angle), mech.pos.y + 30 * Math.sin(mech.angle), 3, RADIUS, {
+        bullet[me] = Bodies.polygon(m.pos.x + 30 * Math.cos(m.angle), m.pos.y + 30 * Math.sin(m.angle), 3, RADIUS, {
             angle: dir - Math.PI,
             inertia: Infinity,
             friction: 0,
@@ -1829,8 +1829,8 @@ const b = {
                 if (tech.iceEnergy && !who.shield && !who.isShielded && who.dropPowerUp && who.alive) {
                     setTimeout(function() {
                         if (!who.alive) {
-                            mech.energy += tech.iceEnergy * 0.8
-                            mech.addHealth(tech.iceEnergy * 0.04)
+                            m.energy += tech.iceEnergy * 0.8
+                            m.addHealth(tech.iceEnergy * 0.04)
                         }
                     }, 10);
                 }
@@ -1874,17 +1874,17 @@ const b = {
             y: speed * Math.sin(dir)
         });
         // Matter.Body.setVelocity(bullet[me], {
-        //   x: mech.Vx / 2 + speed * Math.cos(dir),
-        //   y: mech.Vy / 2 + speed * Math.sin(dir)
+        //   x: m.Vx / 2 + speed * Math.cos(dir),
+        //   y: m.Vy / 2 + speed * Math.sin(dir)
         // });
     },
     drone(speed = 1) {
         const me = bullet.length;
         const THRUST = tech.isFastDrones ? 0.0023 : 0.0015
         // const FRICTION = tech.isFastDrones ? 0.008 : 0.0005
-        const dir = mech.angle + 0.4 * (Math.random() - 0.5);
+        const dir = m.angle + 0.4 * (Math.random() - 0.5);
         const RADIUS = (4.5 + 3 * Math.random())
-        bullet[me] = Bodies.polygon(mech.pos.x + 30 * Math.cos(mech.angle) + Math.random(), mech.pos.y + 30 * Math.sin(mech.angle) + Math.random(), 8, RADIUS, {
+        bullet[me] = Bodies.polygon(m.pos.x + 30 * Math.cos(m.angle) + Math.random(), m.pos.y + 30 * Math.sin(m.angle) + Math.random(), 8, RADIUS, {
             angle: dir,
             inertia: Infinity,
             friction: 0.05,
@@ -1953,7 +1953,7 @@ const b = {
                             let closeDist = Infinity;
                             for (let i = 0, len = powerUp.length; i < len; ++i) {
                                 if (
-                                    (powerUp[i].name !== "heal" || mech.health < 0.9 * mech.maxHealth || tech.isDroneGrab) &&
+                                    (powerUp[i].name !== "heal" || m.health < 0.9 * m.maxHealth || tech.isDroneGrab) &&
                                     (powerUp[i].name !== "field" || !tech.isDeterminism)
                                 ) {
                                     //pick up nearby power ups
@@ -2065,7 +2065,7 @@ const b = {
             },
             onEnd() {},
             do() {
-                if (!mech.isBodiesAsleep) { //if time dilation isn't active
+                if (!m.isBodiesAsleep) { //if time dilation isn't active
                     if (this.count < 20) {
                         this.count++
                         //grow
@@ -2205,20 +2205,20 @@ const b = {
     // **************************************************************************************************
     // **************************************************************************************************
     respawnBots() {
-        for (let i = 0; i < tech.laserBotCount; i++) b.laserBot({ x: mech.pos.x + 50 * (Math.random() - 0.5), y: mech.pos.y + 50 * (Math.random() - 0.5) }, false)
-        for (let i = 0; i < tech.nailBotCount; i++) b.nailBot({ x: mech.pos.x + 50 * (Math.random() - 0.5), y: mech.pos.y + 50 * (Math.random() - 0.5) }, false)
-        for (let i = 0; i < tech.foamBotCount; i++) b.foamBot({ x: mech.pos.x + 50 * (Math.random() - 0.5), y: mech.pos.y + 50 * (Math.random() - 0.5) }, false)
-        for (let i = 0; i < tech.boomBotCount; i++) b.boomBot({ x: mech.pos.x + 50 * (Math.random() - 0.5), y: mech.pos.y + 50 * (Math.random() - 0.5) }, false)
-        for (let i = 0; i < tech.orbitBotCount; i++) b.orbitBot({ x: mech.pos.x + 50 * (Math.random() - 0.5), y: mech.pos.y + 50 * (Math.random() - 0.5) }, false)
-        for (let i = 0; i < tech.plasmaBotCount; i++) b.plasmaBot({ x: mech.pos.x + 50 * (Math.random() - 0.5), y: mech.pos.y + 50 * (Math.random() - 0.5) }, false)
-        for (let i = 0; i < tech.missileBotCount; i++) b.missileBot({ x: mech.pos.x + 50 * (Math.random() - 0.5), y: mech.pos.y + 50 * (Math.random() - 0.5) }, false)
-        if (tech.isIntangible && mech.isCloak) {
+        for (let i = 0; i < tech.laserBotCount; i++) b.laserBot({ x: m.pos.x + 50 * (Math.random() - 0.5), y: m.pos.y + 50 * (Math.random() - 0.5) }, false)
+        for (let i = 0; i < tech.nailBotCount; i++) b.nailBot({ x: m.pos.x + 50 * (Math.random() - 0.5), y: m.pos.y + 50 * (Math.random() - 0.5) }, false)
+        for (let i = 0; i < tech.foamBotCount; i++) b.foamBot({ x: m.pos.x + 50 * (Math.random() - 0.5), y: m.pos.y + 50 * (Math.random() - 0.5) }, false)
+        for (let i = 0; i < tech.boomBotCount; i++) b.boomBot({ x: m.pos.x + 50 * (Math.random() - 0.5), y: m.pos.y + 50 * (Math.random() - 0.5) }, false)
+        for (let i = 0; i < tech.orbitBotCount; i++) b.orbitBot({ x: m.pos.x + 50 * (Math.random() - 0.5), y: m.pos.y + 50 * (Math.random() - 0.5) }, false)
+        for (let i = 0; i < tech.plasmaBotCount; i++) b.plasmaBot({ x: m.pos.x + 50 * (Math.random() - 0.5), y: m.pos.y + 50 * (Math.random() - 0.5) }, false)
+        for (let i = 0; i < tech.missileBotCount; i++) b.missileBot({ x: m.pos.x + 50 * (Math.random() - 0.5), y: m.pos.y + 50 * (Math.random() - 0.5) }, false)
+        if (tech.isIntangible && m.isCloak) {
             for (let i = 0; i < bullet.length; i++) {
                 if (bullet[i].botType) bullet[i].collisionFilter.mask = cat.map | cat.bullet | cat.mobBullet | cat.mobShield
             }
         }
     },
-    randomBot(where = mech.pos, isKeep = true, isAll = true) {
+    randomBot(where = m.pos, isKeep = true, isAll = true) {
         if (Math.random() < 0.2 && isAll) {
             b.laserBot(where)
             if (isKeep) tech.laserBotCount++;
@@ -2236,10 +2236,10 @@ const b = {
             if (isKeep) tech.boomBotCount++;
         }
     },
-    nailBot(position = { x: mech.pos.x + 50 * (Math.random() - 0.5), y: mech.pos.y + 50 * (Math.random() - 0.5) }, isConsole = true) {
+    nailBot(position = { x: m.pos.x + 50 * (Math.random() - 0.5), y: m.pos.y + 50 * (Math.random() - 0.5) }, isConsole = true) {
         if (isConsole) simulation.makeTextLog(`<span class='color-var'>b</span>.nailBot()`);
         const me = bullet.length;
-        const dir = mech.angle;
+        const dir = m.angle;
         const RADIUS = (12 + 4 * Math.random())
         bullet[me] = Bodies.polygon(position.x, position.y, 4, RADIUS, {
             isUpgraded: tech.isNailBotUpgrade,
@@ -2264,13 +2264,13 @@ const b = {
             beforeDmg() {},
             onEnd() {},
             do() {
-                const distanceToPlayer = Vector.magnitude(Vector.sub(this.position, mech.pos))
+                const distanceToPlayer = Vector.magnitude(Vector.sub(this.position, m.pos))
                 if (distanceToPlayer > this.range) { //if far away move towards player
-                    this.force = Vector.mult(Vector.normalise(Vector.sub(mech.pos, this.position)), this.mass * this.acceleration)
+                    this.force = Vector.mult(Vector.normalise(Vector.sub(m.pos, this.position)), this.mass * this.acceleration)
                 } else { //close to player
                     Matter.Body.setVelocity(this, Vector.add(Vector.mult(this.velocity, 0.90), Vector.mult(player.velocity, 0.17))); //add player's velocity
 
-                    if (this.lastLookCycle < simulation.cycle && !mech.isCloak) {
+                    if (this.lastLookCycle < simulation.cycle && !m.isCloak) {
                         this.lastLookCycle = simulation.cycle + (this.isUpgraded ? 15 : 80)
                         let target
                         for (let i = 0, len = mob.length; i < len; i++) {
@@ -2292,12 +2292,12 @@ const b = {
         })
         World.add(engine.world, bullet[me]); //add bullet to world
     },
-    missileBot(position = { x: mech.pos.x + 50 * (Math.random() - 0.5), y: mech.pos.y + 50 * (Math.random() - 0.5) }, isConsole = true) {
+    missileBot(position = { x: m.pos.x + 50 * (Math.random() - 0.5), y: m.pos.y + 50 * (Math.random() - 0.5) }, isConsole = true) {
         if (isConsole) simulation.makeTextLog(`<span class='color-var'>b</span>.missileBot()`);
         const me = bullet.length;
         bullet[me] = Bodies.rectangle(position.x, position.y, 28, 11, {
             botType: "foam",
-            angle: mech.angle,
+            angle: m.angle,
             friction: 0,
             frictionStatic: 0,
             frictionAir: 0.04,
@@ -2317,13 +2317,13 @@ const b = {
             beforeDmg() {},
             onEnd() {},
             do() {
-                const distanceToPlayer = Vector.magnitude(Vector.sub(this.position, mech.pos))
+                const distanceToPlayer = Vector.magnitude(Vector.sub(this.position, m.pos))
                 if (distanceToPlayer > this.range) { //if far away move towards player
-                    this.force = Vector.mult(Vector.normalise(Vector.sub(mech.pos, this.position)), this.mass * 0.006)
+                    this.force = Vector.mult(Vector.normalise(Vector.sub(m.pos, this.position)), this.mass * 0.006)
                 } else { //close to player
                     Matter.Body.setVelocity(this, Vector.add(Vector.mult(this.velocity, 0.90), Vector.mult(player.velocity, 0.17))); //add player's velocity
 
-                    if (this.cd < simulation.cycle && !(simulation.cycle % this.lookFrequency) && !mech.isCloak) {
+                    if (this.cd < simulation.cycle && !(simulation.cycle % this.lookFrequency) && !m.isCloak) {
                         for (let i = 0, len = mob.length; i < len; i++) {
                             const dist2 = Vector.magnitudeSquared(Vector.sub(this.position, mob[i].position));
                             if (Matter.Query.ray(map, this.position, mob[i].position).length === 0 && dist2 > 250000) {
@@ -2343,10 +2343,10 @@ const b = {
         })
         World.add(engine.world, bullet[me]); //add bullet to world
     },
-    foamBot(position = { x: mech.pos.x + 50 * (Math.random() - 0.5), y: mech.pos.y + 50 * (Math.random() - 0.5) }, isConsole = true) {
+    foamBot(position = { x: m.pos.x + 50 * (Math.random() - 0.5), y: m.pos.y + 50 * (Math.random() - 0.5) }, isConsole = true) {
         if (isConsole) simulation.makeTextLog(`<span class='color-var'>b</span>.foamBot()`);
         const me = bullet.length;
-        const dir = mech.angle;
+        const dir = m.angle;
         const RADIUS = (10 + 5 * Math.random())
         bullet[me] = Bodies.polygon(position.x, position.y, 6, RADIUS, {
             isUpgraded: tech.isFoamBotUpgrade,
@@ -2372,13 +2372,13 @@ const b = {
             beforeDmg() {},
             onEnd() {},
             do() {
-                const distanceToPlayer = Vector.magnitude(Vector.sub(this.position, mech.pos))
+                const distanceToPlayer = Vector.magnitude(Vector.sub(this.position, m.pos))
                 if (distanceToPlayer > this.range) { //if far away move towards player
-                    this.force = Vector.mult(Vector.normalise(Vector.sub(mech.pos, this.position)), this.mass * this.acceleration)
+                    this.force = Vector.mult(Vector.normalise(Vector.sub(m.pos, this.position)), this.mass * this.acceleration)
                 } else { //close to player
                     Matter.Body.setVelocity(this, Vector.add(Vector.mult(this.velocity, 0.90), Vector.mult(player.velocity, 0.17))); //add player's velocity
 
-                    if (this.cd < simulation.cycle && !(simulation.cycle % this.lookFrequency) && !mech.isCloak) {
+                    if (this.cd < simulation.cycle && !(simulation.cycle % this.lookFrequency) && !m.isCloak) {
                         let target
                         for (let i = 0, len = mob.length; i < len; i++) {
                             const dist2 = Vector.magnitudeSquared(Vector.sub(this.position, mob[i].position));
@@ -2386,7 +2386,7 @@ const b = {
                                 this.cd = simulation.cycle + this.delay;
                                 target = Vector.add(mob[i].position, Vector.mult(mob[i].velocity, Math.sqrt(dist2) / 60))
                                 const radius = 6 + 7 * Math.random()
-                                const SPEED = 29 - radius * 0.5; //(mech.crouch ? 32 : 20) - radius * 0.7;
+                                const SPEED = 29 - radius * 0.5; //(m.crouch ? 32 : 20) - radius * 0.7;
                                 const velocity = Vector.mult(Vector.normalise(Vector.sub(target, this.position)), SPEED)
                                 b.foam(this.position, velocity, radius + 7 * this.isUpgraded)
                                 break;
@@ -2398,10 +2398,10 @@ const b = {
         })
         World.add(engine.world, bullet[me]); //add bullet to world
     },
-    laserBot(position = { x: mech.pos.x + 50 * (Math.random() - 0.5), y: mech.pos.y + 50 * (Math.random() - 0.5) }, isConsole = true) {
+    laserBot(position = { x: m.pos.x + 50 * (Math.random() - 0.5), y: m.pos.y + 50 * (Math.random() - 0.5) }, isConsole = true) {
         if (isConsole) simulation.makeTextLog(`<span class='color-var'>b</span>.laserBot()`);
         const me = bullet.length;
-        const dir = mech.angle;
+        const dir = m.angle;
         const RADIUS = (14 + 6 * Math.random())
         bullet[me] = Bodies.polygon(position.x, position.y, 3, RADIUS, {
             isUpgraded: tech.isLaserBotUpgrade,
@@ -2434,7 +2434,7 @@ const b = {
             },
             onEnd() {},
             do() {
-                const playerPos = Vector.add(Vector.add(this.offPlayer, mech.pos), Vector.mult(player.velocity, 20)) //also include an offset unique to this bot to keep many bots spread out
+                const playerPos = Vector.add(Vector.add(this.offPlayer, m.pos), Vector.mult(player.velocity, 20)) //also include an offset unique to this bot to keep many bots spread out
                 const farAway = Math.max(0, (Vector.magnitude(Vector.sub(this.position, playerPos))) / this.followRange) //linear bounding well 
                 const mag = Math.min(farAway, 4) * this.mass * this.acceleration
                 this.force = Vector.mult(Vector.normalise(Vector.sub(playerPos, this.position)), mag)
@@ -2446,7 +2446,7 @@ const b = {
                 //find targets
                 if (!(simulation.cycle % this.lookFrequency)) {
                     this.lockedOn = null;
-                    if (!mech.isCloak) {
+                    if (!m.isCloak) {
                         let closeDist = this.range;
                         for (let i = 0, len = mob.length; i < len; ++i) {
                             const DIST = Vector.magnitude(Vector.sub(this.vertices[0], mob[i].position));
@@ -2468,25 +2468,25 @@ const b = {
                     }
                 }
                 //hit target with laser
-                if (this.lockedOn && this.lockedOn.alive && mech.energy > this.drainThreshold) {
-                    mech.energy -= tech.laserFieldDrain * tech.isLaserDiode
+                if (this.lockedOn && this.lockedOn.alive && m.energy > this.drainThreshold) {
+                    m.energy -= tech.laserFieldDrain * tech.isLaserDiode
                     b.laser(this.vertices[0], this.lockedOn.position, b.dmgScale * (0.38 * tech.laserDamage + this.isUpgraded * 0.21), tech.laserReflections, false, 0.4) //tech.laserDamage = 0.16
                     // laser(where = {
-                    //     x: mech.pos.x + 20 * Math.cos(mech.angle),
-                    //     y: mech.pos.y + 20 * Math.sin(mech.angle)
+                    //     x: m.pos.x + 20 * Math.cos(m.angle),
+                    //     y: m.pos.y + 20 * Math.sin(m.angle)
                     // }, whereEnd = {
-                    //     x: where.x + 3000 * Math.cos(mech.angle),
-                    //     y: where.y + 3000 * Math.sin(mech.angle)
+                    //     x: where.x + 3000 * Math.cos(m.angle),
+                    //     y: where.y + 3000 * Math.sin(m.angle)
                     // }, dmg = tech.laserDamage, reflections = tech.laserReflections, isThickBeam = false, push = 1) {
                 }
             }
         })
         World.add(engine.world, bullet[me]); //add bullet to world
     },
-    boomBot(position = { x: mech.pos.x + 50 * (Math.random() - 0.5), y: mech.pos.y + 50 * (Math.random() - 0.5) }, isConsole = true) {
+    boomBot(position = { x: m.pos.x + 50 * (Math.random() - 0.5), y: m.pos.y + 50 * (Math.random() - 0.5) }, isConsole = true) {
         if (isConsole) simulation.makeTextLog(`<span class='color-var'>b</span>.boomBot()`);
         const me = bullet.length;
-        const dir = mech.angle;
+        const dir = m.angle;
         const RADIUS = (7 + 2 * Math.random())
         bullet[me] = Bodies.polygon(position.x, position.y, 4, RADIUS, {
             isUpgraded: tech.isBoomBotUpgrade,
@@ -2511,12 +2511,12 @@ const b = {
             explode: 0,
             beforeDmg() {
                 if (this.lockedOn) {
-                    const explosionRadius = Math.min(170 + 200 * this.isUpgraded, Vector.magnitude(Vector.sub(this.position, mech.pos)) - 30)
+                    const explosionRadius = Math.min(170 + 200 * this.isUpgraded, Vector.magnitude(Vector.sub(this.position, m.pos)) - 30)
                     if (explosionRadius > 60) {
                         this.explode = explosionRadius
                         // 
                         //push away from player, because normal explosion knock doesn't do much
-                        // const sub = Vector.sub(this.lockedOn.position, mech.pos)
+                        // const sub = Vector.sub(this.lockedOn.position, m.pos)
                         // mag = Math.min(35, 20 / Math.sqrt(this.lockedOn.mass))
                         // Matter.Body.setVelocity(this.lockedOn, Vector.mult(Vector.normalise(sub), mag))
                     }
@@ -2529,13 +2529,13 @@ const b = {
                     b.explosion(this.position, this.explode); //makes bullet do explosive damage at end
                     this.explode = 0;
                 }
-                const distanceToPlayer = Vector.magnitude(Vector.sub(this.position, mech.pos))
+                const distanceToPlayer = Vector.magnitude(Vector.sub(this.position, m.pos))
                 if (distanceToPlayer > 100) { //if far away move towards player
-                    this.force = Vector.mult(Vector.normalise(Vector.sub(mech.pos, this.position)), this.mass * this.acceleration)
+                    this.force = Vector.mult(Vector.normalise(Vector.sub(m.pos, this.position)), this.mass * this.acceleration)
                 } else if (distanceToPlayer < 250) { //close to player
                     Matter.Body.setVelocity(this, Vector.add(Vector.mult(this.velocity, 0.90), Vector.mult(player.velocity, 0.17))); //add player's velocity
                     //find targets
-                    if (!(simulation.cycle % this.lookFrequency) && !mech.isCloak) {
+                    if (!(simulation.cycle % this.lookFrequency) && !m.isCloak) {
                         this.lockedOn = null;
                         let closeDist = this.range;
                         for (let i = 0, len = mob.length; i < len; ++i) {
@@ -2550,7 +2550,7 @@ const b = {
                     }
                 }
                 //punch target
-                if (this.lockedOn && this.lockedOn.alive && !mech.isCloak) {
+                if (this.lockedOn && this.lockedOn.alive && !m.isCloak) {
                     const DIST = Vector.magnitude(Vector.sub(this.vertices[0], this.lockedOn.position));
                     if (DIST - this.lockedOn.radius < this.range &&
                         Matter.Query.ray(map, this.position, this.lockedOn.position).length === 0) {
@@ -2562,10 +2562,10 @@ const b = {
         })
         World.add(engine.world, bullet[me]); //add bullet to world
     },
-    plasmaBot(position = { x: mech.pos.x + 50 * (Math.random() - 0.5), y: mech.pos.y + 50 * (Math.random() - 0.5) }, isConsole = true) {
+    plasmaBot(position = { x: m.pos.x + 50 * (Math.random() - 0.5), y: m.pos.y + 50 * (Math.random() - 0.5) }, isConsole = true) {
         if (isConsole) simulation.makeTextLog(`<span class='color-var'>b</span>.plasmaBot()`);
         const me = bullet.length;
-        const dir = mech.angle;
+        const dir = m.angle;
         const RADIUS = 21
         bullet[me] = Bodies.polygon(position.x, position.y, 5, RADIUS, {
             botType: "plasma",
@@ -2592,15 +2592,15 @@ const b = {
             },
             onEnd() {},
             do() {
-                const distanceToPlayer = Vector.magnitude(Vector.sub(this.position, mech.pos))
+                const distanceToPlayer = Vector.magnitude(Vector.sub(this.position, m.pos))
                 if (distanceToPlayer > 150) { //if far away move towards player
-                    this.force = Vector.mult(Vector.normalise(Vector.sub(mech.pos, this.position)), this.mass * this.acceleration)
+                    this.force = Vector.mult(Vector.normalise(Vector.sub(m.pos, this.position)), this.mass * this.acceleration)
                 }
                 Matter.Body.setVelocity(this, Vector.add(Vector.mult(this.velocity, 0.90), Vector.mult(player.velocity, 0.17))); //add player's velocity
                 //find closest
                 if (!(simulation.cycle % this.lookFrequency)) {
                     this.lockedOn = null;
-                    if (!mech.isCloak) {
+                    if (!m.isCloak) {
                         let closeDist = tech.isPlasmaRange * 1000;
                         for (let i = 0, len = mob.length; i < len; ++i) {
                             const DIST = Vector.magnitude(Vector.sub(this.position, mob[i].position)) - mob[i].radius;
@@ -2614,15 +2614,15 @@ const b = {
                     }
                 }
                 //fire plasma at target
-                if (this.lockedOn && this.lockedOn.alive && mech.fieldCDcycle < mech.cycle) {
+                if (this.lockedOn && this.lockedOn.alive && m.fieldCDcycle < m.cycle) {
                     const sub = Vector.sub(this.lockedOn.position, this.position)
                     const DIST = Vector.magnitude(sub);
                     const unit = Vector.normalise(sub)
-                    if (DIST < tech.isPlasmaRange * 450 && mech.energy > this.drainThreshold) {
-                        mech.energy -= 0.005;
-                        // if (mech.energy < 0) {
-                        //     mech.fieldCDcycle = mech.cycle + 120;
-                        //     mech.energy = 0;
+                    if (DIST < tech.isPlasmaRange * 450 && m.energy > this.drainThreshold) {
+                        m.energy -= 0.005;
+                        // if (m.energy < 0) {
+                        //     m.fieldCDcycle = m.cycle + 120;
+                        //     m.energy = 0;
                         // }
                         //calculate laser collision
                         let best;
@@ -2698,7 +2698,7 @@ const b = {
                                 best.who.damage(dmg);
                                 best.who.locatePlayer();
                                 //push mobs away
-                                const force = Vector.mult(Vector.normalise(Vector.sub(mech.pos, path[1])), -0.01 * Math.min(5, best.who.mass))
+                                const force = Vector.mult(Vector.normalise(Vector.sub(m.pos, path[1])), -0.01 * Math.min(5, best.who.mass))
                                 Matter.Body.applyForce(best.who, path[1], force)
                                 Matter.Body.setVelocity(best.who, { //friction
                                     x: best.who.velocity.x * 0.7,
@@ -2714,7 +2714,7 @@ const b = {
                                 });
                             } else if (!best.who.isStatic) {
                                 //push blocks away
-                                const force = Vector.mult(Vector.normalise(Vector.sub(mech.pos, path[1])), -0.007 * Math.sqrt(Math.sqrt(best.who.mass)))
+                                const force = Vector.mult(Vector.normalise(Vector.sub(m.pos, path[1])), -0.007 * Math.sqrt(Math.sqrt(best.who.mass)))
                                 Matter.Body.applyForce(best.who, path[1], force)
                             }
                         }
@@ -2747,7 +2747,7 @@ const b = {
         })
         World.add(engine.world, bullet[me]); //add bullet to world
     },
-    orbitBot(position = mech.pos, isConsole = true) {
+    orbitBot(position = m.pos, isConsole = true) {
         if (isConsole) simulation.makeTextLog(`<span class='color-var'>b</span>.orbitBot()`);
         const me = bullet.length;
         bullet[me] = Bodies.polygon(position.x, position.y, 9, 12, {
@@ -2787,7 +2787,7 @@ const b = {
             phase: 2 * Math.PI * Math.random(),
             do() {
                 //check for damage
-                if (!mech.isCloak && !mech.isBodiesAsleep) { //if time dilation isn't active
+                if (!m.isCloak && !m.isBodiesAsleep) { //if time dilation isn't active
                     // q = Matter.Query.point(mob, this.position)
                     // q = Matter.Query.collides(this, mob)
                     const size = 33
@@ -2821,7 +2821,7 @@ const b = {
                     x: Math.cos(time),
                     y: Math.sin(time) //*1.1
                 }
-                Matter.Body.setPosition(this, Vector.add(mech.pos, Vector.mult(orbit, this.range))) //bullets move with player
+                Matter.Body.setPosition(this, Vector.add(m.pos, Vector.mult(orbit, this.range))) //bullets move with player
             }
         })
         // bullet[me].orbitalSpeed = Math.sqrt(0.7 / bullet[me].range)
@@ -2874,19 +2874,19 @@ const b = {
 
             },
             fireNormal() {
-                if (this.nextFireCycle + 1 < mech.cycle) this.startingHoldCycle = mech.cycle //reset if not constantly firing
-                const CD = Math.max(11 - 0.06 * (mech.cycle - this.startingHoldCycle), 2) //CD scales with cycles fire is held down
-                this.nextFireCycle = mech.cycle + CD * b.fireCD //predict next fire cycle if the fire button is held down
+                if (this.nextFireCycle + 1 < m.cycle) this.startingHoldCycle = m.cycle //reset if not constantly firing
+                const CD = Math.max(11 - 0.06 * (m.cycle - this.startingHoldCycle), 2) //CD scales with cycles fire is held down
+                this.nextFireCycle = m.cycle + CD * b.fireCD //predict next fire cycle if the fire button is held down
 
-                mech.fireCDcycle = mech.cycle + Math.floor(CD * b.fireCD); // cool down
-                this.baseFire(mech.angle + (Math.random() - 0.5) * (Math.random() - 0.5) * (mech.crouch ? 1.35 : 3.2) / CD)
+                m.fireCDcycle = m.cycle + Math.floor(CD * b.fireCD); // cool down
+                this.baseFire(m.angle + (Math.random() - 0.5) * (Math.random() - 0.5) * (m.crouch ? 1.35 : 3.2) / CD)
             },
             fireNeedles() {
-                mech.fireCDcycle = mech.cycle + Math.floor((mech.crouch ? 40 : 30) * b.fireCD); // cool down
+                m.fireCDcycle = m.cycle + Math.floor((m.crouch ? 40 : 30) * b.fireCD); // cool down
 
-                function makeFlechette(angle = mech.angle) {
+                function makeFlechette(angle = m.angle) {
                     const me = bullet.length;
-                    bullet[me] = Bodies.rectangle(mech.pos.x + 40 * Math.cos(mech.angle), mech.pos.y + 40 * Math.sin(mech.angle), 50, 1, b.fireAttributes(angle));
+                    bullet[me] = Bodies.rectangle(m.pos.x + 40 * Math.cos(m.angle), m.pos.y + 40 * Math.sin(m.angle), 50, 1, b.fireAttributes(angle));
                     bullet[me].collisionFilter.mask = cat.mobShield | cat.body
                     Matter.Body.setDensity(bullet[me], 0.00001); //0.001 is normal
                     bullet[me].endCycle = simulation.cycle + 180;
@@ -2944,30 +2944,30 @@ const b = {
                     };
                     const SPEED = 50
                     Matter.Body.setVelocity(bullet[me], {
-                        x: mech.Vx / 2 + SPEED * Math.cos(angle),
-                        y: mech.Vy / 2 + SPEED * Math.sin(angle)
+                        x: m.Vx / 2 + SPEED * Math.cos(angle),
+                        y: m.Vy / 2 + SPEED * Math.sin(angle)
                     });
                     Matter.Body.setDensity(bullet[me], 0.00001);
                     World.add(engine.world, bullet[me]); //add bullet to world
                 }
-                const spread = (mech.crouch ? 0.01 : 0.045)
-                makeFlechette(mech.angle + spread)
+                const spread = (m.crouch ? 0.01 : 0.045)
+                makeFlechette(m.angle + spread)
                 makeFlechette()
-                makeFlechette(mech.angle - spread)
+                makeFlechette(m.angle - spread)
             },
             fireRivets() {
-                mech.fireCDcycle = mech.cycle + Math.floor((mech.crouch ? 25 : 20) * b.fireCD); // cool down
+                m.fireCDcycle = m.cycle + Math.floor((m.crouch ? 25 : 20) * b.fireCD); // cool down
 
                 const me = bullet.length;
                 const size = tech.rivetSize * 6
-                bullet[me] = Bodies.rectangle(mech.pos.x + 35 * Math.cos(mech.angle), mech.pos.y + 35 * Math.sin(mech.angle), 5 * size, size, b.fireAttributes(mech.angle));
+                bullet[me] = Bodies.rectangle(m.pos.x + 35 * Math.cos(m.angle), m.pos.y + 35 * Math.sin(m.angle), 5 * size, size, b.fireAttributes(m.angle));
                 bullet[me].dmg = tech.isNailRadiation ? 0 : 2.75
                 Matter.Body.setDensity(bullet[me], 0.002);
                 World.add(engine.world, bullet[me]); //add bullet to world
-                const SPEED = mech.crouch ? 55 : 46
+                const SPEED = m.crouch ? 55 : 46
                 Matter.Body.setVelocity(bullet[me], {
-                    x: SPEED * Math.cos(mech.angle),
-                    y: SPEED * Math.sin(mech.angle)
+                    x: SPEED * Math.cos(m.angle),
+                    y: SPEED * Math.sin(m.angle)
                 });
                 bullet[me].endCycle = simulation.cycle + 180
                 bullet[me].beforeDmg = function(who) { //beforeDmg is rewritten with ice crystal tech
@@ -2999,26 +2999,26 @@ const b = {
                 b.muzzleFlash(30);
             },
             fireNailFireRate() {
-                if (this.nextFireCycle + 1 < mech.cycle) this.startingHoldCycle = mech.cycle //reset if not constantly firing
-                const CD = Math.max(7.5 - 0.06 * (mech.cycle - this.startingHoldCycle), 2) //CD scales with cycles fire is held down
-                this.nextFireCycle = mech.cycle + CD * b.fireCD //predict next fire cycle if the fire button is held down
+                if (this.nextFireCycle + 1 < m.cycle) this.startingHoldCycle = m.cycle //reset if not constantly firing
+                const CD = Math.max(7.5 - 0.06 * (m.cycle - this.startingHoldCycle), 2) //CD scales with cycles fire is held down
+                this.nextFireCycle = m.cycle + CD * b.fireCD //predict next fire cycle if the fire button is held down
 
-                mech.fireCDcycle = mech.cycle + Math.floor(CD * b.fireCD); // cool down
-                this.baseFire(mech.angle + (Math.random() - 0.5) * (Math.random() - 0.5) * (mech.crouch ? 1.35 : 3.2) / CD)
+                m.fireCDcycle = m.cycle + Math.floor(CD * b.fireCD); // cool down
+                this.baseFire(m.angle + (Math.random() - 0.5) * (Math.random() - 0.5) * (m.crouch ? 1.35 : 3.2) / CD)
             },
             fireInstantFireRate() {
-                mech.fireCDcycle = mech.cycle + Math.floor(2 * b.fireCD); // cool down
-                this.baseFire(mech.angle + (Math.random() - 0.5) * (Math.random() - 0.5) * (mech.crouch ? 1.35 : 3.2) / 2)
+                m.fireCDcycle = m.cycle + Math.floor(2 * b.fireCD); // cool down
+                this.baseFire(m.angle + (Math.random() - 0.5) * (Math.random() - 0.5) * (m.crouch ? 1.35 : 3.2) / 2)
             },
             baseFire(angle) {
                 const speed = 30 + 6 * Math.random() + 9 * tech.nailInstantFireRate
                 const dmg = 0.9
                 b.nail({
-                    x: mech.pos.x + 30 * Math.cos(mech.angle),
-                    y: mech.pos.y + 30 * Math.sin(mech.angle)
+                    x: m.pos.x + 30 * Math.cos(m.angle),
+                    y: m.pos.y + 30 * Math.sin(m.angle)
                 }, {
-                    x: mech.Vx / 2 + speed * Math.cos(angle),
-                    y: mech.Vy / 2 + speed * Math.sin(angle)
+                    x: m.Vx / 2 + speed * Math.cos(angle),
+                    y: m.Vy / 2 + speed * Math.sin(angle)
                 }, dmg) //position, velocity, damage
                 if (tech.isIceCrystals) {
                     bullet[bullet.length - 1].beforeDmg = function(who) {
@@ -3027,10 +3027,10 @@ const b = {
                             b.explosion(this.position, 150 + 30 * Math.random()); //makes bullet do explosive damage at end
                         }
                     };
-                    if (mech.energy < 0.01) {
-                        mech.fireCDcycle = mech.cycle + 60; // cool down
+                    if (m.energy < 0.01) {
+                        m.fireCDcycle = m.cycle + 60; // cool down
                     } else {
-                        mech.energy -= mech.fieldRegen + 0.01
+                        m.energy -= m.fieldRegen + 0.01
                     }
                 }
             },
@@ -3044,36 +3044,36 @@ const b = {
             have: false,
             fire() {
                 let knock, spread
-                if (mech.crouch) {
+                if (m.crouch) {
                     spread = 0.75
-                    mech.fireCDcycle = mech.cycle + Math.floor(55 * b.fireCD); // cool down
-                    if (tech.isShotgunImmune) mech.immuneCycle = mech.cycle + Math.floor(58 * b.fireCD); //player is immune to collision damage for 30 cycles
+                    m.fireCDcycle = m.cycle + Math.floor(55 * b.fireCD); // cool down
+                    if (tech.isShotgunImmune) m.immuneCycle = m.cycle + Math.floor(58 * b.fireCD); //player is immune to collision damage for 30 cycles
                     knock = 0.01
                 } else {
-                    mech.fireCDcycle = mech.cycle + Math.floor(45 * b.fireCD); // cool down
-                    if (tech.isShotgunImmune) mech.immuneCycle = mech.cycle + Math.floor(47 * b.fireCD); //player is immune to collision damage for 30 cycles
+                    m.fireCDcycle = m.cycle + Math.floor(45 * b.fireCD); // cool down
+                    if (tech.isShotgunImmune) m.immuneCycle = m.cycle + Math.floor(47 * b.fireCD); //player is immune to collision damage for 30 cycles
                     spread = 1.3
                     knock = 0.1
                 }
 
                 if (tech.isShotgunRecoil) {
-                    mech.fireCDcycle -= 0.66 * (45 * b.fireCD)
-                    player.force.x -= 2 * knock * Math.cos(mech.angle)
-                    player.force.y -= 2 * knock * Math.sin(mech.angle) //reduce knock back in vertical direction to stop super jumps
+                    m.fireCDcycle -= 0.66 * (45 * b.fireCD)
+                    player.force.x -= 2 * knock * Math.cos(m.angle)
+                    player.force.y -= 2 * knock * Math.sin(m.angle) //reduce knock back in vertical direction to stop super jumps
                 } else {
-                    player.force.x -= knock * Math.cos(mech.angle)
-                    player.force.y -= knock * Math.sin(mech.angle) * 0.3 //reduce knock back in vertical direction to stop super jumps
+                    player.force.x -= knock * Math.cos(m.angle)
+                    player.force.y -= knock * Math.sin(m.angle) * 0.3 //reduce knock back in vertical direction to stop super jumps
                 }
 
                 b.muzzleFlash(35);
 
                 if (tech.isSlugShot) {
                     const me = bullet.length;
-                    const dir = mech.angle + 0.02 * (Math.random() - 0.5)
-                    bullet[me] = Bodies.rectangle(mech.pos.x + 35 * Math.cos(mech.angle), mech.pos.y + 35 * Math.sin(mech.angle), 45, 20, b.fireAttributes(dir));
+                    const dir = m.angle + 0.02 * (Math.random() - 0.5)
+                    bullet[me] = Bodies.rectangle(m.pos.x + 35 * Math.cos(m.angle), m.pos.y + 35 * Math.sin(m.angle), 45, 20, b.fireAttributes(dir));
                     Matter.Body.setDensity(bullet[me], 0.004);
                     World.add(engine.world, bullet[me]); //add bullet to world
-                    const SPEED = (mech.crouch ? 52 : 43) + Math.random() * 7
+                    const SPEED = (m.crouch ? 52 : 43) + Math.random() * 7
                     Matter.Body.setVelocity(bullet[me], {
                         x: SPEED * Math.cos(dir),
                         y: SPEED * Math.sin(dir)
@@ -3118,15 +3118,15 @@ const b = {
                         }
                     }
                 } else if (tech.isIncendiary) {
-                    const SPEED = mech.crouch ? 35 : 25
-                    const END = Math.floor(mech.crouch ? 9 : 6);
+                    const SPEED = m.crouch ? 35 : 25
+                    const END = Math.floor(m.crouch ? 9 : 6);
                     const totalBullets = 8
-                    const angleStep = (mech.crouch ? 0.15 : 0.4) / totalBullets
-                    let dir = mech.angle - angleStep * totalBullets / 2;
+                    const angleStep = (m.crouch ? 0.15 : 0.4) / totalBullets
+                    let dir = m.angle - angleStep * totalBullets / 2;
                     for (let i = 0; i < totalBullets; i++) { //5 -> 7
                         dir += angleStep
                         const me = bullet.length;
-                        bullet[me] = Bodies.rectangle(mech.pos.x + 50 * Math.cos(mech.angle), mech.pos.y + 50 * Math.sin(mech.angle), 17, 4, b.fireAttributes(dir));
+                        bullet[me] = Bodies.rectangle(m.pos.x + 50 * Math.cos(m.angle), m.pos.y + 50 * Math.sin(m.angle), 17, 4, b.fireAttributes(dir));
                         const end = END + Math.random() * 3
                         bullet[me].endCycle = 2 * end + simulation.cycle
                         const speed = SPEED * end / END
@@ -3145,12 +3145,12 @@ const b = {
                         World.add(engine.world, bullet[me]); //add bullet to world
                     }
                 } else if (tech.isNailShot) {
-                    if (mech.crouch) {
+                    if (m.crouch) {
                         for (let i = 0; i < 11; i++) {
-                            const dir = mech.angle + (Math.random() - 0.5) * 0.015
+                            const dir = m.angle + (Math.random() - 0.5) * 0.015
                             const pos = {
-                                x: mech.pos.x + 35 * Math.cos(mech.angle) + 15 * (Math.random() - 0.5),
-                                y: mech.pos.y + 35 * Math.sin(mech.angle) + 15 * (Math.random() - 0.5)
+                                x: m.pos.x + 35 * Math.cos(m.angle) + 15 * (Math.random() - 0.5),
+                                y: m.pos.y + 35 * Math.sin(m.angle) + 15 * (Math.random() - 0.5)
                             }
                             speed = 39 + 7 * Math.random()
                             const velocity = {
@@ -3161,10 +3161,10 @@ const b = {
                         }
                     } else {
                         for (let i = 0; i < 15; i++) {
-                            const dir = mech.angle + (Math.random() - 0.5) * 0.42
+                            const dir = m.angle + (Math.random() - 0.5) * 0.42
                             const pos = {
-                                x: mech.pos.x + 35 * Math.cos(mech.angle) + 15 * (Math.random() - 0.5),
-                                y: mech.pos.y + 35 * Math.sin(mech.angle) + 15 * (Math.random() - 0.5)
+                                x: m.pos.x + 35 * Math.cos(m.angle) + 15 * (Math.random() - 0.5),
+                                y: m.pos.y + 35 * Math.sin(m.angle) + 15 * (Math.random() - 0.5)
                             }
                             speed = 34 + 6 * Math.random()
                             const velocity = {
@@ -3178,8 +3178,8 @@ const b = {
                     const side = 22
                     for (let i = 0; i < 17; i++) {
                         const me = bullet.length;
-                        const dir = mech.angle + (Math.random() - 0.5) * spread
-                        bullet[me] = Bodies.rectangle(mech.pos.x + 35 * Math.cos(mech.angle) + 15 * (Math.random() - 0.5), mech.pos.y + 35 * Math.sin(mech.angle) + 15 * (Math.random() - 0.5), side, side, b.fireAttributes(dir));
+                        const dir = m.angle + (Math.random() - 0.5) * spread
+                        bullet[me] = Bodies.rectangle(m.pos.x + 35 * Math.cos(m.angle) + 15 * (Math.random() - 0.5), m.pos.y + 35 * Math.sin(m.angle) + 15 * (Math.random() - 0.5), side, side, b.fireAttributes(dir));
                         World.add(engine.world, bullet[me]); //add bullet to world
                         const SPEED = 52 + Math.random() * 8
                         Matter.Body.setVelocity(bullet[me], {
@@ -3191,7 +3191,7 @@ const b = {
                         // bullet[me].restitution = 0.4
                         bullet[me].frictionAir = 0.034;
                         bullet[me].do = function() {
-                            if (!mech.isBodiesAsleep) {
+                            if (!m.isBodiesAsleep) {
                                 const scale = 1 - 0.034 / tech.isBulletsLastLonger
                                 Matter.Body.scale(this, scale, scale);
                             }
@@ -3208,12 +3208,12 @@ const b = {
             have: false,
             num: 5,
             fire() {
-                const SPEED = mech.crouch ? 43 : 32
-                mech.fireCDcycle = mech.cycle + Math.floor((mech.crouch ? 25 : 18) * b.fireCD); // cool down
+                const SPEED = m.crouch ? 43 : 32
+                m.fireCDcycle = m.cycle + Math.floor((m.crouch ? 25 : 18) * b.fireCD); // cool down
                 if (tech.oneSuperBall) {
-                    let dir = mech.angle
+                    let dir = m.angle
                     const me = bullet.length;
-                    bullet[me] = Bodies.polygon(mech.pos.x + 30 * Math.cos(mech.angle), mech.pos.y + 30 * Math.sin(mech.angle), 12, 20 * tech.bulletSize, b.fireAttributes(dir, false));
+                    bullet[me] = Bodies.polygon(m.pos.x + 30 * Math.cos(m.angle), m.pos.y + 30 * Math.sin(m.angle), 12, 20 * tech.bulletSize, b.fireAttributes(dir, false));
                     World.add(engine.world, bullet[me]); //add bullet to world
                     Matter.Body.setVelocity(bullet[me], {
                         x: SPEED * Math.cos(dir),
@@ -3236,11 +3236,11 @@ const b = {
                     };
                 } else {
                     b.muzzleFlash(20);
-                    const SPREAD = mech.crouch ? 0.08 : 0.15
-                    let dir = mech.angle - SPREAD * (tech.superBallNumber - 1) / 2;
+                    const SPREAD = m.crouch ? 0.08 : 0.15
+                    let dir = m.angle - SPREAD * (tech.superBallNumber - 1) / 2;
                     for (let i = 0; i < tech.superBallNumber; i++) {
                         const me = bullet.length;
-                        bullet[me] = Bodies.polygon(mech.pos.x + 30 * Math.cos(mech.angle), mech.pos.y + 30 * Math.sin(mech.angle), 12, 7.5 * tech.bulletSize, b.fireAttributes(dir, false));
+                        bullet[me] = Bodies.polygon(m.pos.x + 30 * Math.cos(m.angle), m.pos.y + 30 * Math.sin(m.angle), 12, 7.5 * tech.bulletSize, b.fireAttributes(dir, false));
                         World.add(engine.world, bullet[me]); //add bullet to world
                         Matter.Body.setVelocity(bullet[me], {
                             x: SPEED * Math.cos(dir),
@@ -3272,20 +3272,20 @@ const b = {
             ammoPack: 70,
             have: false,
             fire() {
-                mech.fireCDcycle = mech.cycle + Math.floor(3 * b.fireCD); // cool down
-                const dir = mech.angle
+                m.fireCDcycle = m.cycle + Math.floor(3 * b.fireCD); // cool down
+                const dir = m.angle
                 const SPEED = 10
                 let wiggleMag
                 if (tech.waveHelix === 2) {
-                    wiggleMag = (mech.crouch ? 6 : 12) * (1 + Math.sin(mech.cycle * 0.1))
+                    wiggleMag = (m.crouch ? 6 : 12) * (1 + Math.sin(m.cycle * 0.1))
                 } else {
-                    wiggleMag = mech.crouch ? 6 : 12
+                    wiggleMag = m.crouch ? 6 : 12
                 }
-                // const wiggleMag = tech.waveHelix ? (mech.crouch ? 6 + 6 * Math.sin(mech.cycle * 0.1) : 13 + 13 * Math.sin(mech.cycle * 0.1)) : (mech.crouch ? 6 : 12)
+                // const wiggleMag = tech.waveHelix ? (m.crouch ? 6 + 6 * Math.sin(m.cycle * 0.1) : 13 + 13 * Math.sin(m.cycle * 0.1)) : (m.crouch ? 6 : 12)
                 const size = 5 * (tech.waveHelix === 1 ? 1 : 0.7)
                 for (let i = 0; i < tech.waveHelix; i++) {
                     const me = bullet.length;
-                    bullet[me] = Bodies.polygon(mech.pos.x + 25 * Math.cos(dir), mech.pos.y + 25 * Math.sin(dir), 7, size, {
+                    bullet[me] = Bodies.polygon(m.pos.x + 25 * Math.cos(dir), m.pos.y + 25 * Math.sin(dir), 7, size, {
                         angle: dir,
                         cycle: -0.5,
                         endCycle: simulation.cycle + Math.floor((tech.isWaveReflect ? 600 : 120) * tech.isBulletsLastLonger),
@@ -3303,7 +3303,7 @@ const b = {
                         beforeDmg() {},
                         onEnd() {},
                         do() {
-                            if (!mech.isBodiesAsleep) {
+                            if (!m.isBodiesAsleep) {
                                 if (tech.isWaveReflect) {
                                     // check if inside a mob
                                     q = Matter.Query.point(mob, this.position)
@@ -3320,12 +3320,12 @@ const b = {
                                         });
                                     }
                                     Matter.Body.setPosition(this, Vector.add(this.position, player.velocity)) //bullets move with player
-                                    const sub = Vector.sub(this.position, mech.pos)
+                                    const sub = Vector.sub(this.position, m.pos)
                                     const range = 558 //93 * x
                                     if (Vector.magnitude(sub) > range) {
                                         // Matter.Body.setPosition(this, Vector.sub(this.position, Vector.mult(Vector.normalise(sub), 2 * range))) //teleport to opposite side
                                         Matter.Body.setVelocity(this, Vector.mult(this.velocity, -1));
-                                        Matter.Body.setPosition(this, Vector.add(mech.pos, Vector.mult(Vector.normalise(sub), range))) //reflect
+                                        Matter.Body.setPosition(this, Vector.add(m.pos, Vector.mult(Vector.normalise(sub), range))) //reflect
                                     }
                                 } else {
                                     let slowCheck = 1
@@ -3386,33 +3386,33 @@ const b = {
             ammoLoaded: 0,
             fire() {
                 const countReduction = Math.pow(0.9, tech.missileCount)
-                if (mech.crouch) {
-                    mech.fireCDcycle = mech.cycle + 10 * b.fireCD / countReduction; // cool down
+                if (m.crouch) {
+                    m.fireCDcycle = m.cycle + 10 * b.fireCD / countReduction; // cool down
 
                     const size = countReduction * (tech.missileSize ? 1.32 : 0.88)
                     const where = {
-                        x: mech.pos.x,
-                        y: mech.pos.y - 40
+                        x: m.pos.x,
+                        y: m.pos.y - 40
                     }
                     for (let i = 0; i < tech.missileCount; i++) {
                         b.missile(where, -Math.PI / 2 + 0.2 * (Math.random() - 0.5) * Math.sqrt(tech.missileCount), -2, size)
                         bullet[bullet.length - 1].force.x += 0.004 * size * (i - (tech.missileCount - 1) / 2);
                     }
                 } else {
-                    mech.fireCDcycle = mech.cycle + 50 * b.fireCD / countReduction; // cool down
+                    m.fireCDcycle = m.cycle + 50 * b.fireCD / countReduction; // cool down
 
                     const size = countReduction * (tech.missileSize ? 1.5 : 1)
                     const direction = {
-                        x: Math.cos(mech.angle),
-                        y: Math.sin(mech.angle)
+                        x: Math.cos(m.angle),
+                        y: Math.sin(m.angle)
                     }
                     const push = Vector.mult(Vector.perp(direction), 0.02 * size / Math.sqrt(tech.missileCount))
                     const where = {
-                        x: mech.pos.x + 40 * direction.x,
-                        y: mech.pos.y + 40 * direction.y
+                        x: m.pos.x + 40 * direction.x,
+                        y: m.pos.y + 40 * direction.y
                     }
                     for (let i = 0; i < tech.missileCount; i++) {
-                        b.missile(where, mech.angle, 0, size)
+                        b.missile(where, m.angle, 0, size)
                         bullet[bullet.length - 1].force.x += push.x * (i - (tech.missileCount - 1) / 2);
                         bullet[bullet.length - 1].force.y += push.y * (i - (tech.missileCount - 1) / 2);
                     }
@@ -3420,43 +3420,43 @@ const b = {
 
 
                 // if (tech.missileCount) {
-                //     if (mech.crouch) {
+                //     if (m.crouch) {
                 //         for (let i = 0; i < 3; i++) {
                 //             b.missile({
-                //                 x: mech.pos.x,
-                //                 y: mech.pos.y - 40
+                //                 x: m.pos.x,
+                //                 y: m.pos.y - 40
                 //             }, -Math.PI / 2 + 0.08 * (1 - i) + 0.3 * (Math.random() - 0.5), 0, 0.6 * (tech.missileSize ? 1.5 : 1))
                 //             bullet[bullet.length - 1].force.x -= 0.015 * (i - 1);
                 //         }
                 //     } else {
-                //         mech.fireCDcycle = mech.cycle + 80 * b.fireCD; // cool down
+                //         m.fireCDcycle = m.cycle + 80 * b.fireCD; // cool down
                 //         const direction = {
-                //             x: Math.cos(mech.angle),
-                //             y: Math.sin(mech.angle)
+                //             x: Math.cos(m.angle),
+                //             y: Math.sin(m.angle)
                 //         }
                 //         const push = Vector.mult(Vector.perp(direction), 0.02)
                 //         for (let i = 0; i < 3; i++) {
                 //             b.missile({
-                //                 x: mech.pos.x + 40 * direction.x,
-                //                 y: mech.pos.y + 40 * direction.y
-                //             }, mech.angle + 0.06 * (Math.random() - 0.5), 5, 0.7 * (tech.missileSize ? 1.5 : 1))
+                //                 x: m.pos.x + 40 * direction.x,
+                //                 y: m.pos.y + 40 * direction.y
+                //             }, m.angle + 0.06 * (Math.random() - 0.5), 5, 0.7 * (tech.missileSize ? 1.5 : 1))
                 //             bullet[bullet.length - 1].force.x += push.x * (i - 1);
                 //             bullet[bullet.length - 1].force.y += push.y * (i - 1);
                 //         }
                 //     }
                 // } else {
-                //     if (mech.crouch) {
-                //         mech.fireCDcycle = mech.cycle + 10 * b.fireCD; // cool down
+                //     if (m.crouch) {
+                //         m.fireCDcycle = m.cycle + 10 * b.fireCD; // cool down
                 //         const off = Math.random() - 0.5
                 //         b.missile({
-                //                 x: mech.pos.x,
-                //                 y: mech.pos.y - 40
+                //                 x: m.pos.x,
+                //                 y: m.pos.y - 40
                 //             },
                 //             -Math.PI / 2 + 0.15 * off, 0, 0.83 * (tech.missileSize ? 1.5 : 1))
                 //         bullet[bullet.length - 1].force.x += off * 0.03;
                 //         // bullet[bullet.length - 1].force.y += push.y * (i - 1);
                 //     } else {
-                //         mech.fireCDcycle = mech.cycle + 55 * b.fireCD; // cool down
+                //         m.fireCDcycle = m.cycle + 55 * b.fireCD; // cool down
 
                 //         // bullet[bullet.length - 1].force.y += 0.01; //a small push down at first to make it seem like the missile is briefly falling
                 //     }
@@ -3471,7 +3471,7 @@ const b = {
             ammoPack: 5,
             have: false,
             fire() {
-                mech.fireCDcycle = mech.cycle + Math.floor((mech.crouch ? 40 : 30) * b.fireCD); // cool down
+                m.fireCDcycle = m.cycle + Math.floor((m.crouch ? 40 : 30) * b.fireCD); // cool down
                 b.grenade()
             },
         },
@@ -3483,24 +3483,24 @@ const b = {
             have: false,
             fire() {
                 if (tech.isLaserMine) { //laser mine
-                    const speed = mech.crouch ? 50 : 20
-                    const velocity = { x: speed * Math.cos(mech.angle), y: speed * Math.sin(mech.angle) }
-                    b.laserMine(mech.pos, velocity)
+                    const speed = m.crouch ? 50 : 20
+                    const velocity = { x: speed * Math.cos(m.angle), y: speed * Math.sin(m.angle) }
+                    b.laserMine(m.pos, velocity)
                 } else { //normal mines
                     const pos = {
-                        x: mech.pos.x + 30 * Math.cos(mech.angle),
-                        y: mech.pos.y + 30 * Math.sin(mech.angle)
+                        x: m.pos.x + 30 * Math.cos(m.angle),
+                        y: m.pos.y + 30 * Math.sin(m.angle)
                     }
-                    let speed = mech.crouch ? 36 : 22
+                    let speed = m.crouch ? 36 : 22
                     if (Matter.Query.point(map, pos).length > 0) { //don't fire if mine will spawn inside map
                         speed = -2
                     }
                     b.mine(pos, {
-                        x: speed * Math.cos(mech.angle),
-                        y: speed * Math.sin(mech.angle)
+                        x: speed * Math.cos(m.angle),
+                        y: speed * Math.sin(m.angle)
                     }, 0, tech.isMineAmmoBack)
                 }
-                mech.fireCDcycle = mech.cycle + Math.floor((mech.crouch ? 50 : 25) * b.fireCD); // cool down
+                m.fireCDcycle = m.cycle + Math.floor((m.crouch ? 50 : 25) * b.fireCD); // cool down
             }
         },
         {
@@ -3511,9 +3511,9 @@ const b = {
             have: false,
             fire() {
                 const me = bullet.length;
-                const dir = mech.angle;
-                bullet[me] = Bodies.polygon(mech.pos.x + 30 * Math.cos(mech.angle), mech.pos.y + 30 * Math.sin(mech.angle), 20, 4.5, b.fireAttributes(dir, false));
-                b.fireProps(mech.crouch ? 50 : 30, mech.crouch ? 30 : 16, dir, me); //cd , speed
+                const dir = m.angle;
+                bullet[me] = Bodies.polygon(m.pos.x + 30 * Math.cos(m.angle), m.pos.y + 30 * Math.sin(m.angle), 20, 4.5, b.fireAttributes(dir, false));
+                b.fireProps(m.crouch ? 50 : 30, m.crouch ? 30 : 16, dir, me); //cd , speed
                 Matter.Body.setDensity(bullet[me], 0.000001);
                 bullet[me].endCycle = Infinity;
                 bullet[me].frictionAir = 0;
@@ -3598,7 +3598,7 @@ const b = {
 
                 bullet[me].grow = function() {
                     this.stuck(); //runs different code based on what the bullet is stuck to
-                    if (!mech.isBodiesAsleep) {
+                    if (!m.isBodiesAsleep) {
                         let scale = 1.01
                         if (tech.isSporeGrowth && !(simulation.cycle % 60)) { //release a spore
                             b.spore(this.position)
@@ -3640,12 +3640,12 @@ const b = {
             ammoPack: 14,
             have: false,
             fire() {
-                if (mech.crouch) {
+                if (m.crouch) {
                     b.drone(45)
-                    mech.fireCDcycle = mech.cycle + Math.floor(13 * b.fireCD); // cool down
+                    m.fireCDcycle = m.cycle + Math.floor(13 * b.fireCD); // cool down
                 } else {
                     b.drone(1)
-                    mech.fireCDcycle = mech.cycle + Math.floor(6 * b.fireCD); // cool down
+                    m.fireCDcycle = m.cycle + Math.floor(6 * b.fireCD); // cool down
                 }
             }
         },
@@ -3656,12 +3656,12 @@ const b = {
         //     ammoPack: 64,
         //     have: false,
         //     fire() {
-        //         if (mech.crouch) {
+        //         if (m.crouch) {
         //             b.iceIX(10, 0.3)
-        //             mech.fireCDcycle = mech.cycle + Math.floor(8 * b.fireCD); // cool down
+        //             m.fireCDcycle = m.cycle + Math.floor(8 * b.fireCD); // cool down
         //         } else {
         //             b.iceIX(2)
-        //             mech.fireCDcycle = mech.cycle + Math.floor(3 * b.fireCD); // cool down
+        //             m.fireCDcycle = m.cycle + Math.floor(3 * b.fireCD); // cool down
         //         }
 
         //     }
@@ -3673,17 +3673,17 @@ const b = {
             ammoPack: 35,
             have: false,
             fire() {
-                mech.fireCDcycle = mech.cycle + Math.floor((mech.crouch ? 20 : 6) * b.fireCD); // cool down
-                const radius = (mech.crouch ? 10 + 5 * Math.random() : 4 + 6 * Math.random()) + (tech.isAmmoFoamSize && this.ammo < 300) * 12
+                m.fireCDcycle = m.cycle + Math.floor((m.crouch ? 20 : 6) * b.fireCD); // cool down
+                const radius = (m.crouch ? 10 + 5 * Math.random() : 4 + 6 * Math.random()) + (tech.isAmmoFoamSize && this.ammo < 300) * 12
                 const SPEED = 18 - radius * 0.4;
-                const dir = mech.angle + 0.2 * (Math.random() - 0.5)
+                const dir = m.angle + 0.2 * (Math.random() - 0.5)
                 const velocity = {
                     x: SPEED * Math.cos(dir),
                     y: SPEED * Math.sin(dir)
                 }
                 const position = {
-                    x: mech.pos.x + 30 * Math.cos(mech.angle),
-                    y: mech.pos.y + 30 * Math.sin(mech.angle)
+                    x: m.pos.x + 30 * Math.cos(m.angle),
+                    y: m.pos.y + 30 * Math.sin(m.angle)
                 }
                 b.foam(position, velocity, radius)
             }
@@ -3697,7 +3697,7 @@ const b = {
             fire() {
                 function pushAway(range) { //push away blocks when firing
                     for (let i = 0, len = mob.length; i < len; ++i) {
-                        const SUB = Vector.sub(mob[i].position, mech.pos)
+                        const SUB = Vector.sub(mob[i].position, m.pos)
                         const DISTANCE = Vector.magnitude(SUB)
                         if (DISTANCE < range) {
                             const DEPTH = Math.min(range - DISTANCE, 1500)
@@ -3721,7 +3721,7 @@ const b = {
                         }
                     }
                     for (let i = 0, len = body.length; i < len; ++i) {
-                        const SUB = Vector.sub(body[i].position, mech.pos)
+                        const SUB = Vector.sub(body[i].position, m.pos)
                         const DISTANCE = Vector.magnitude(SUB)
                         if (DISTANCE < range) {
                             const DEPTH = Math.min(range - DISTANCE, 500)
@@ -3733,15 +3733,15 @@ const b = {
                 }
 
                 if (tech.isCapacitor) {
-                    if (mech.energy > 0.16 || tech.isRailEnergyGain) {
-                        mech.energy += 0.16 * (tech.isRailEnergyGain ? 6 : -1)
-                        mech.fireCDcycle = mech.cycle + Math.floor(30 * b.fireCD);
+                    if (m.energy > 0.16 || tech.isRailEnergyGain) {
+                        m.energy += 0.16 * (tech.isRailEnergyGain ? 6 : -1)
+                        m.fireCDcycle = m.cycle + Math.floor(30 * b.fireCD);
                         const me = bullet.length;
-                        bullet[me] = Bodies.rectangle(mech.pos.x + 50 * Math.cos(mech.angle), mech.pos.y + 50 * Math.sin(mech.angle), 60, 14, {
+                        bullet[me] = Bodies.rectangle(m.pos.x + 50 * Math.cos(m.angle), m.pos.y + 50 * Math.sin(m.angle), 60, 14, {
                             density: 0.005, //0.001 is normal
                             restitution: 0,
                             frictionAir: 0,
-                            angle: mech.angle,
+                            angle: m.angle,
                             dmg: 0, //damage done in addition to the damage from momentum
                             classType: "bullet",
                             collisionFilter: {
@@ -3776,9 +3776,9 @@ const b = {
                                 if (this.drawCycle > 0) {
                                     this.drawCycle--
                                     //draw magnetic field
-                                    const X = mech.pos.x
-                                    const Y = mech.pos.y
-                                    const unitVector = Vector.normalise(Vector.sub(simulation.mouseInGame, mech.pos))
+                                    const X = m.pos.x
+                                    const Y = m.pos.y
+                                    const unitVector = Vector.normalise(Vector.sub(simulation.mouseInGame, m.pos))
                                     const unitVectorPerp = Vector.perp(unitVector)
 
                                     function magField(mag, arc) {
@@ -3808,18 +3808,18 @@ const b = {
 
                         const speed = 67
                         Matter.Body.setVelocity(bullet[me], {
-                            x: mech.Vx / 2 + speed * Math.cos(mech.angle),
-                            y: mech.Vy / 2 + speed * Math.sin(mech.angle)
+                            x: m.Vx / 2 + speed * Math.cos(m.angle),
+                            y: m.Vy / 2 + speed * Math.sin(m.angle)
                         });
 
                         //knock back
-                        const KNOCK = mech.crouch ? 0.08 : 0.34
-                        player.force.x -= KNOCK * Math.cos(mech.angle)
-                        player.force.y -= KNOCK * Math.sin(mech.angle) * 0.35 //reduce knock back in vertical direction to stop super jumps
+                        const KNOCK = m.crouch ? 0.08 : 0.34
+                        player.force.x -= KNOCK * Math.cos(m.angle)
+                        player.force.y -= KNOCK * Math.sin(m.angle) * 0.35 //reduce knock back in vertical direction to stop super jumps
 
                         pushAway(800)
                     } else {
-                        mech.fireCDcycle = mech.cycle + Math.floor(120);
+                        m.fireCDcycle = m.cycle + Math.floor(120);
                     }
                 } else {
                     const me = bullet.length;
@@ -3858,20 +3858,20 @@ const b = {
                         },
                         onEnd() {}
                     });
-                    mech.fireCDcycle = Infinity; // cool down
+                    m.fireCDcycle = Infinity; // cool down
                     World.add(engine.world, bullet[me]); //add bullet to world
                     bullet[me].endCycle = Infinity
                     bullet[me].charge = 0;
                     bullet[me].do = function() {
-                        if (mech.energy < 0.005 && !tech.isRailEnergyGain) {
-                            mech.energy += 0.05 + this.charge * 0.3
-                            mech.fireCDcycle = mech.cycle + 120; // cool down if out of energy
+                        if (m.energy < 0.005 && !tech.isRailEnergyGain) {
+                            m.energy += 0.05 + this.charge * 0.3
+                            m.fireCDcycle = m.cycle + 120; // cool down if out of energy
                             this.endCycle = 0;
                             return
                         }
 
                         if ((!input.fire && this.charge > 0.6)) { //fire on mouse release or on low energy
-                            mech.fireCDcycle = mech.cycle + 2; // set fire cool down
+                            m.fireCDcycle = m.cycle + 2; // set fire cool down
                             //normal bullet behavior occurs after firing, overwrites this function
                             this.do = function() {
                                 this.force.y += this.mass * 0.0003 / this.charge; // low gravity that scales with charge
@@ -3881,20 +3881,20 @@ const b = {
                             this.endCycle = simulation.cycle + 140
                             this.collisionFilter.category = cat.bullet
                             Matter.Body.setPosition(this, {
-                                x: mech.pos.x,
-                                y: mech.pos.y
+                                x: m.pos.x,
+                                y: m.pos.y
                             })
-                            Matter.Body.setAngle(this, mech.angle)
+                            Matter.Body.setAngle(this, m.angle)
                             const speed = 90
                             Matter.Body.setVelocity(this, {
-                                x: mech.Vx / 2 + speed * this.charge * Math.cos(mech.angle),
-                                y: mech.Vy / 2 + speed * this.charge * Math.sin(mech.angle)
+                                x: m.Vx / 2 + speed * this.charge * Math.cos(m.angle),
+                                y: m.Vy / 2 + speed * this.charge * Math.sin(m.angle)
                             });
 
                             //knock back
-                            const KNOCK = ((mech.crouch) ? 0.1 : 0.5) * this.charge * this.charge
-                            player.force.x -= KNOCK * Math.cos(mech.angle)
-                            player.force.y -= KNOCK * Math.sin(mech.angle) * 0.35 //reduce knock back in vertical direction to stop super jumps
+                            const KNOCK = ((m.crouch) ? 0.1 : 0.5) * this.charge * this.charge
+                            player.force.x -= KNOCK * Math.cos(m.angle)
+                            player.force.y -= KNOCK * Math.sin(m.angle) * 0.35 //reduce knock back in vertical direction to stop super jumps
                             pushAway(1200 * this.charge)
                         } else { // charging on mouse down
 
@@ -3908,26 +3908,26 @@ const b = {
                             }
 
 
-                            mech.fireCDcycle = Infinity //can't fire until mouse is released
+                            m.fireCDcycle = Infinity //can't fire until mouse is released
                             const previousCharge = this.charge
-                            let smoothRate = 0.98 * (mech.crouch ? 0.99 : 1) * (0.98 + 0.02 * b.fireCD) //small b.fireCD = faster shots, b.fireCD=1 = normal shot,  big b.fireCD = slower chot
+                            let smoothRate = 0.98 * (m.crouch ? 0.99 : 1) * (0.98 + 0.02 * b.fireCD) //small b.fireCD = faster shots, b.fireCD=1 = normal shot,  big b.fireCD = slower chot
                             this.charge = this.charge * smoothRate + 1 * (1 - smoothRate)
                             if (tech.isRailEnergyGain) {
-                                mech.energy += (this.charge - previousCharge) * 2 //energy drain is proportional to charge gained, but doesn't stop normal mech.fieldRegen
+                                m.energy += (this.charge - previousCharge) * 2 //energy drain is proportional to charge gained, but doesn't stop normal m.fieldRegen
                             } else {
-                                mech.energy -= (this.charge - previousCharge) * 0.33 //energy drain is proportional to charge gained, but doesn't stop normal mech.fieldRegen
+                                m.energy -= (this.charge - previousCharge) * 0.33 //energy drain is proportional to charge gained, but doesn't stop normal m.fieldRegen
                             }
                             //draw targeting
                             let best;
                             let range = 3000
-                            const dir = mech.angle
+                            const dir = m.angle
                             const path = [{
-                                    x: mech.pos.x + 20 * Math.cos(dir),
-                                    y: mech.pos.y + 20 * Math.sin(dir)
+                                    x: m.pos.x + 20 * Math.cos(dir),
+                                    y: m.pos.y + 20 * Math.sin(dir)
                                 },
                                 {
-                                    x: mech.pos.x + range * Math.cos(dir),
-                                    y: mech.pos.y + range * Math.sin(dir)
+                                    x: m.pos.x + range * Math.cos(dir),
+                                    y: m.pos.y + range * Math.sin(dir)
                                 }
                             ];
                             const vertexCollision = function(v1, v1End, domain) {
@@ -4001,9 +4001,9 @@ const b = {
                             ctx.setLineDash([0, 0]);
 
                             //draw magnetic field
-                            const X = mech.pos.x
-                            const Y = mech.pos.y
-                            const unitVector = Vector.normalise(Vector.sub(simulation.mouseInGame, mech.pos))
+                            const X = m.pos.x
+                            const Y = m.pos.y
+                            const unitVector = Vector.normalise(Vector.sub(simulation.mouseInGame, m.pos))
                             const unitVectorPerp = Vector.perp(unitVector)
 
                             function magField(mag, arc) {
@@ -4055,75 +4055,75 @@ const b = {
                 }
             },
             fireLaser() {
-                if (mech.energy < tech.laserFieldDrain) {
-                    mech.fireCDcycle = mech.cycle + 100; // cool down if out of energy
+                if (m.energy < tech.laserFieldDrain) {
+                    m.fireCDcycle = m.cycle + 100; // cool down if out of energy
                 } else {
-                    mech.fireCDcycle = mech.cycle
-                    mech.energy -= mech.fieldRegen + tech.laserFieldDrain * tech.isLaserDiode
+                    m.fireCDcycle = m.cycle
+                    m.energy -= m.fieldRegen + tech.laserFieldDrain * tech.isLaserDiode
                     b.laser();
                 }
             },
 
             // laser(where = {
-            //     x: mech.pos.x + 20 * Math.cos(mech.angle),
-            //     y: mech.pos.y + 20 * Math.sin(mech.angle)
+            //     x: m.pos.x + 20 * Math.cos(m.angle),
+            //     y: m.pos.y + 20 * Math.sin(m.angle)
             // }, whereEnd = {
-            //     x: where.x + 3000 * Math.cos(mech.angle),
-            //     y: where.y + 3000 * Math.sin(mech.angle)
+            //     x: where.x + 3000 * Math.cos(m.angle),
+            //     y: where.y + 3000 * Math.sin(m.angle)
             // }, dmg = tech.laserDamage, reflections = tech.laserReflections, isThickBeam = false, push = 1) {
             fireSplit() {
-                if (mech.energy < tech.laserFieldDrain) {
-                    mech.fireCDcycle = mech.cycle + 100; // cool down if out of energy
+                if (m.energy < tech.laserFieldDrain) {
+                    m.fireCDcycle = m.cycle + 100; // cool down if out of energy
                 } else {
-                    mech.fireCDcycle = mech.cycle
-                    mech.energy -= mech.fieldRegen + tech.laserFieldDrain * tech.isLaserDiode
-                    const divergence = mech.crouch ? 0.15 : 0.2
+                    m.fireCDcycle = m.cycle
+                    m.energy -= m.fieldRegen + tech.laserFieldDrain * tech.isLaserDiode
+                    const divergence = m.crouch ? 0.15 : 0.2
                     const scale = Math.pow(0.9, tech.beamSplitter)
                     const pushScale = scale * scale
                     let dmg = tech.laserDamage * scale //Math.pow(0.9, tech.laserDamage)
                     const where = {
-                        x: mech.pos.x + 20 * Math.cos(mech.angle),
-                        y: mech.pos.y + 20 * Math.sin(mech.angle)
+                        x: m.pos.x + 20 * Math.cos(m.angle),
+                        y: m.pos.y + 20 * Math.sin(m.angle)
                     }
                     b.laser(where, {
-                        x: where.x + 3000 * Math.cos(mech.angle),
-                        y: where.y + 3000 * Math.sin(mech.angle)
+                        x: where.x + 3000 * Math.cos(m.angle),
+                        y: where.y + 3000 * Math.sin(m.angle)
                     }, dmg, tech.laserReflections, false, pushScale)
                     for (let i = 1; i < 1 + tech.beamSplitter; i++) {
                         b.laser(where, {
-                            x: where.x + 3000 * Math.cos(mech.angle + i * divergence),
-                            y: where.y + 3000 * Math.sin(mech.angle + i * divergence)
+                            x: where.x + 3000 * Math.cos(m.angle + i * divergence),
+                            y: where.y + 3000 * Math.sin(m.angle + i * divergence)
                         }, dmg, tech.laserReflections, false, pushScale)
                         b.laser(where, {
-                            x: where.x + 3000 * Math.cos(mech.angle - i * divergence),
-                            y: where.y + 3000 * Math.sin(mech.angle - i * divergence)
+                            x: where.x + 3000 * Math.cos(m.angle - i * divergence),
+                            y: where.y + 3000 * Math.sin(m.angle - i * divergence)
                         }, dmg, tech.laserReflections, false, pushScale)
                     }
                 }
             },
             fireWideBeam() {
-                if (mech.energy < tech.laserFieldDrain) {
-                    mech.fireCDcycle = mech.cycle + 100; // cool down if out of energy
+                if (m.energy < tech.laserFieldDrain) {
+                    m.fireCDcycle = m.cycle + 100; // cool down if out of energy
                 } else {
-                    mech.fireCDcycle = mech.cycle
-                    mech.energy -= mech.fieldRegen + tech.laserFieldDrain * tech.isLaserDiode
+                    m.fireCDcycle = m.cycle
+                    m.energy -= m.fieldRegen + tech.laserFieldDrain * tech.isLaserDiode
                     const range = {
-                        x: 5000 * Math.cos(mech.angle),
-                        y: 5000 * Math.sin(mech.angle)
+                        x: 5000 * Math.cos(m.angle),
+                        y: 5000 * Math.sin(m.angle)
                     }
                     const rangeOffPlus = {
-                        x: 7.5 * Math.cos(mech.angle + Math.PI / 2),
-                        y: 7.5 * Math.sin(mech.angle + Math.PI / 2)
+                        x: 7.5 * Math.cos(m.angle + Math.PI / 2),
+                        y: 7.5 * Math.sin(m.angle + Math.PI / 2)
                     }
                     const rangeOffMinus = {
-                        x: 7.5 * Math.cos(mech.angle - Math.PI / 2),
-                        y: 7.5 * Math.sin(mech.angle - Math.PI / 2)
+                        x: 7.5 * Math.cos(m.angle - Math.PI / 2),
+                        y: 7.5 * Math.sin(m.angle - Math.PI / 2)
                     }
                     const dmg = 0.55 * tech.laserDamage //  3.5 * 0.55 = 200% more damage
-                    const where = { x: mech.pos.x + 30 * Math.cos(mech.angle), y: mech.pos.y + 30 * Math.sin(mech.angle) }
+                    const where = { x: m.pos.x + 30 * Math.cos(m.angle), y: m.pos.y + 30 * Math.sin(m.angle) }
                     const eye = {
-                        x: mech.pos.x + 15 * Math.cos(mech.angle),
-                        y: mech.pos.y + 15 * Math.sin(mech.angle)
+                        x: m.pos.x + 15 * Math.cos(m.angle),
+                        y: m.pos.y + 15 * Math.sin(m.angle)
                     }
                     ctx.strokeStyle = "#f00";
                     ctx.lineWidth = 8
@@ -4166,23 +4166,23 @@ const b = {
                 }
             },
             fireHistory() {
-                if (mech.energy < tech.laserFieldDrain) {
-                    mech.fireCDcycle = mech.cycle + 100; // cool down if out of energy
+                if (m.energy < tech.laserFieldDrain) {
+                    m.fireCDcycle = m.cycle + 100; // cool down if out of energy
                 } else {
-                    mech.fireCDcycle = mech.cycle
-                    mech.energy -= mech.fieldRegen + tech.laserFieldDrain * tech.isLaserDiode
+                    m.fireCDcycle = m.cycle
+                    m.energy -= m.fieldRegen + tech.laserFieldDrain * tech.isLaserDiode
                     const dmg = 0.4 * tech.laserDamage //  3.5 * 0.55 = 200% more damage
                     const spacing = Math.ceil(5.2 - 0.2 * tech.historyLaser)
                     ctx.beginPath();
                     b.laser({
-                        x: mech.pos.x + 20 * Math.cos(mech.angle),
-                        y: mech.pos.y + 20 * Math.sin(mech.angle)
+                        x: m.pos.x + 20 * Math.cos(m.angle),
+                        y: m.pos.y + 20 * Math.sin(m.angle)
                     }, {
-                        x: mech.pos.x + 3000 * Math.cos(mech.angle),
-                        y: mech.pos.y + 3000 * Math.sin(mech.angle)
+                        x: m.pos.x + 3000 * Math.cos(m.angle),
+                        y: m.pos.y + 3000 * Math.sin(m.angle)
                     }, dmg, 0, true, 0.2);
                     for (let i = 1, len = 5 + tech.historyLaser * 5; i < len; i++) {
-                        const history = mech.history[(mech.cycle - i * spacing) % 600]
+                        const history = m.history[(m.cycle - i * spacing) % 600]
                         const off = history.yOff - 24.2859
                         b.laser({
                             x: history.position.x + 20 * Math.cos(history.angle),
@@ -4198,18 +4198,18 @@ const b = {
                 }
             },
             firePulse() {
-                mech.fireCDcycle = mech.cycle + Math.floor((tech.isPulseAim ? 25 : 50) * b.fireCD); // cool down
-                let energy = 0.27 * Math.min(mech.energy, 1.5)
-                mech.energy -= energy * tech.isLaserDiode
+                m.fireCDcycle = m.cycle + Math.floor((tech.isPulseAim ? 25 : 50) * b.fireCD); // cool down
+                let energy = 0.27 * Math.min(m.energy, 1.5)
+                m.energy -= energy * tech.isLaserDiode
                 if (tech.beamSplitter) {
                     energy *= Math.pow(0.9, tech.beamSplitter)
-                    b.pulse(energy, mech.angle)
+                    b.pulse(energy, m.angle)
                     for (let i = 1; i < 1 + tech.beamSplitter; i++) {
-                        b.pulse(energy, mech.angle - i * 0.27)
-                        b.pulse(energy, mech.angle + i * 0.27)
+                        b.pulse(energy, m.angle - i * 0.27)
+                        b.pulse(energy, m.angle + i * 0.27)
                     }
                 } else {
-                    b.pulse(energy, mech.angle)
+                    b.pulse(energy, m.angle)
                 }
             },
         },
@@ -4225,35 +4225,35 @@ const b = {
         holdCount: 0,
         activeGunIndex: null,
         fire() {
-            if (this.lastFireCycle === mech.cycle - 1) { //button has been held down
+            if (this.lastFireCycle === m.cycle - 1) { //button has been held down
                 this.rewindCount += 8;
                 const DRAIN = 0.01
-                let history = mech.history[(mech.cycle - this.rewindCount) % 600]
-                if (this.rewindCount > 599 || mech.energy < DRAIN || history.activeGun !== this.activeGunIndex) {
+                let history = m.history[(m.cycle - this.rewindCount) % 600]
+                if (this.rewindCount > 599 || m.energy < DRAIN || history.activeGun !== this.activeGunIndex) {
                     this.rewindCount = 0;
-                    mech.resetHistory();
-                    mech.fireCDcycle = mech.cycle + Math.floor(120 * b.fireCD); // cool down
+                    m.resetHistory();
+                    m.fireCDcycle = m.cycle + Math.floor(120 * b.fireCD); // cool down
                 } else {
-                    mech.energy -= DRAIN
-                    mech.immuneCycle = mech.cycle + 30; //player is immune to collision damage for 5 cycles
+                    m.energy -= DRAIN
+                    m.immuneCycle = m.cycle + 30; //player is immune to collision damage for 5 cycles
                     Matter.Body.setPosition(player, history.position);
                     Matter.Body.setVelocity(player, { x: history.velocity.x, y: history.velocity.y });
-                    if (mech.health !== history.health) {
-                        mech.health = history.health
-                        mech.displayHealth();
+                    if (m.health !== history.health) {
+                        m.health = history.health
+                        m.displayHealth();
                     }
-                    mech.yOff = history.yOff
-                    if (mech.yOff < 48) {
-                        mech.doCrouch()
+                    m.yOff = history.yOff
+                    if (m.yOff < 48) {
+                        m.doCrouch()
                     } else {
-                        mech.undoCrouch()
+                        m.undoCrouch()
                     }
                 }
             } else { //button is held the first time
                 this.rewindCount = 0;
                 this.activeGunIndex = b.activeGun
             }
-            this.lastFireCycle = mech.cycle;
+            this.lastFireCycle = m.cycle;
         }
     }
 };
\ No newline at end of file
diff --git a/js/engine.js b/js/engine.js
index 95b2f52..7c4cc17 100644
--- a/js/engine.js
+++ b/js/engine.js
@@ -23,25 +23,25 @@ engine.world.gravity.scale = 0; //turn off gravity (it's added back in later)
 function playerOnGroundCheck(event) {
     //runs on collisions events
     function enter() {
-        mech.numTouching++;
-        if (!mech.onGround) {
-            mech.onGround = true;
-            if (mech.crouch) {
-                if (mech.checkHeadClear()) {
-                    mech.undoCrouch();
+        m.numTouching++;
+        if (!m.onGround) {
+            m.onGround = true;
+            if (m.crouch) {
+                if (m.checkHeadClear()) {
+                    m.undoCrouch();
                 } else {
-                    mech.yOffGoal = mech.yOffWhen.crouch;
+                    m.yOffGoal = m.yOffWhen.crouch;
                 }
             } else {
                 //sets a hard land where player stays in a crouch for a bit and can't jump
                 //crouch is forced in groundControl below
                 const momentum = player.velocity.y * player.mass //player mass is 5 so this triggers at 26 down velocity, unless the player is holding something
                 if (momentum > 130) {
-                    mech.doCrouch();
-                    mech.yOff = mech.yOffWhen.jump;
-                    mech.hardLandCD = mech.cycle + Math.min(momentum / 6.5 - 6, 40)
+                    m.doCrouch();
+                    m.yOff = m.yOffWhen.jump;
+                    m.hardLandCD = m.cycle + Math.min(momentum / 6.5 - 6, 40)
                 } else {
-                    mech.yOffGoal = mech.yOffWhen.stand;
+                    m.yOffGoal = m.yOffWhen.stand;
                 }
             }
         }
@@ -51,14 +51,14 @@ function playerOnGroundCheck(event) {
     for (let i = 0, j = pairs.length; i != j; ++i) {
         let pair = pairs[i];
         if (pair.bodyA === jumpSensor) {
-            mech.standingOn = pair.bodyB; //keeping track to correctly provide recoil on jump
-            if (mech.standingOn.alive !== true) enter();
+            m.standingOn = pair.bodyB; //keeping track to correctly provide recoil on jump
+            if (m.standingOn.alive !== true) enter();
         } else if (pair.bodyB === jumpSensor) {
-            mech.standingOn = pair.bodyA; //keeping track to correctly provide recoil on jump
-            if (mech.standingOn.alive !== true) enter();
+            m.standingOn = pair.bodyA; //keeping track to correctly provide recoil on jump
+            if (m.standingOn.alive !== true) enter();
         }
     }
-    mech.numTouching = 0;
+    m.numTouching = 0;
 }
 
 function playerOffGroundCheck(event) {
@@ -66,14 +66,14 @@ function playerOffGroundCheck(event) {
     const pairs = event.pairs;
     for (let i = 0, j = pairs.length; i != j; ++i) {
         if (pairs[i].bodyA === jumpSensor || pairs[i].bodyB === jumpSensor) {
-            if (mech.onGround && mech.numTouching === 0) {
-                mech.onGround = false;
-                mech.hardLandCD = 0 // disable hard landing
-                if (mech.checkHeadClear()) {
-                    if (mech.crouch) {
-                        mech.undoCrouch();
+            if (m.onGround && m.numTouching === 0) {
+                m.onGround = false;
+                m.hardLandCD = 0 // disable hard landing
+                if (m.checkHeadClear()) {
+                    if (m.crouch) {
+                        m.undoCrouch();
                     }
-                    mech.yOffGoal = mech.yOffWhen.jump;
+                    m.yOffGoal = m.yOffWhen.jump;
                 }
             }
         }
@@ -85,7 +85,7 @@ function collisionChecks(event) {
     for (let i = 0, j = pairs.length; i != j; i++) {
         //mob + (player,bullet,body) collisions
         for (let k = 0; k < mob.length; k++) {
-            if (mob[k].alive && mech.alive) {
+            if (mob[k].alive && m.alive) {
                 if (pairs[i].bodyA === mob[k]) {
                     collideMob(pairs[i].bodyB);
                     break;
@@ -97,21 +97,21 @@ function collisionChecks(event) {
                 function collideMob(obj) {
                     //player + mob collision
                     if (
-                        mech.immuneCycle < mech.cycle &&
+                        m.immuneCycle < m.cycle &&
                         (obj === playerBody || obj === playerHead) &&
                         !(tech.isFreezeHarmImmune && (mob[k].isSlowed || mob[k].isStunned))
                     ) {
                         mob[k].foundPlayer();
                         let dmg = Math.min(Math.max(0.025 * Math.sqrt(mob[k].mass), 0.05), 0.3) * simulation.dmgScale; //player damage is capped at 0.3*dmgScale of 1.0
-                        if (tech.isRewindAvoidDeath && mech.energy > 0.66) { //CPT reversal runs in mech.damage, but it stops the rest of the collision code here too
-                            mech.damage(dmg);
+                        if (tech.isRewindAvoidDeath && m.energy > 0.66) { //CPT reversal runs in m.damage, but it stops the rest of the collision code here too
+                            m.damage(dmg);
                             return
                         }
-                        mech.damage(dmg);
-                        if (tech.isPiezo) mech.energy += 4;
+                        m.damage(dmg);
+                        if (tech.isPiezo) m.energy += 4;
                         if (tech.isBayesian) powerUps.ejectTech()
                         if (mob[k].onHit) mob[k].onHit(k);
-                        mech.immuneCycle = mech.cycle + tech.collisionImmuneCycles; //player is immune to collision damage for 30 cycles
+                        m.immuneCycle = m.cycle + tech.collisionImmuneCycles; //player is immune to collision damage for 30 cycles
                         //extra kick between player and mob              //this section would be better with forces but they don't work...
                         let angle = Math.atan2(player.position.y - mob[k].position.y, player.position.x - mob[k].position.x);
                         Matter.Body.setVelocity(player, {
@@ -123,9 +123,9 @@ function collisionChecks(event) {
                             y: mob[k].velocity.y - 8 * Math.sin(angle)
                         });
 
-                        if (tech.isAnnihilation && !mob[k].shield && !mob[k].isShielded && mob[k].dropPowerUp && mech.energy > 0.34 * mech.maxEnergy) {
-                            mech.energy -= 0.33 * mech.maxEnergy
-                            mech.immuneCycle = 0; //player doesn't go immune to collision damage
+                        if (tech.isAnnihilation && !mob[k].shield && !mob[k].isShielded && mob[k].dropPowerUp && m.energy > 0.34 * m.maxEnergy) {
+                            m.energy -= 0.33 * m.maxEnergy
+                            m.immuneCycle = 0; //player doesn't go immune to collision damage
                             mob[k].death();
                             simulation.drawList.push({ //add dmg to draw queue
                                 x: pairs[i].activeContacts[0].vertex.x,
@@ -171,7 +171,7 @@ function collisionChecks(event) {
                             mob[k].damage(dmg, true);
                             const stunTime = dmg / Math.sqrt(obj.mass)
                             if (stunTime > 0.5) mobs.statusStun(mob[k], 30 + 60 * Math.sqrt(stunTime))
-                            if (mob[k].distanceToPlayer2() < 1000000 && !mech.isCloak) mob[k].foundPlayer();
+                            if (mob[k].distanceToPlayer2() < 1000000 && !m.isCloak) mob[k].foundPlayer();
                             if (tech.fragments && obj.speed > 10 && !obj.hasFragmented) {
                                 obj.hasFragmented = true;
                                 b.targetedNail(obj.position, tech.fragments * 4)
diff --git a/js/index.js b/js/index.js
index 01cfcaf..3a21b89 100644
--- a/js/index.js
+++ b/js/index.js
@@ -69,8 +69,8 @@ window.addEventListener('load', (event) => {
             if (property === "field") {
                 let found = false
                 let index
-                for (let i = 0; i < mech.fieldUpgrades.length; i++) {
-                    if (set[property] === mech.fieldUpgrades[i].name) {
+                for (let i = 0; i < m.fieldUpgrades.length; i++) {
+                    if (set[property] === m.fieldUpgrades[i].name) {
                         index = i;
                         found = true;
                         break;
@@ -156,7 +156,7 @@ const build = {
                 set[property] = set[property].replace(/%20/g, " ")
                 if (property.substring(0, 3) === "gun") b.giveGuns(set[property])
                 if (property.substring(0, 3) === "tech") tech.giveTech(set[property])
-                if (property === "field") mech.setField(set[property])
+                if (property === "field") m.setField(set[property])
                 if (property === "difficulty") {
                     simulation.difficultyMode = Number(set[property])
                     document.getElementById("difficulty-select").value = Number(set[property])
@@ -177,7 +177,7 @@ const build = {
         }
     },
     pauseGrid() {
-        const harm = (1 - mech.harmReduction()) * 100
+        const harm = (1 - m.harmReduction()) * 100
         let text = ""
         if (!simulation.isChoosing) text += `<div class="pause-grid-module">
       <span style="font-size:1.5em;font-weight: 600;">PAUSED</span> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; press P to resume</div>`
@@ -189,11 +189,11 @@ const build = {
       <br><strong class='color-dup'>duplication</strong> chance: ${(Math.min(1,tech.duplicationChance())*100).toFixed(0)}%
       <br>
       <br><strong class='color-m'>tech</strong>: ${tech.totalCount}  &nbsp; <strong class='color-r'>research</strong>: ${powerUps.research.count}  
-      <br><strong class='color-h'>health</strong>: (${(mech.health*100).toFixed(0)} / ${(mech.maxHealth*100).toFixed(0)}) &nbsp; <strong class='color-f'>energy</strong>: (${(mech.energy*100).toFixed(0)} / ${(mech.maxEnergy*100).toFixed(0)})
+      <br><strong class='color-h'>health</strong>: (${(m.health*100).toFixed(0)} / ${(m.maxHealth*100).toFixed(0)}) &nbsp; <strong class='color-f'>energy</strong>: (${(m.energy*100).toFixed(0)} / ${(m.maxEnergy*100).toFixed(0)})
       <br>position: (${player.position.x.toFixed(1)}, ${player.position.y.toFixed(1)}) &nbsp; velocity: (${player.velocity.x.toFixed(1)}, ${player.velocity.y.toFixed(1)})
       <br>mouse: (${simulation.mouseInGame.x.toFixed(1)}, ${simulation.mouseInGame.y.toFixed(1)}) &nbsp; mass: ${player.mass.toFixed(1)}      
       <br>
-      <br>level: ${level.levels[level.onLevel]} (${level.difficultyText()}) &nbsp; ${mech.cycle} cycles
+      <br>level: ${level.levels[level.onLevel]} (${level.difficultyText()}) &nbsp; ${m.cycle} cycles
       <br>${mob.length} mobs, &nbsp; ${body.length} blocks, &nbsp; ${bullet.length} bullets, &nbsp; ${powerUp.length} power ups
       <br>damage difficulty scale: ${(b.dmgScale*100).toFixed(2) }%
       <br>harm difficulty scale: ${(simulation.dmgScale*100).toFixed(0)}%
@@ -212,7 +212,7 @@ const build = {
         el.style.display = "grid"
         el.innerHTML = text
         text = "";
-        text += `<div class="pause-grid-module"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${mech.fieldUpgrades[mech.fieldMode].name}</div> ${mech.fieldUpgrades[mech.fieldMode].description}</div>`
+        text += `<div class="pause-grid-module"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${m.fieldUpgrades[m.fieldMode].name}</div> ${m.fieldUpgrades[m.fieldMode].description}</div>`
         let countTech = 0
         for (let i = 0, len = tech.tech.length; i < len; i++) {
             if (tech.tech[i].count > 0) {
@@ -276,9 +276,9 @@ const build = {
                 b.giveGuns(index)
             }
         } else if (type === "field") {
-            if (mech.fieldMode !== index) {
-                document.getElementById("field-" + mech.fieldMode).classList.remove("build-field-selected");
-                mech.setField(index)
+            if (m.fieldMode !== index) {
+                document.getElementById("field-" + m.fieldMode).classList.remove("build-field-selected");
+                m.setField(index)
                 who.classList.add("build-field-selected");
             }
         } else if (type === "tech") { //remove tech if you have too many
@@ -369,8 +369,8 @@ const build = {
       <input type="checkbox" id="no-power-ups" name="no-power-ups" style="width:17px; height:17px;">
     </div>
   </div>`
-        for (let i = 0, len = mech.fieldUpgrades.length; i < len; i++) {
-            text += `<div id ="field-${i}" class="experiment-grid-module" onclick="build.choosePowerUp(this,${i},'field')"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${mech.fieldUpgrades[i].name}</div> ${mech.fieldUpgrades[i].description}</div>`
+        for (let i = 0, len = m.fieldUpgrades.length; i < len; i++) {
+            text += `<div id ="field-${i}" class="experiment-grid-module" onclick="build.choosePowerUp(this,${i},'field')"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${m.fieldUpgrades[i].name}</div> ${m.fieldUpgrades[i].description}</div>`
         }
         for (let i = 0, len = b.guns.length; i < len; i++) {
             text += `<div id = "gun-${i}" class="experiment-grid-module" onclick="build.choosePowerUp(this,${i},'gun')"><div class="grid-title"><div class="circle-grid gun"></div> &nbsp; ${b.guns[i].name}</div> ${b.guns[i].description}</div>`
@@ -398,7 +398,7 @@ const build = {
     },
     reset() {
         build.isExperimentSelection = true;
-        mech.setField(0)
+        m.setField(0)
 
         b.inventory = []; //removes guns and ammo  
         for (let i = 0, len = b.guns.length; i < len; ++i) {
@@ -432,7 +432,7 @@ const build = {
                 count++
             }
         }
-        url += `&field=${encodeURIComponent(mech.fieldUpgrades[mech.fieldMode].name.trim())}`
+        url += `&field=${encodeURIComponent(m.fieldUpgrades[m.fieldMode].name.trim())}`
         url += `&difficulty=${simulation.difficultyMode}`
         if (isCustom) {
             url += `&level=${Math.abs(Number(document.getElementById("starting-level").value))}`
@@ -501,7 +501,7 @@ document.getElementById("experiment-button").addEventListener("click", () => { /
     let inventory = [];
     let techList = [];
     if (!simulation.firstRun) {
-        field = mech.fieldMode
+        field = m.fieldMode
         inventory = [...b.inventory]
         for (let i = 0; i < tech.tech.length; i++) {
             techList.push(tech.tech[i].count)
@@ -710,7 +710,7 @@ window.addEventListener("keydown", function(event) {
             simulation.previousGun();
             break
         case input.key.pause:
-            if (!simulation.isChoosing && input.isPauseKeyReady && mech.alive) {
+            if (!simulation.isChoosing && input.isPauseKeyReady && m.alive) {
                 input.isPauseKeyReady = false
                 setTimeout(function() {
                     input.isPauseKeyReady = true
@@ -729,7 +729,7 @@ window.addEventListener("keydown", function(event) {
             }
             break
         case input.key.testing:
-            if (mech.alive && localSettings.loreCount > 0) {
+            if (m.alive && localSettings.loreCount > 0) {
                 if (simulation.testing) {
                     simulation.testing = false;
                     simulation.loop = simulation.normalLoop
@@ -791,7 +791,7 @@ window.addEventListener("keydown", function(event) {
             break
     }
     if (simulation.testing) {
-        if (event.key === "X") mech.death(); //only uppercase
+        if (event.key === "X") m.death(); //only uppercase
         switch (event.key.toLowerCase()) {
             case "o":
                 simulation.isAutoZoom = false;
@@ -837,21 +837,21 @@ window.addEventListener("keydown", function(event) {
                 spawn.randomLevelBoss(simulation.mouseInGame.x, simulation.mouseInGame.y);
                 break
             case "f":
-                const mode = (mech.fieldMode === mech.fieldUpgrades.length - 1) ? 0 : mech.fieldMode + 1
-                mech.setField(mode)
+                const mode = (m.fieldMode === m.fieldUpgrades.length - 1) ? 0 : m.fieldMode + 1
+                m.setField(mode)
                 break
             case "g":
                 b.giveGuns("all", 1000)
                 break
             case "h":
-                mech.addHealth(Infinity)
-                mech.energy = mech.maxEnergy;
+                m.addHealth(Infinity)
+                m.energy = m.maxEnergy;
                 break
             case "y":
                 tech.giveTech()
                 break
             case "r":
-                mech.resetHistory();
+                m.resetHistory();
                 Matter.Body.setPosition(player, simulation.mouseInGame);
                 Matter.Body.setVelocity(player, {
                     x: 0,
@@ -1068,7 +1068,7 @@ function cycle() {
         simulation.then = now - (elapsed % simulation.fpsInterval); // Get ready for next frame by setting then=now.   Also, adjust for fpsInterval not being multiple of 16.67
 
         simulation.cycle++; //tracks game cycles
-        mech.cycle++; //tracks player cycles  //used to alow time to stop for everything, but the player
+        m.cycle++; //tracks player cycles  //used to alow time to stop for everything, but the player
         if (simulation.clearNow) {
             simulation.clearNow = false;
             simulation.clearMap();
@@ -1076,8 +1076,8 @@ function cycle() {
         }
 
         simulation.loop();
-        // if (isNaN(mech.health) || isNaN(mech.energy)) {
-        //   console.log(`mech.health = ${mech.health}`)
+        // if (isNaN(m.health) || isNaN(m.energy)) {
+        //   console.log(`m.health = ${m.health}`)
         //   simulation.paused = true;
         //   build.pauseGrid()
         //   document.body.style.cursor = "auto";
diff --git a/js/level.js b/js/level.js
index a3f20fd..d9137c2 100644
--- a/js/level.js
+++ b/js/level.js
@@ -16,7 +16,7 @@ const level = {
             // level.difficultyIncrease(30)
             // simulation.zoomScale = 1000;
             // simulation.setZoom();
-            // mech.setField("plasma torch")
+            // m.setField("plasma torch")
             // b.giveGuns("grenades")
             // tech.isExplodeRadio = true
             // tech.giveTech("needle gun")
@@ -74,26 +74,26 @@ const level = {
         level.addToWorld(); //add bodies to game engine
         simulation.draw.setPaths();
         b.respawnBots();
-        mech.resetHistory();
+        m.resetHistory();
         if (tech.isArmorFromPowerUps) {
             tech.armorFromPowerUps += Math.min(0.03 * powerUps.totalPowerUps, 0.42)
-            mech.setMaxHealth();
+            m.setMaxHealth();
         }
         if (tech.isHealLowHealth) {
-            const len = Math.floor((mech.maxHealth - mech.health) / 0.5)
+            const len = Math.floor((m.maxHealth - m.health) / 0.5)
             for (let i = 0; i < len; i++) {
-                powerUps.spawn(mech.pos.x + 60 * (Math.random() - 0.5), mech.pos.y + 60 * (Math.random() - 0.5), "heal", false);
-                // powerUps.heal.spawn(mech.pos.x + 60 * (Math.random() - 0.5), mech.pos.y + 60 * (Math.random() - 0.5), 50);
+                powerUps.spawn(m.pos.x + 60 * (Math.random() - 0.5), m.pos.y + 60 * (Math.random() - 0.5), "heal", false);
+                // powerUps.heal.spawn(m.pos.x + 60 * (Math.random() - 0.5), m.pos.y + 60 * (Math.random() - 0.5), 50);
             }
         }
-        if (tech.isPerpetualReroll) powerUps.spawn(mech.pos.x + 60 * (Math.random() - 0.5), mech.pos.y + 60 * (Math.random() - 0.5), "research", false);
+        if (tech.isPerpetualReroll) powerUps.spawn(m.pos.x + 60 * (Math.random() - 0.5), m.pos.y + 60 * (Math.random() - 0.5), "research", false);
         if (tech.isPerpetualAmmo) {
-            powerUps.spawn(mech.pos.x + 60 * (Math.random() - 0.5), mech.pos.y + 60 * (Math.random() - 0.5), "ammo", false);
-            powerUps.spawn(mech.pos.x + 60 * (Math.random() - 0.5), mech.pos.y + 60 * (Math.random() - 0.5), "ammo", false);
+            powerUps.spawn(m.pos.x + 60 * (Math.random() - 0.5), m.pos.y + 60 * (Math.random() - 0.5), "ammo", false);
+            powerUps.spawn(m.pos.x + 60 * (Math.random() - 0.5), m.pos.y + 60 * (Math.random() - 0.5), "ammo", false);
         }
         if (tech.isPerpetualHeal) {
-            powerUps.spawn(mech.pos.x + 60 * (Math.random() - 0.5), mech.pos.y + 60 * (Math.random() - 0.5), "heal", false);
-            powerUps.spawn(mech.pos.x + 60 * (Math.random() - 0.5), mech.pos.y + 60 * (Math.random() - 0.5), "heal", false);
+            powerUps.spawn(m.pos.x + 60 * (Math.random() - 0.5), m.pos.y + 60 * (Math.random() - 0.5), "heal", false);
+            powerUps.spawn(m.pos.x + 60 * (Math.random() - 0.5), m.pos.y + 60 * (Math.random() - 0.5), "heal", false);
         }
         if (tech.isPerpetualStun) {
             for (let i = 0; i < mob.length; i++) mobs.statusStun(mob[i], 600)
@@ -162,9 +162,9 @@ const level = {
             ctx.beginPath();
             const step = Math.PI / 20
             const horizontalStep = 85
-            if (simulation.isCheating) phase += 0.003 //(mech.pos.x - circle.x) * 0.0005 //0.05 * Math.sin(simulation.cycle * 0.030)
+            if (simulation.isCheating) phase += 0.003 //(m.pos.x - circle.x) * 0.0005 //0.05 * Math.sin(simulation.cycle * 0.030)
             // const sway = 5 * Math.cos(simulation.cycle * 0.007)
-            sway.x = sway.x * 0.995 + 0.005 * (mech.pos.x - circle.x) * 0.05 //+ 0.04 * Math.cos(simulation.cycle * 0.01)
+            sway.x = sway.x * 0.995 + 0.005 * (m.pos.x - circle.x) * 0.05 //+ 0.04 * Math.cos(simulation.cycle * 0.01)
             sway.y = 2.5 * Math.sin(simulation.cycle * 0.015)
             for (let i = -19.5; i < 20; i++) {
                 const where = {
@@ -740,7 +740,7 @@ const level = {
         const door = level.door(312, -750, 25, 190, 185)
 
         level.custom = () => {
-            if (!(mech.cycle % 60)) { //so much work to catch blocks caught at the bottom of the vertical portals
+            if (!(m.cycle % 60)) { //so much work to catch blocks caught at the bottom of the vertical portals
                 let touching = Matter.Query.collides(map[removeIndex1], body)
                 if (touching.length) {
                     // console.log(touching[0].bodyB)
@@ -1112,7 +1112,7 @@ const level = {
             level.playerExitCheck();
         };
         level.customTopLayer = () => {
-            if (elevator.pauseUntilCycle < simulation.cycle && !mech.isBodiesAsleep) { //elevator move
+            if (elevator.pauseUntilCycle < simulation.cycle && !m.isBodiesAsleep) { //elevator move
                 if (elevator.pointA.y > -1275) { //bottom
                     elevator.plat.speed = -10
                     elevator.pauseUntilCycle = simulation.cycle + 90
@@ -1321,7 +1321,7 @@ const level = {
         };
         level.customTopLayer = () => {
 
-            if (elevator.pauseUntilCycle < simulation.cycle && !mech.isBodiesAsleep) { //elevator move
+            if (elevator.pauseUntilCycle < simulation.cycle && !m.isBodiesAsleep) { //elevator move
                 if (elevator.pointA.y > -980) { //bottom
                     elevator.plat.speed = -2
                     elevator.pauseUntilCycle = simulation.cycle + 60
@@ -2796,7 +2796,7 @@ const level = {
             portal[3].draw();
             hazard.draw();
             //elevator
-            if (elevator.pauseUntilCycle < simulation.cycle && !mech.isBodiesAsleep) {
+            if (elevator.pauseUntilCycle < simulation.cycle && !m.isBodiesAsleep) {
                 if (elevator.plat.position.y > -200) { //bottom
                     elevator.plat.speed = -20
                     elevator.pauseUntilCycle = simulation.cycle + 90
@@ -3932,7 +3932,7 @@ const level = {
             if (simulation.CDScale > 0.2) simulation.CDScale *= 0.97 //mob CD time decreases each level
         }
         simulation.dmgScale = 0.378 * simulation.difficulty //damage done by mobs increases each level
-        simulation.healScale = 1 / (1 + simulation.difficulty * 0.06) //a higher denominator makes for lower heals // mech.health += heal * simulation.healScale;
+        simulation.healScale = 1 / (1 + simulation.difficulty * 0.06) //a higher denominator makes for lower heals // m.health += heal * simulation.healScale;
     },
     difficultyDecrease(num = 1) { //used in easy mode for simulation.reset()
         for (let i = 0; i < num; i++) {
@@ -3973,9 +3973,9 @@ const level = {
         // <br>input.key.down = ["<span class='color-text'>${input.key.down}</span>", "<span class='color-text'>ArrowDown</span>"]
         // <br>input.key.right = ["<span class='color-text'>${input.key.right}</span>", "<span class='color-text'>ArrowRight</span>"]
         // <br>
-        // <br><span class='color-var'>mech</span>.fieldMode = "<span class='color-text'>${mech.fieldUpgrades[mech.fieldMode].name}</span>"
+        // <br><span class='color-var'>m</span>.fieldMode = "<span class='color-text'>${m.fieldUpgrades[m.fieldMode].name}</span>"
         // <br>input.key.field = ["<span class='color-text'>${input.key.field}</span>", "<span class='color-text'>right mouse</span>"]
-        // <br><span class='color-var'>mech</span>.field.description = "<span class='color-text'>${mech.fieldUpgrades[mech.fieldMode].description}</span>"
+        // <br><span class='color-var'>m</span>.field.description = "<span class='color-text'>${m.fieldUpgrades[m.fieldMode].description}</span>"
         // `, 1200);
     },
     nextLevel() {
@@ -4009,18 +4009,18 @@ const level = {
         }
     },
     setPosToSpawn(xPos, yPos) {
-        mech.spawnPos.x = mech.pos.x = xPos;
-        mech.spawnPos.y = mech.pos.y = yPos;
-        level.enter.x = mech.spawnPos.x - 50;
-        level.enter.y = mech.spawnPos.y + 20;
-        mech.transX = mech.transSmoothX = canvas.width2 - mech.pos.x;
-        mech.transY = mech.transSmoothY = canvas.height2 - mech.pos.y;
-        mech.Vx = mech.spawnVel.x;
-        mech.Vy = mech.spawnVel.y;
+        m.spawnPos.x = m.pos.x = xPos;
+        m.spawnPos.y = m.pos.y = yPos;
+        level.enter.x = m.spawnPos.x - 50;
+        level.enter.y = m.spawnPos.y + 20;
+        m.transX = m.transSmoothX = canvas.width2 - m.pos.x;
+        m.transY = m.transSmoothY = canvas.height2 - m.pos.y;
+        m.Vx = m.spawnVel.x;
+        m.Vy = m.spawnVel.y;
         player.force.x = 0;
         player.force.y = 0;
-        Matter.Body.setPosition(player, mech.spawnPos);
-        Matter.Body.setVelocity(player, mech.spawnVel);
+        Matter.Body.setPosition(player, m.spawnPos);
+        Matter.Body.setVelocity(player, m.spawnVel);
     },
     enter: {
         x: 0,
@@ -4115,8 +4115,8 @@ const level = {
             target.torque = (Math.random() - 0.5) * 2 * target.mass;
         },
         boost(target, yVelocity) {
-            mech.buttonCD_jump = 0; // reset short jump counter to prevent short jumps on boosts
-            mech.hardLandCD = 0 // disable hard landing
+            m.buttonCD_jump = 0; // reset short jump counter to prevent short jumps on boosts
+            m.hardLandCD = 0 // disable hard landing
             if (target.velocity.y > 30) {
                 Matter.Body.setVelocity(target, {
                     x: target.velocity.x + (Math.random() - 0.5) * 2,
@@ -4148,7 +4148,7 @@ const level = {
     addToWorld() { //needs to be run to put bodies into the world
         for (let i = 0; i < body.length; i++) {
             //body[i].collisionFilter.group = 0;
-            if (body[i] !== mech.holdingTarget) {
+            if (body[i] !== m.holdingTarget) {
                 body[i].collisionFilter.category = cat.body;
                 body[i].collisionFilter.mask = cat.player | cat.map | cat.body | cat.bullet | cat.mob | cat.mobBullet
             }
@@ -4270,7 +4270,7 @@ const level = {
 
         if (rotate) {
             rotor.rotate = function() {
-                if (!mech.isBodiesAsleep) {
+                if (!m.isBodiesAsleep) {
                     Matter.Body.applyForce(rotor, {
                         x: rotor.position.x + 100,
                         y: rotor.position.y + 100
@@ -4364,7 +4364,7 @@ const level = {
             restitution: 0,
             isOpen: false,
             openClose() {
-                if (!mech.isBodiesAsleep) {
+                if (!m.isBodiesAsleep) {
                     if (!this.isOpen) {
                         if (this.position.y > y - distance) { //try to open 
                             const position = {
@@ -4432,8 +4432,8 @@ const level = {
             if (Matter.Query.collides(this, [player]).length === 0) { //not touching player
                 if (player.isInPortal === this) player.isInPortal = null
             } else if (player.isInPortal !== this) { //touching player
-                if (mech.buttonCD_jump === mech.cycle) player.force.y = 0 // undo a jump right before entering the portal
-                mech.buttonCD_jump = 0 //disable short jumps when letting go of jump key
+                if (m.buttonCD_jump === m.cycle) player.force.y = 0 // undo a jump right before entering the portal
+                m.buttonCD_jump = 0 //disable short jumps when letting go of jump key
                 player.isInPortal = this.portalPair
                 //teleport
                 if (this.portalPair.angle % (Math.PI / 2)) { //if left, right up or down
@@ -4467,7 +4467,7 @@ const level = {
             }
             // if (body.length) {
             for (let i = 0, len = body.length; i < len; i++) {
-                if (body[i] !== mech.holdingTarget) {
+                if (body[i] !== m.holdingTarget) {
                     // body[i].bounds.max.x - body[i].bounds.min.x < 100 && body[i].bounds.max.y - body[i].bounds.min.y < 100
                     if (Matter.Query.collides(this, [body[i]]).length === 0) {
                         if (body[i].isInPortal === this) body[i].isInPortal = null
@@ -4502,7 +4502,7 @@ const level = {
             // if (body.length) {
             //   touching = Matter.Query.collides(this, body)
             //   for (let i = 0; i < touching.length; i++) {
-            //     if (touching[i].bodyB !== mech.holdingTarget) {
+            //     if (touching[i].bodyB !== m.holdingTarget) {
             //       for (let j = 0, len = body.length; j < len; j++) {
             //         if (body[j] === touching[i].bodyB) {
             //           body.splice(j, 1);
@@ -4515,7 +4515,7 @@ const level = {
             //   }
             // }
 
-            // if (touching.length !== 0 && touching[0].bodyB !== mech.holdingTarget) {
+            // if (touching.length !== 0 && touching[0].bodyB !== m.holdingTarget) {
             //   if (body.length) {
             //     for (let i = 0; i < body.length; i++) {
             //       if (body[i] === touching[0].bodyB) {
@@ -4591,12 +4591,12 @@ const level = {
             maxHeight: height,
             isOn: true,
             query() {
-                if (this.isOn && this.height > 0 && Matter.Query.region([player], this).length && !(mech.isCloak && isOptical)) {
+                if (this.isOn && this.height > 0 && Matter.Query.region([player], this).length && !(m.isCloak && isOptical)) {
                     if (damage < 0.02) {
-                        mech.damage(damage)
-                    } else if (mech.immuneCycle < mech.cycle) {
-                        mech.immuneCycle = mech.cycle + tech.collisionImmuneCycles;
-                        mech.damage(damage)
+                        m.damage(damage)
+                    } else if (m.immuneCycle < m.cycle) {
+                        m.immuneCycle = m.cycle + tech.collisionImmuneCycles;
+                        m.damage(damage)
                         simulation.drawList.push({ //add dmg to draw queue
                             x: player.position.x,
                             y: player.position.y,
@@ -4606,7 +4606,7 @@ const level = {
                         });
                     }
                     const drain = 0.005
-                    if (mech.energy > drain) mech.energy -= drain
+                    if (m.energy > drain) m.energy -= drain
                 }
             },
             draw() {
@@ -4623,7 +4623,7 @@ const level = {
                 }
             },
             level(isFill) {
-                if (!mech.isBodiesAsleep) {
+                if (!m.isBodiesAsleep) {
                     const growSpeed = 1
                     if (isFill) {
                         if (this.height < this.maxHeight) {
diff --git a/js/mob.js b/js/mob.js
index 4cad089..4f33077 100644
--- a/js/mob.js
+++ b/js/mob.js
@@ -61,7 +61,7 @@ const mobs = {
         }
 
         function applySlow() {
-            if (!who.shield && !who.isShielded && !mech.isBodiesAsleep) {
+            if (!who.shield && !who.isShielded && !m.isBodiesAsleep) {
                 if (who.isBoss) cycles = Math.floor(cycles * 0.25)
 
                 let i = who.status.length
@@ -99,7 +99,7 @@ const mobs = {
         }
     },
     statusStun(who, cycles = 180) {
-        if (!who.shield && !who.isShielded && !mech.isBodiesAsleep) {
+        if (!who.shield && !who.isShielded && !m.isBodiesAsleep) {
             Matter.Body.setVelocity(who, {
                 x: who.velocity.x * 0.8,
                 y: who.velocity.y * 0.8
@@ -150,7 +150,7 @@ const mobs = {
         }
     },
     statusDoT(who, tickDamage, cycles = 180) {
-        if (!who.isShielded && !mech.isBodiesAsleep && who.alive) {
+        if (!who.isShielded && !m.isBodiesAsleep && who.alive) {
             who.status.push({
                 effect() {
                     if ((simulation.cycle - this.startCycle) % 30 === 0) {
@@ -300,7 +300,7 @@ const mobs = {
                 }
             },
             alwaysSeePlayer() {
-                if (!mech.isCloak) {
+                if (!m.isCloak) {
                     this.seePlayer.recall = true;
                     this.seePlayer.position.x = player.position.x;
                     this.seePlayer.position.y = player.position.y;
@@ -310,9 +310,9 @@ const mobs = {
                 if (!(simulation.cycle % this.seePlayerFreq)) {
                     if (
                         this.distanceToPlayer2() < this.seeAtDistance2 &&
-                        Matter.Query.ray(map, this.position, this.mechPosRange()).length === 0 &&
-                        Matter.Query.ray(body, this.position, this.mechPosRange()).length === 0 &&
-                        !mech.isCloak
+                        Matter.Query.ray(map, this.position, this.mPosRange()).length === 0 &&
+                        Matter.Query.ray(body, this.position, this.mPosRange()).length === 0 &&
+                        !m.isCloak
                     ) {
                         this.foundPlayer();
                     } else if (this.seePlayer.recall) {
@@ -322,7 +322,7 @@ const mobs = {
             },
             seePlayerCheckByDistance() {
                 if (!(simulation.cycle % this.seePlayerFreq)) {
-                    if (this.distanceToPlayer2() < this.seeAtDistance2 && !mech.isCloak) {
+                    if (this.distanceToPlayer2() < this.seeAtDistance2 && !m.isCloak) {
                         this.foundPlayer();
                     } else if (this.seePlayer.recall) {
                         this.lostPlayer();
@@ -332,8 +332,8 @@ const mobs = {
             seePlayerByDistOrLOS() {
                 if (!(simulation.cycle % this.seePlayerFreq)) {
                     if (
-                        (this.distanceToPlayer2() < this.seeAtDistance2 || (Matter.Query.ray(map, this.position, this.mechPosRange()).length === 0 && Matter.Query.ray(body, this.position, this.mechPosRange()).length === 0)) &&
-                        !mech.isCloak
+                        (this.distanceToPlayer2() < this.seeAtDistance2 || (Matter.Query.ray(map, this.position, this.mPosRange()).length === 0 && Matter.Query.ray(body, this.position, this.mPosRange()).length === 0)) &&
+                        !m.isCloak
                     ) {
                         this.foundPlayer();
                     } else if (this.seePlayer.recall) {
@@ -363,9 +363,9 @@ const mobs = {
                 if (!(simulation.cycle % this.seePlayerFreq) && (this.seePlayer.recall || this.isLookingAtPlayer(this.lookRange))) {
                     if (
                         this.distanceToPlayer2() < this.seeAtDistance2 &&
-                        Matter.Query.ray(map, this.position, this.mechPosRange()).length === 0 &&
-                        Matter.Query.ray(body, this.position, this.mechPosRange()).length === 0 &&
-                        !mech.isCloak
+                        Matter.Query.ray(map, this.position, this.mPosRange()).length === 0 &&
+                        Matter.Query.ray(body, this.position, this.mPosRange()).length === 0 &&
+                        !m.isCloak
                     ) {
                         this.foundPlayer();
                     } else if (this.seePlayer.recall) {
@@ -384,7 +384,7 @@ const mobs = {
                     ctx.fill();
                 }
             },
-            mechPosRange() {
+            mPosRange() {
                 return {
                     x: player.position.x, // + (Math.random() - 0.5) * 50,
                     y: player.position.y + (Math.random() - 0.5) * 110
@@ -414,18 +414,18 @@ const mobs = {
                     ctx.setLineDash([125 * Math.random(), 125 * Math.random()]);
                     // ctx.lineDashOffset = 6*(simulation.cycle % 215);
                     if (this.distanceToPlayer() < this.laserRange) {
-                        if (mech.immuneCycle < mech.cycle) mech.damage(0.0003 * simulation.dmgScale);
-                        if (mech.energy > 0.1) mech.energy -= 0.003
+                        if (m.immuneCycle < m.cycle) m.damage(0.0003 * simulation.dmgScale);
+                        if (m.energy > 0.1) m.energy -= 0.003
                         ctx.beginPath();
                         ctx.moveTo(this.position.x, this.position.y);
-                        ctx.lineTo(mech.pos.x, mech.pos.y);
-                        ctx.lineTo(mech.pos.x + (Math.random() - 0.5) * 3000, mech.pos.y + (Math.random() - 0.5) * 3000);
+                        ctx.lineTo(m.pos.x, m.pos.y);
+                        ctx.lineTo(m.pos.x + (Math.random() - 0.5) * 3000, m.pos.y + (Math.random() - 0.5) * 3000);
                         ctx.lineWidth = 2;
                         ctx.strokeStyle = "rgb(255,0,170)";
                         ctx.stroke();
 
                         ctx.beginPath();
-                        ctx.arc(mech.pos.x, mech.pos.y, 40, 0, 2 * Math.PI);
+                        ctx.arc(m.pos.x, m.pos.y, 40, 0, 2 * Math.PI);
                         ctx.fillStyle = "rgba(255,0,170,0.15)";
                         ctx.fill();
 
@@ -499,12 +499,12 @@ const mobs = {
                     };
                     vertexCollision(this.position, look, map);
                     vertexCollision(this.position, look, body);
-                    if (!mech.isCloak) vertexCollision(this.position, look, [player]);
+                    if (!m.isCloak) vertexCollision(this.position, look, [player]);
                     // hitting player
                     if (best.who === player) {
-                        if (mech.immuneCycle < mech.cycle) {
+                        if (m.immuneCycle < m.cycle) {
                             const dmg = 0.0012 * simulation.dmgScale;
-                            mech.damage(dmg);
+                            m.damage(dmg);
                             //draw damage
                             ctx.fillStyle = "#f00";
                             ctx.beginPath();
@@ -540,7 +540,7 @@ const mobs = {
                         this.distanceToPlayer2() < this.seeAtDistance2 &&
                         Matter.Query.ray(map, this.position, player.position).length === 0 &&
                         Matter.Query.ray(body, this.position, player.position).length === 0 &&
-                        !mech.isCloak
+                        !m.isCloak
                     ) {
                         this.foundPlayer();
                     } else if (this.seePlayer.recall) {
@@ -687,17 +687,17 @@ const mobs = {
             pullPlayer() {
                 if (this.seePlayer.yes && Vector.magnitudeSquared(Vector.sub(this.position, player.position)) < 1000000) {
                     const angle = Math.atan2(player.position.y - this.position.y, player.position.x - this.position.x);
-                    player.force.x -= simulation.accelScale * 0.00113 * player.mass * Math.cos(angle) * (mech.onGround ? 2 : 1);
+                    player.force.x -= simulation.accelScale * 0.00113 * player.mass * Math.cos(angle) * (m.onGround ? 2 : 1);
                     player.force.y -= simulation.accelScale * 0.00084 * player.mass * Math.sin(angle);
 
                     ctx.beginPath();
                     ctx.moveTo(this.position.x, this.position.y);
-                    ctx.lineTo(mech.pos.x, mech.pos.y);
+                    ctx.lineTo(m.pos.x, m.pos.y);
                     ctx.lineWidth = Math.min(60, this.radius * 2);
                     ctx.strokeStyle = "rgba(0,0,0,0.5)";
                     ctx.stroke();
                     ctx.beginPath();
-                    ctx.arc(mech.pos.x, mech.pos.y, 40, 0, 2 * Math.PI);
+                    ctx.arc(m.pos.x, m.pos.y, 40, 0, 2 * Math.PI);
                     ctx.fillStyle = "rgba(0,0,0,0.3)";
                     ctx.fill();
                 }
@@ -769,7 +769,7 @@ const mobs = {
                 // }
             },
             grow() {
-                if (!mech.isBodiesAsleep) {
+                if (!m.isBodiesAsleep) {
                     if (this.seePlayer.recall) {
                         if (this.radius < 80) {
                             const scale = 1.01;
@@ -843,7 +843,7 @@ const mobs = {
             drift() {
                 //teleport towards player as a way to move
                 if (this.seePlayer.recall && !(simulation.cycle % this.blinkRate)) {
-                    // && !mech.lookingAtMob(this,0.5)){
+                    // && !m.lookingAtMob(this,0.5)){
                     ctx.beginPath();
                     ctx.moveTo(this.position.x, this.position.y);
                     const dist = Vector.sub(this.seePlayer.position, this.position);
@@ -871,8 +871,8 @@ const mobs = {
                 if (
                     !(simulation.cycle % this.fireFreq) &&
                     Math.abs(this.position.x - this.seePlayer.position.x) < 400 && //above player
-                    Matter.Query.ray(map, this.position, this.mechPosRange()).length === 0 && //see player
-                    Matter.Query.ray(body, this.position, this.mechPosRange()).length === 0
+                    Matter.Query.ray(map, this.position, this.mPosRange()).length === 0 && //see player
+                    Matter.Query.ray(body, this.position, this.mPosRange()).length === 0
                 ) {
                     spawn.bomb(this.position.x, this.position.y + this.radius * 0.5, 10 + Math.ceil(this.radius / 15), 5);
                     //add spin and speed
@@ -886,7 +886,7 @@ const mobs = {
                 }
             },
             fire() {
-                if (!mech.isBodiesAsleep) {
+                if (!m.isBodiesAsleep) {
                     const setNoseShape = () => {
                         const mag = this.radius + this.radius * this.noseLength;
                         this.vertices[1].x = this.position.x + Math.cos(this.angle) * mag;
@@ -970,14 +970,14 @@ const mobs = {
                 Matter.Body.setAngle(this, angle - Math.PI);
             },
             explode(mass = this.mass) {
-                if (mech.immuneCycle < mech.cycle) {
-                    mech.damage(Math.min(Math.max(0.02 * Math.sqrt(mass), 0.01), 0.35) * simulation.dmgScale);
+                if (m.immuneCycle < m.cycle) {
+                    m.damage(Math.min(Math.max(0.02 * Math.sqrt(mass), 0.01), 0.35) * simulation.dmgScale);
                     this.dropPowerUp = false;
                     this.death(); //death with no power up or body
                 }
             },
             timeLimit() {
-                if (!mech.isBodiesAsleep) {
+                if (!m.isBodiesAsleep) {
                     this.timeLeft--;
                     if (this.timeLeft < 0) {
                         this.dropPowerUp = false;
@@ -1005,11 +1005,11 @@ const mobs = {
                     if (this.shield) dmg *= 0.075
 
                     //energy and heal drain should be calculated after damage boosts
-                    if (tech.energySiphon && dmg !== Infinity && this.dropPowerUp) mech.energy += Math.min(this.health, dmg) * tech.energySiphon
+                    if (tech.energySiphon && dmg !== Infinity && this.dropPowerUp) m.energy += Math.min(this.health, dmg) * tech.energySiphon
 
                     if (tech.healthDrain && dmg !== Infinity && this.dropPowerUp) {
-                        mech.addHealth(Math.min(this.health, dmg) * tech.healthDrain)
-                        if (mech.health > mech.maxHealth) mech.health = mech.maxHealth
+                        m.addHealth(Math.min(this.health, dmg) * tech.healthDrain)
+                        if (m.health > m.maxHealth) m.health = m.maxHealth
                     }
                     dmg /= Math.sqrt(this.mass)
                     this.health -= dmg
@@ -1033,9 +1033,9 @@ const mobs = {
                 this.removeConsBB();
                 this.alive = false; //triggers mob removal in mob[i].replace(i)
                 if (this.dropPowerUp) {
-                    if (tech.isEnergyLoss) mech.energy *= 0.75;
+                    if (tech.isEnergyLoss) m.energy *= 0.75;
                     powerUps.spawnRandomPowerUp(this.position.x, this.position.y);
-                    mech.lastKillCycle = mech.cycle; //tracks the last time a kill was made, mostly used in simulation.checks()
+                    m.lastKillCycle = m.cycle; //tracks the last time a kill was made, mostly used in simulation.checks()
                     if (Math.random() < tech.sporesOnDeath) {
                         const len = Math.min(25, Math.floor(2 + this.mass * (0.5 + 0.5 * Math.random())))
                         for (let i = 0; i < len; i++) {
diff --git a/js/player.js b/js/player.js
index 9c4d0e8..c599fa7 100644
--- a/js/player.js
+++ b/js/player.js
@@ -2,7 +2,7 @@
 let player, jumpSensor, playerBody, playerHead, headSensor;
 
 // player Object Prototype *********************************************
-const mech = {
+const m = {
     spawn() {
         //load player in matter.js physic engine
         // let vector = Vertices.fromPath("0 40  50 40   50 115   0 115   30 130   20 130"); //player as a series of vertices
@@ -35,13 +35,13 @@ const mech = {
                 mask: cat.body | cat.map | cat.mob | cat.mobBullet | cat.mobShield
             },
             death() {
-                mech.death();
+                m.death();
             }
         });
-        Matter.Body.setMass(player, mech.mass);
+        Matter.Body.setMass(player, m.mass);
         World.add(engine.world, [player]);
 
-        mech.holdConstraint = Constraint.create({
+        m.holdConstraint = Constraint.create({
             //holding body constraint
             pointA: {
                 x: 0,
@@ -50,9 +50,9 @@ const mech = {
             bodyB: jumpSensor, //setting constraint to jump sensor because it has to be on something until the player picks up things
             stiffness: 0.4
         });
-        World.add(engine.world, mech.holdConstraint);
+        World.add(engine.world, m.holdConstraint);
     },
-    cycle: 300, //starts at 300 cycles instead of 0 to prevent bugs with mech.history
+    cycle: 300, //starts at 300 cycles instead of 0 to prevent bugs with m.history
     lastKillCycle: 0,
     lastHarmCycle: 0,
     width: 50,
@@ -65,8 +65,8 @@ const mech = {
         light: 100,
     },
     setFillColors() {
-        this.fillColor = `hsl(${mech.color.hue},${mech.color.sat}%,${mech.color.light}%)`
-        this.fillColorDark = `hsl(${mech.color.hue},${mech.color.sat}%,${mech.color.light-20}%)`
+        this.fillColor = `hsl(${m.color.hue},${m.color.sat}%,${m.color.light}%)`
+        this.fillColorDark = `hsl(${m.color.hue},${m.color.sat}%,${m.color.light-20}%)`
     },
     height: 42,
     yOffWhen: {
@@ -80,8 +80,8 @@ const mech = {
     Fx: 0.016, //run Force on ground //
     jumpForce: 0.42,
     setMovement() {
-        mech.Fx = 0.016 * tech.squirrelFx * tech.fastTime;
-        mech.jumpForce = 0.42 * tech.squirrelJump * tech.fastTimeJump;
+        m.Fx = 0.016 * tech.squirrelFx * tech.fastTime;
+        m.jumpForce = 0.42 * tech.squirrelJump * tech.fastTimeJump;
     },
     FxAir: 0.016, // 0.4/5/5  run Force in Air
     yOff: 70,
@@ -103,7 +103,7 @@ const mech = {
         x: 0,
         y: 0
     },
-    yPosDifference: 24.2859, //player.position.y - mech.pos.y  //24.285923217549026
+    yPosDifference: 24.2859, //player.position.y - m.pos.y  //24.285923217549026
     // yPosDifferenceCrouched: -2.7140767824453604,
     Sy: 0, //adds a smoothing effect to vertical only
     Vx: 0,
@@ -138,7 +138,7 @@ const mech = {
     history: [], //tracks the last second of player position
     resetHistory() {
         for (let i = 0; i < 600; i++) { //reset history
-            mech.history[i] = {
+            m.history[i] = {
                 position: {
                     x: player.position.x,
                     y: player.position.y,
@@ -147,23 +147,23 @@ const mech = {
                     x: player.velocity.x,
                     y: player.velocity.y
                 },
-                yOff: mech.yOff,
-                angle: mech.angle,
-                health: mech.health,
-                energy: mech.energy,
+                yOff: m.yOff,
+                angle: m.angle,
+                health: m.health,
+                energy: m.energy,
                 activeGun: b.activeGun
             }
         }
     },
     move() {
-        mech.pos.x = player.position.x;
-        mech.pos.y = playerBody.position.y - mech.yOff;
-        mech.Vx = player.velocity.x;
-        mech.Vy = player.velocity.y;
+        m.pos.x = player.position.x;
+        m.pos.y = playerBody.position.y - m.yOff;
+        m.Vx = player.velocity.x;
+        m.Vy = player.velocity.y;
 
         //tracks the last 10s of player information
-        // console.log(mech.history)
-        mech.history.splice(mech.cycle % 600, 1, {
+        // console.log(m.history)
+        m.history.splice(m.cycle % 600, 1, {
             position: {
                 x: player.position.x,
                 y: player.position.y,
@@ -172,14 +172,14 @@ const mech = {
                 x: player.velocity.x,
                 y: player.velocity.y
             },
-            yOff: mech.yOff,
-            angle: mech.angle,
-            health: mech.health,
-            energy: mech.energy,
+            yOff: m.yOff,
+            angle: m.angle,
+            health: m.health,
+            energy: m.energy,
             activeGun: b.activeGun
         });
         // const back = 59  // 59 looks at 1 second ago //29 looks at 1/2 a second ago
-        // historyIndex = (mech.cycle - back) % 600
+        // historyIndex = (m.cycle - back) % 600
     },
     transSmoothX: 0,
     transSmoothY: 0,
@@ -187,22 +187,22 @@ const mech = {
     // mouseZoom: 0,
     look() {
         //always on mouse look
-        mech.angle = Math.atan2(
-            simulation.mouseInGame.y - mech.pos.y,
-            simulation.mouseInGame.x - mech.pos.x
+        m.angle = Math.atan2(
+            simulation.mouseInGame.y - m.pos.y,
+            simulation.mouseInGame.x - m.pos.x
         );
         //smoothed mouse look translations
         const scale = 0.8;
-        mech.transSmoothX = canvas.width2 - mech.pos.x - (simulation.mouse.x - canvas.width2) * scale;
-        mech.transSmoothY = canvas.height2 - mech.pos.y - (simulation.mouse.y - canvas.height2) * scale;
+        m.transSmoothX = canvas.width2 - m.pos.x - (simulation.mouse.x - canvas.width2) * scale;
+        m.transSmoothY = canvas.height2 - m.pos.y - (simulation.mouse.y - canvas.height2) * scale;
 
-        mech.transX += (mech.transSmoothX - mech.transX) * 0.07;
-        mech.transY += (mech.transSmoothY - mech.transY) * 0.07;
+        m.transX += (m.transSmoothX - m.transX) * 0.07;
+        m.transY += (m.transSmoothY - m.transY) * 0.07;
     },
     doCrouch() {
-        if (!mech.crouch) {
-            mech.crouch = true;
-            mech.yOffGoal = mech.yOffWhen.crouch;
+        if (!m.crouch) {
+            m.crouch = true;
+            m.yOffGoal = m.yOffWhen.crouch;
             if ((playerHead.position.y - player.position.y) < 0) {
 
                 Matter.Body.setPosition(playerHead, {
@@ -228,9 +228,9 @@ const mech = {
         }
     },
     undoCrouch() {
-        if (mech.crouch) {
-            mech.crouch = false;
-            mech.yOffGoal = mech.yOffWhen.stand;
+        if (m.crouch) {
+            m.crouch = false;
+            m.yOffGoal = m.yOffWhen.stand;
             if ((playerHead.position.y - player.position.y) > 0) {
                 Matter.Body.setPosition(playerHead, {
                     x: player.position.x,
@@ -263,18 +263,18 @@ const mech = {
     buttonCD_jump: 0, //cool down for player buttons
     groundControl() {
         //check for crouch or jump
-        if (mech.crouch) {
-            if (!(input.down) && mech.checkHeadClear() && mech.hardLandCD < mech.cycle) mech.undoCrouch();
-        } else if (input.down || mech.hardLandCD > mech.cycle) {
-            mech.doCrouch(); //on ground && not crouched and pressing s or down
-        } else if ((input.up) && mech.buttonCD_jump + 20 < mech.cycle && mech.yOffWhen.stand > 23) {
-            mech.buttonCD_jump = mech.cycle; //can't jump again until 20 cycles pass
+        if (m.crouch) {
+            if (!(input.down) && m.checkHeadClear() && m.hardLandCD < m.cycle) m.undoCrouch();
+        } else if (input.down || m.hardLandCD > m.cycle) {
+            m.doCrouch(); //on ground && not crouched and pressing s or down
+        } else if ((input.up) && m.buttonCD_jump + 20 < m.cycle && m.yOffWhen.stand > 23) {
+            m.buttonCD_jump = m.cycle; //can't jump again until 20 cycles pass
             //apply a fraction of the jump force to the body the player is jumping off of
-            Matter.Body.applyForce(mech.standingOn, mech.pos, {
+            Matter.Body.applyForce(m.standingOn, m.pos, {
                 x: 0,
-                y: mech.jumpForce * 0.12 * Math.min(mech.standingOn.mass, 5)
+                y: m.jumpForce * 0.12 * Math.min(m.standingOn.mass, 5)
             });
-            player.force.y = -mech.jumpForce; //player jump force
+            player.force.y = -m.jumpForce; //player jump force
             Matter.Body.setVelocity(player, { //zero player y-velocity for consistent jumps
                 x: player.velocity.x,
                 y: 0
@@ -283,16 +283,16 @@ const mech = {
 
         if (input.left) {
             if (player.velocity.x > -2) {
-                player.force.x -= mech.Fx * 1.5
+                player.force.x -= m.Fx * 1.5
             } else {
-                player.force.x -= mech.Fx
+                player.force.x -= m.Fx
             }
             // }
         } else if (input.right) {
             if (player.velocity.x < 2) {
-                player.force.x += mech.Fx * 1.5
+                player.force.x += m.Fx * 1.5
             } else {
-                player.force.x += mech.Fx
+                player.force.x += m.Fx
             }
         } else {
             const stoppingFriction = 0.92;
@@ -303,7 +303,7 @@ const mech = {
         }
         //come to a stop if fast or if no move key is pressed
         if (player.speed > 4) {
-            const stoppingFriction = (mech.crouch) ? 0.65 : 0.89; // this controls speed when crouched
+            const stoppingFriction = (m.crouch) ? 0.65 : 0.89; // this controls speed when crouched
             Matter.Body.setVelocity(player, {
                 x: player.velocity.x * stoppingFriction,
                 y: player.velocity.y * stoppingFriction
@@ -312,7 +312,7 @@ const mech = {
     },
     airControl() {
         //check for short jumps   //moving up   //recently pressed jump  //but not pressing jump key now
-        if (mech.buttonCD_jump + 60 > mech.cycle && !(input.up) && mech.Vy < 0) {
+        if (m.buttonCD_jump + 60 > m.cycle && !(input.up) && m.Vy < 0) {
             Matter.Body.setVelocity(player, {
                 //reduce player y-velocity every cycle
                 x: player.velocity.x,
@@ -321,9 +321,9 @@ const mech = {
         }
 
         if (input.left) {
-            if (player.velocity.x > -mech.airSpeedLimit / player.mass / player.mass) player.force.x -= mech.FxAir; // move player   left / a
+            if (player.velocity.x > -m.airSpeedLimit / player.mass / player.mass) player.force.x -= m.FxAir; // move player   left / a
         } else if (input.right) {
-            if (player.velocity.x < mech.airSpeedLimit / player.mass / player.mass) player.force.x += mech.FxAir; //move player  right / d
+            if (player.velocity.x < m.airSpeedLimit / player.mass / player.mass) player.force.x += m.FxAir; //move player  right / d
         }
     },
     alive: false,
@@ -364,13 +364,13 @@ const mech = {
             }
 
             function randomizeField() {
-                mech.setField(Math.ceil(Math.random() * (mech.fieldUpgrades.length - 1)))
+                m.setField(Math.ceil(Math.random() * (m.fieldUpgrades.length - 1)))
             }
 
             function randomizeHealth() {
-                mech.health = 0.7 + Math.random()
-                if (mech.health > 1) mech.health = 1;
-                mech.displayHealth();
+                m.health = 0.7 + Math.random()
+                if (m.health > 1) m.health = 1;
+                m.displayHealth();
             }
 
             function randomizeGuns() {
@@ -435,11 +435,11 @@ const mech = {
                 simulation.makeTextLog("simulation.amplitude <span class='color-symbol'>=</span> null");
             }, 6 * swapPeriod);
 
-        } else if (mech.alive) { //normal death code here
-            mech.alive = false;
+        } else if (m.alive) { //normal death code here
+            m.alive = false;
             simulation.paused = true;
-            mech.health = 0;
-            mech.displayHealth();
+            m.health = 0;
+            m.displayHealth();
             document.getElementById("text-log").style.opacity = 0; //fade out any active text logs
             document.getElementById("fade-out").style.opacity = 1; //slowly fades out
             // build.shareURL(false)
@@ -453,14 +453,14 @@ const mech = {
     health: 0,
     maxHealth: 1, //set in simulation.reset()
     drawHealth() {
-        if (mech.health < 1) {
+        if (m.health < 1) {
             ctx.fillStyle = "rgba(100, 100, 100, 0.5)";
-            ctx.fillRect(mech.pos.x - mech.radius, mech.pos.y - 50, 60, 10);
+            ctx.fillRect(m.pos.x - m.radius, m.pos.y - 50, 60, 10);
             ctx.fillStyle = "#f00";
             ctx.fillRect(
-                mech.pos.x - mech.radius,
-                mech.pos.y - 50,
-                60 * mech.health,
+                m.pos.x - m.radius,
+                m.pos.y - 50,
+                60 * m.health,
                 10
             );
         }
@@ -468,9 +468,9 @@ const mech = {
     displayHealth() {
         id = document.getElementById("health");
         // health display follows a x^1.5 rule to make it seem like the player has lower health, this makes the player feel more excitement
-        id.style.width = Math.floor(300 * mech.maxHealth * Math.pow(mech.health / mech.maxHealth, 1.4)) + "px";
+        id.style.width = Math.floor(300 * m.maxHealth * Math.pow(m.health / m.maxHealth, 1.4)) + "px";
         //css animation blink if health is low
-        if (mech.health < 0.3) {
+        if (m.health < 0.3) {
             id.classList.add("low-health");
         } else {
             id.classList.remove("low-health");
@@ -478,45 +478,45 @@ const mech = {
     },
     addHealth(heal) {
         if (!tech.isEnergyHealth) {
-            mech.health += heal * simulation.healScale;
-            if (mech.health > mech.maxHealth) mech.health = mech.maxHealth;
-            mech.displayHealth();
+            m.health += heal * simulation.healScale;
+            if (m.health > m.maxHealth) m.health = m.maxHealth;
+            m.displayHealth();
         }
     },
     baseHealth: 1,
     setMaxHealth() {
-        mech.maxHealth = mech.baseHealth + tech.bonusHealth + tech.armorFromPowerUps
-        document.getElementById("health-bg").style.width = `${Math.floor(300*mech.maxHealth)}px`
-        simulation.makeTextLog(`<span class='color-var'>mech</span>.<span class='color-h'>maxHealth</span> <span class='color-symbol'>=</span> ${mech.maxHealth.toFixed(2)}`)
-        if (mech.health > mech.maxHealth) mech.health = mech.maxHealth;
-        mech.displayHealth();
+        m.maxHealth = m.baseHealth + tech.bonusHealth + tech.armorFromPowerUps
+        document.getElementById("health-bg").style.width = `${Math.floor(300*m.maxHealth)}px`
+        simulation.makeTextLog(`<span class='color-var'>m</span>.<span class='color-h'>maxHealth</span> <span class='color-symbol'>=</span> ${m.maxHealth.toFixed(2)}`)
+        if (m.health > m.maxHealth) m.health = m.maxHealth;
+        m.displayHealth();
     },
 
     defaultFPSCycle: 0, //tracks when to return to normal fps
     immuneCycle: 0, //used in engine
     harmReduction() {
         let dmg = 1
-        dmg *= mech.fieldHarmReduction
+        dmg *= m.fieldHarmReduction
         if (tech.squirrelFx !== 1) dmg *= 1 + (tech.squirrelFx - 1) / 5 //cause more damage
         if (tech.isSpeedHarm) dmg *= 1 - Math.min(player.speed * 0.0185, 0.55)
         if (tech.isSlowFPS) dmg *= 0.8
         if (tech.isPiezo) dmg *= 0.85
-        if (tech.isHarmReduce && mech.fieldUpgrades[mech.fieldMode].name === "negative mass field" && mech.isFieldActive) dmg *= 0.6
+        if (tech.isHarmReduce && m.fieldUpgrades[m.fieldMode].name === "negative mass field" && m.isFieldActive) dmg *= 0.6
         if (tech.isBotArmor) dmg *= 0.97 ** tech.totalBots()
-        if (tech.isHarmArmor && mech.lastHarmCycle + 600 > mech.cycle) dmg *= 0.33;
-        if (tech.isNoFireDefense && mech.cycle > mech.fireCDcycle + 120) dmg *= 0.6
+        if (tech.isHarmArmor && m.lastHarmCycle + 600 > m.cycle) dmg *= 0.33;
+        if (tech.isNoFireDefense && m.cycle > m.fireCDcycle + 120) dmg *= 0.6
         if (tech.energyRegen === 0) dmg *= 0.4
-        if (tech.isTurret && mech.crouch) dmg *= 0.5;
+        if (tech.isTurret && m.crouch) dmg *= 0.5;
         if (tech.isFireMoveLock && input.fire) dmg *= 0.4;
         if (tech.isEntanglement && b.inventory[0] === b.activeGun) {
             for (let i = 0, len = b.inventory.length; i < len; i++) dmg *= 0.87 // 1 - 0.15
         }
         return dmg
     },
-    rewind(steps) { // mech.rewind(Math.floor(Math.min(599, 137 * mech.energy)))
+    rewind(steps) { // m.rewind(Math.floor(Math.min(599, 137 * m.energy)))
         if (tech.isRewindGrenade) {
             for (let i = 1, len = Math.floor(2 + steps / 40); i < len; i++) {
-                b.grenade(Vector.add(mech.pos, { x: 10 * (Math.random() - 0.5), y: 10 * (Math.random() - 0.5) }), -i * Math.PI / len) //fire different angles for each grenade
+                b.grenade(Vector.add(m.pos, { x: 10 * (Math.random() - 0.5), y: 10 * (Math.random() - 0.5) }), -i * Math.PI / len) //fire different angles for each grenade
                 const who = bullet[bullet.length - 1]
                 if (tech.isVacuumBomb) {
                     Matter.Body.setVelocity(who, {
@@ -539,14 +539,14 @@ const mech = {
                 }
             }
         }
-        let history = mech.history[(mech.cycle - steps) % 600]
+        let history = m.history[(m.cycle - steps) % 600]
         Matter.Body.setPosition(player, history.position);
         Matter.Body.setVelocity(player, { x: history.velocity.x, y: history.velocity.y });
-        mech.yOff = history.yOff
-        if (mech.yOff < 48) {
-            mech.doCrouch()
+        m.yOff = history.yOff
+        if (m.yOff < 48) {
+            m.doCrouch()
         } else {
-            mech.undoCrouch()
+            m.undoCrouch()
         }
 
         // b.activeGun = history.activeGun
@@ -569,12 +569,12 @@ const mech = {
                 });
             }
         }
-        mech.energy = Math.max(mech.energy - steps / 136, 0.01)
-        mech.immuneCycle = mech.cycle + 30; //player is immune to collision damage for 30 cycles
+        m.energy = Math.max(m.energy - steps / 136, 0.01)
+        m.immuneCycle = m.cycle + 30; //player is immune to collision damage for 30 cycles
 
         let isDrawPlayer = true
         const shortPause = function() {
-            if (mech.defaultFPSCycle < mech.cycle) { //back to default values
+            if (m.defaultFPSCycle < m.cycle) { //back to default values
                 simulation.fpsCap = simulation.fpsCapDefault
                 simulation.fpsInterval = 1000 / simulation.fpsCap;
                 document.getElementById("dmg").style.transition = "opacity 1s";
@@ -586,28 +586,28 @@ const mech = {
                     ctx.save();
                     ctx.translate(canvas.width2, canvas.height2); //center
                     ctx.scale(simulation.zoom / simulation.edgeZoomOutSmooth, simulation.zoom / simulation.edgeZoomOutSmooth); //zoom in once centered
-                    ctx.translate(-canvas.width2 + mech.transX, -canvas.height2 + mech.transY); //translate
+                    ctx.translate(-canvas.width2 + m.transX, -canvas.height2 + m.transY); //translate
                     for (let i = 1; i < steps; i++) {
-                        history = mech.history[(mech.cycle - i) % 600]
-                        mech.pos.x = history.position.x
-                        mech.pos.y = history.position.y + mech.yPosDifference - history.yOff
-                        mech.yOff = history.yOff
-                        mech.draw();
+                        history = m.history[(m.cycle - i) % 600]
+                        m.pos.x = history.position.x
+                        m.pos.y = history.position.y + m.yPosDifference - history.yOff
+                        m.yOff = history.yOff
+                        m.draw();
                     }
                     ctx.restore();
-                    mech.resetHistory()
+                    m.resetHistory()
                 }
             }
         };
 
-        if (mech.defaultFPSCycle < mech.cycle) requestAnimationFrame(shortPause);
+        if (m.defaultFPSCycle < m.cycle) requestAnimationFrame(shortPause);
         simulation.fpsCap = 3 //1 is longest pause, 4 is standard
         simulation.fpsInterval = 1000 / simulation.fpsCap;
-        mech.defaultFPSCycle = mech.cycle
+        m.defaultFPSCycle = m.cycle
         if (tech.isRewindBot) {
             const len = steps * 0.042 * tech.isRewindBot
             for (let i = 0; i < len; i++) {
-                const where = mech.history[Math.abs(mech.cycle - i * 40) % 600].position //spread out spawn locations along past history
+                const where = m.history[Math.abs(m.cycle - i * 40) % 600].position //spread out spawn locations along past history
                 b.randomBot({
                     x: where.x + 100 * (Math.random() - 0.5),
                     y: where.y + 100 * (Math.random() - 0.5)
@@ -617,13 +617,13 @@ const mech = {
         }
     },
     damage(dmg) {
-        if (tech.isRewindAvoidDeath && mech.energy > 0.66) {
-            const steps = Math.floor(Math.min(299, 137 * mech.energy))
-            simulation.makeTextLog(`<span class='color-var'>mech</span>.rewind(${steps})`)
-            mech.rewind(steps)
+        if (tech.isRewindAvoidDeath && m.energy > 0.66) {
+            const steps = Math.floor(Math.min(299, 137 * m.energy))
+            simulation.makeTextLog(`<span class='color-var'>m</span>.rewind(${steps})`)
+            m.rewind(steps)
             return
         }
-        mech.lastHarmCycle = mech.cycle
+        m.lastHarmCycle = m.cycle
         if (tech.isDroneOnDamage) { //chance to build a drone on damage  from tech
             const len = Math.min((dmg - 0.06 * Math.random()) * 40, 40)
             for (let i = 0; i < len; i++) {
@@ -632,17 +632,17 @@ const mech = {
         }
 
         if (tech.isEnergyHealth) {
-            mech.energy -= dmg;
-            if (mech.energy < 0 || isNaN(mech.energy)) { //taking deadly damage
+            m.energy -= dmg;
+            if (m.energy < 0 || isNaN(m.energy)) { //taking deadly damage
                 if (tech.isDeathAvoid && powerUps.research.count && !tech.isDeathAvoidedThisLevel) {
                     tech.isDeathAvoidedThisLevel = true
                     powerUps.research.changeRerolls(-1)
-                    simulation.makeTextLog(`<span class='color-var'>mech</span>.<span class='color-r'>research</span><span class='color-symbol'>--</span><br>${powerUps.research.count}`)
+                    simulation.makeTextLog(`<span class='color-var'>m</span>.<span class='color-r'>research</span><span class='color-symbol'>--</span><br>${powerUps.research.count}`)
                     for (let i = 0; i < 6; i++) {
-                        powerUps.spawn(mech.pos.x, mech.pos.y, "heal", false);
+                        powerUps.spawn(m.pos.x, m.pos.y, "heal", false);
                     }
-                    mech.energy = mech.maxEnergy
-                    mech.immuneCycle = mech.cycle + 360 //disable this.immuneCycle bonus seconds
+                    m.energy = m.maxEnergy
+                    m.immuneCycle = m.cycle + 360 //disable this.immuneCycle bonus seconds
                     simulation.wipe = function() { //set wipe to have trails
                         ctx.fillStyle = "rgba(255,255,255,0.03)";
                         ctx.fillRect(0, 0, canvas.width, canvas.height);
@@ -654,24 +654,24 @@ const mech = {
                     }, 3000);
                     return;
                 } else { //death
-                    mech.health = 0;
-                    mech.energy = 0;
-                    mech.death();
+                    m.health = 0;
+                    m.energy = 0;
+                    m.death();
                     return;
                 }
             }
         } else {
-            dmg *= mech.harmReduction()
-            mech.health -= dmg;
-            if (mech.health < 0 || isNaN(mech.health)) {
+            dmg *= m.harmReduction()
+            m.health -= dmg;
+            if (m.health < 0 || isNaN(m.health)) {
                 if (tech.isDeathAvoid && powerUps.research.count > 0 && !tech.isDeathAvoidedThisLevel) { //&& Math.random() < 0.5
                     tech.isDeathAvoidedThisLevel = true
-                    mech.health = 0.05
+                    m.health = 0.05
                     powerUps.research.changeRerolls(-1)
-                    simulation.makeTextLog(`<span class='color-var'>mech</span>.<span class='color-r'>research</span><span class='color-symbol'>--</span>
+                    simulation.makeTextLog(`<span class='color-var'>m</span>.<span class='color-r'>research</span><span class='color-symbol'>--</span>
                     <br>${powerUps.research.count}`)
-                    for (let i = 0; i < 6; i++) powerUps.spawn(mech.pos.x + 10 * Math.random(), mech.pos.y + 10 * Math.random(), "heal", false);
-                    mech.immuneCycle = mech.cycle + 360 //disable this.immuneCycle bonus seconds
+                    for (let i = 0; i < 6; i++) powerUps.spawn(m.pos.x + 10 * Math.random(), m.pos.y + 10 * Math.random(), "heal", false);
+                    m.immuneCycle = m.cycle + 360 //disable this.immuneCycle bonus seconds
                     simulation.wipe = function() { //set wipe to have trails
                         ctx.fillStyle = "rgba(255,255,255,0.03)";
                         ctx.fillRect(0, 0, canvas.width, canvas.height);
@@ -682,19 +682,19 @@ const mech = {
                         }
                     }, 3000);
                 } else {
-                    mech.health = 0;
-                    mech.death();
+                    m.health = 0;
+                    m.death();
                     return;
                 }
             }
-            mech.displayHealth();
+            m.displayHealth();
             document.getElementById("dmg").style.transition = "opacity 0s";
             document.getElementById("dmg").style.opacity = 0.1 + Math.min(0.6, dmg * 4);
         }
 
-        if (dmg > 0.06 / mech.holdingMassScale) mech.drop(); //drop block if holding
+        if (dmg > 0.06 / m.holdingMassScale) m.drop(); //drop block if holding
         const normalFPS = function() {
-            if (mech.defaultFPSCycle < mech.cycle) { //back to default values
+            if (m.defaultFPSCycle < m.cycle) { //back to default values
                 simulation.fpsCap = simulation.fpsCapDefault
                 simulation.fpsInterval = 1000 / simulation.fpsCap;
                 document.getElementById("dmg").style.transition = "opacity 1s";
@@ -704,12 +704,12 @@ const mech = {
             }
         };
 
-        if (mech.defaultFPSCycle < mech.cycle) requestAnimationFrame(normalFPS);
+        if (m.defaultFPSCycle < m.cycle) requestAnimationFrame(normalFPS);
         if (tech.isSlowFPS) { // slow game 
             simulation.fpsCap = 30 //new fps
             simulation.fpsInterval = 1000 / simulation.fpsCap;
             //how long to wait to return to normal fps
-            mech.defaultFPSCycle = mech.cycle + 20 + Math.min(90, Math.floor(200 * dmg))
+            m.defaultFPSCycle = m.cycle + 20 + Math.min(90, Math.floor(200 * dmg))
             if (tech.isHarmFreeze) { //freeze all mobs
                 for (let i = 0, len = mob.length; i < len; i++) {
                     mobs.statusSlow(mob[i], 300)
@@ -723,7 +723,7 @@ const mech = {
                 simulation.fpsCap = simulation.fpsCapDefault
                 simulation.fpsInterval = 1000 / simulation.fpsCap;
             }
-            mech.defaultFPSCycle = mech.cycle
+            m.defaultFPSCycle = m.cycle
         }
         // if (!noTransition) {
         //   document.getElementById("health").style.transition = "width 0s ease-out"
@@ -736,84 +736,84 @@ const mech = {
     },
     buttonCD: 0, //cool down for player buttons
     drawLeg(stroke) {
-        // if (simulation.mouseInGame.x > mech.pos.x) {
-        if (mech.angle > -Math.PI / 2 && mech.angle < Math.PI / 2) {
-            mech.flipLegs = 1;
+        // if (simulation.mouseInGame.x > m.pos.x) {
+        if (m.angle > -Math.PI / 2 && m.angle < Math.PI / 2) {
+            m.flipLegs = 1;
         } else {
-            mech.flipLegs = -1;
+            m.flipLegs = -1;
         }
         ctx.save();
-        ctx.scale(mech.flipLegs, 1); //leg lines
+        ctx.scale(m.flipLegs, 1); //leg lines
         ctx.beginPath();
-        ctx.moveTo(mech.hip.x, mech.hip.y);
-        ctx.lineTo(mech.knee.x, mech.knee.y);
-        ctx.lineTo(mech.foot.x, mech.foot.y);
+        ctx.moveTo(m.hip.x, m.hip.y);
+        ctx.lineTo(m.knee.x, m.knee.y);
+        ctx.lineTo(m.foot.x, m.foot.y);
         ctx.strokeStyle = stroke;
         ctx.lineWidth = 7;
         ctx.stroke();
 
         //toe lines
         ctx.beginPath();
-        ctx.moveTo(mech.foot.x, mech.foot.y);
-        ctx.lineTo(mech.foot.x - 15, mech.foot.y + 5);
-        ctx.moveTo(mech.foot.x, mech.foot.y);
-        ctx.lineTo(mech.foot.x + 15, mech.foot.y + 5);
+        ctx.moveTo(m.foot.x, m.foot.y);
+        ctx.lineTo(m.foot.x - 15, m.foot.y + 5);
+        ctx.moveTo(m.foot.x, m.foot.y);
+        ctx.lineTo(m.foot.x + 15, m.foot.y + 5);
         ctx.lineWidth = 4;
         ctx.stroke();
 
         //hip joint
         ctx.beginPath();
-        ctx.arc(mech.hip.x, mech.hip.y, 11, 0, 2 * Math.PI);
+        ctx.arc(m.hip.x, m.hip.y, 11, 0, 2 * Math.PI);
         //knee joint
-        ctx.moveTo(mech.knee.x + 7, mech.knee.y);
-        ctx.arc(mech.knee.x, mech.knee.y, 7, 0, 2 * Math.PI);
+        ctx.moveTo(m.knee.x + 7, m.knee.y);
+        ctx.arc(m.knee.x, m.knee.y, 7, 0, 2 * Math.PI);
         //foot joint
-        ctx.moveTo(mech.foot.x + 6, mech.foot.y);
-        ctx.arc(mech.foot.x, mech.foot.y, 6, 0, 2 * Math.PI);
-        ctx.fillStyle = mech.fillColor;
+        ctx.moveTo(m.foot.x + 6, m.foot.y);
+        ctx.arc(m.foot.x, m.foot.y, 6, 0, 2 * Math.PI);
+        ctx.fillStyle = m.fillColor;
         ctx.fill();
         ctx.lineWidth = 2;
         ctx.stroke();
         ctx.restore();
     },
     calcLeg(cycle_offset, offset) {
-        mech.hip.x = 12 + offset;
-        mech.hip.y = 24 + offset;
-        //stepSize goes to zero if Vx is zero or not on ground (make mech transition cleaner)
-        mech.stepSize = 0.8 * mech.stepSize + 0.2 * (7 * Math.sqrt(Math.min(9, Math.abs(mech.Vx))) * mech.onGround);
+        m.hip.x = 12 + offset;
+        m.hip.y = 24 + offset;
+        //stepSize goes to zero if Vx is zero or not on ground (make m transition cleaner)
+        m.stepSize = 0.8 * m.stepSize + 0.2 * (7 * Math.sqrt(Math.min(9, Math.abs(m.Vx))) * m.onGround);
         //changes to stepsize are smoothed by adding only a percent of the new value each cycle
-        const stepAngle = 0.034 * mech.walk_cycle + cycle_offset;
-        mech.foot.x = 2.2 * mech.stepSize * Math.cos(stepAngle) + offset;
-        mech.foot.y = offset + 1.2 * mech.stepSize * Math.sin(stepAngle) + mech.yOff + mech.height;
-        const Ymax = mech.yOff + mech.height;
-        if (mech.foot.y > Ymax) mech.foot.y = Ymax;
+        const stepAngle = 0.034 * m.walk_cycle + cycle_offset;
+        m.foot.x = 2.2 * m.stepSize * Math.cos(stepAngle) + offset;
+        m.foot.y = offset + 1.2 * m.stepSize * Math.sin(stepAngle) + m.yOff + m.height;
+        const Ymax = m.yOff + m.height;
+        if (m.foot.y > Ymax) m.foot.y = Ymax;
 
         //calculate knee position as intersection of circle from hip and foot
-        const d = Math.sqrt((mech.hip.x - mech.foot.x) * (mech.hip.x - mech.foot.x) + (mech.hip.y - mech.foot.y) * (mech.hip.y - mech.foot.y));
-        const l = (mech.legLength1 * mech.legLength1 - mech.legLength2 * mech.legLength2 + d * d) / (2 * d);
-        const h = Math.sqrt(mech.legLength1 * mech.legLength1 - l * l);
-        mech.knee.x = (l / d) * (mech.foot.x - mech.hip.x) - (h / d) * (mech.foot.y - mech.hip.y) + mech.hip.x + offset;
-        mech.knee.y = (l / d) * (mech.foot.y - mech.hip.y) + (h / d) * (mech.foot.x - mech.hip.x) + mech.hip.y;
+        const d = Math.sqrt((m.hip.x - m.foot.x) * (m.hip.x - m.foot.x) + (m.hip.y - m.foot.y) * (m.hip.y - m.foot.y));
+        const l = (m.legLength1 * m.legLength1 - m.legLength2 * m.legLength2 + d * d) / (2 * d);
+        const h = Math.sqrt(m.legLength1 * m.legLength1 - l * l);
+        m.knee.x = (l / d) * (m.foot.x - m.hip.x) - (h / d) * (m.foot.y - m.hip.y) + m.hip.x + offset;
+        m.knee.y = (l / d) * (m.foot.y - m.hip.y) + (h / d) * (m.foot.x - m.hip.x) + m.hip.y;
     },
     draw() {
-        ctx.fillStyle = mech.fillColor;
-        mech.walk_cycle += mech.flipLegs * mech.Vx;
+        ctx.fillStyle = m.fillColor;
+        m.walk_cycle += m.flipLegs * m.Vx;
 
         //draw body
         ctx.save();
-        ctx.globalAlpha = (mech.immuneCycle < mech.cycle) ? 1 : 0.5
-        ctx.translate(mech.pos.x, mech.pos.y);
-        mech.calcLeg(Math.PI, -3);
-        mech.drawLeg("#4a4a4a");
-        mech.calcLeg(0, 0);
-        mech.drawLeg("#333");
-        ctx.rotate(mech.angle);
+        ctx.globalAlpha = (m.immuneCycle < m.cycle) ? 1 : 0.5
+        ctx.translate(m.pos.x, m.pos.y);
+        m.calcLeg(Math.PI, -3);
+        m.drawLeg("#4a4a4a");
+        m.calcLeg(0, 0);
+        m.drawLeg("#333");
+        ctx.rotate(m.angle);
 
         ctx.beginPath();
         ctx.arc(0, 0, 30, 0, 2 * Math.PI);
         let grd = ctx.createLinearGradient(-30, 0, 30, 0);
-        grd.addColorStop(0, mech.fillColorDark);
-        grd.addColorStop(1, mech.fillColor);
+        grd.addColorStop(0, m.fillColorDark);
+        grd.addColorStop(1, m.fillColor);
         ctx.fillStyle = grd;
         ctx.fill();
         ctx.arc(15, 0, 4, 0, 2 * Math.PI);
@@ -825,7 +825,7 @@ const mech = {
         // ctx.fillStyle = '#0cf';
         // ctx.fill()
         ctx.restore();
-        mech.yOff = mech.yOff * 0.85 + mech.yOffGoal * 0.15; //smoothly move leg height towards height goal
+        m.yOff = m.yOff * 0.85 + m.yOffGoal * 0.15; //smoothly move leg height towards height goal
     },
     // *********************************************
     // **************** fields *********************
@@ -871,34 +871,34 @@ const mech = {
     fieldArc: 0,
     fieldThreshold: 0,
     calculateFieldThreshold() {
-        mech.fieldThreshold = Math.cos(mech.fieldArc * Math.PI)
+        m.fieldThreshold = Math.cos(m.fieldArc * Math.PI)
     },
     setHoldDefaults() {
-        if (mech.energy < mech.maxEnergy) mech.energy = mech.maxEnergy;
-        mech.fieldRegen = tech.energyRegen; //0.001
-        mech.fieldMeterColor = "#0cf"
-        mech.fieldShieldingScale = 1;
-        mech.fieldBlockCD = 10;
-        mech.fieldHarmReduction = 1;
-        mech.fieldDamage = 1
-        mech.duplicateChance = 0
+        if (m.energy < m.maxEnergy) m.energy = m.maxEnergy;
+        m.fieldRegen = tech.energyRegen; //0.001
+        m.fieldMeterColor = "#0cf"
+        m.fieldShieldingScale = 1;
+        m.fieldBlockCD = 10;
+        m.fieldHarmReduction = 1;
+        m.fieldDamage = 1
+        m.duplicateChance = 0
         if (tech.duplicationChance() === 0) simulation.draw.powerUp = simulation.draw.powerUpNormal
-        mech.grabPowerUpRange2 = 156000;
-        mech.fieldRange = 155;
-        mech.fieldFire = false;
-        mech.fieldCDcycle = 0;
-        mech.isCloak = false;
+        m.grabPowerUpRange2 = 156000;
+        m.fieldRange = 155;
+        m.fieldFire = false;
+        m.fieldCDcycle = 0;
+        m.isCloak = false;
         player.collisionFilter.mask = cat.body | cat.map | cat.mob | cat.mobBullet | cat.mobShield
-        mech.airSpeedLimit = 125
-        mech.drop();
-        mech.holdingMassScale = 0.5;
-        mech.isFieldActive = false; //only being used by negative mass field
-        mech.fieldArc = 0.2; //run calculateFieldThreshold after setting fieldArc, used for powerUp grab and mobPush with lookingAt(mob)
-        mech.calculateFieldThreshold(); //run calculateFieldThreshold after setting fieldArc, used for powerUp grab and mobPush with lookingAt(mob)
-        mech.isBodiesAsleep = true;
-        mech.wakeCheck();
-        mech.setMaxEnergy();
-        mech.hole = {
+        m.airSpeedLimit = 125
+        m.drop();
+        m.holdingMassScale = 0.5;
+        m.isFieldActive = false; //only being used by negative mass field
+        m.fieldArc = 0.2; //run calculateFieldThreshold after setting fieldArc, used for powerUp grab and mobPush with lookingAt(mob)
+        m.calculateFieldThreshold(); //run calculateFieldThreshold after setting fieldArc, used for powerUp grab and mobPush with lookingAt(mob)
+        m.isBodiesAsleep = true;
+        m.wakeCheck();
+        m.setMaxEnergy();
+        m.hole = {
             isOn: false,
             isReady: true,
             pos1: {
@@ -912,68 +912,68 @@ const mech = {
         }
     },
     setMaxEnergy() {
-        mech.maxEnergy = (tech.isMaxEnergyTech ? 0.5 : 1) + tech.bonusEnergy + tech.healMaxEnergyBonus
-        simulation.makeTextLog(`<span class='color-var'>mech</span>.<span class='color-f'>maxEnergy</span> <span class='color-symbol'>=</span> ${(mech.maxEnergy.toFixed(2))}`)
+        m.maxEnergy = (tech.isMaxEnergyTech ? 0.5 : 1) + tech.bonusEnergy + tech.healMaxEnergyBonus
+        simulation.makeTextLog(`<span class='color-var'>m</span>.<span class='color-f'>maxEnergy</span> <span class='color-symbol'>=</span> ${(m.maxEnergy.toFixed(2))}`)
     },
     fieldMeterColor: "#0cf",
     drawFieldMeter(bgColor = "rgba(0, 0, 0, 0.4)", range = 60) {
-        if (mech.energy < mech.maxEnergy) {
-            mech.energy += mech.fieldRegen;
-            if (mech.energy < 0) mech.energy = 0
+        if (m.energy < m.maxEnergy) {
+            m.energy += m.fieldRegen;
+            if (m.energy < 0) m.energy = 0
             ctx.fillStyle = bgColor;
-            const xOff = mech.pos.x - mech.radius * mech.maxEnergy
-            const yOff = mech.pos.y - 50
-            ctx.fillRect(xOff, yOff, range * mech.maxEnergy, 10);
-            ctx.fillStyle = mech.fieldMeterColor;
-            ctx.fillRect(xOff, yOff, range * mech.energy, 10);
-        } else if (mech.energy > mech.maxEnergy + 0.05) {
+            const xOff = m.pos.x - m.radius * m.maxEnergy
+            const yOff = m.pos.y - 50
+            ctx.fillRect(xOff, yOff, range * m.maxEnergy, 10);
+            ctx.fillStyle = m.fieldMeterColor;
+            ctx.fillRect(xOff, yOff, range * m.energy, 10);
+        } else if (m.energy > m.maxEnergy + 0.05) {
             ctx.fillStyle = bgColor;
-            const xOff = mech.pos.x - mech.radius * mech.energy
-            const yOff = mech.pos.y - 50
-            // ctx.fillRect(xOff, yOff, range * mech.maxEnergy, 10);
-            ctx.fillStyle = mech.fieldMeterColor;
-            ctx.fillRect(xOff, yOff, range * mech.energy, 10);
+            const xOff = m.pos.x - m.radius * m.energy
+            const yOff = m.pos.y - 50
+            // ctx.fillRect(xOff, yOff, range * m.maxEnergy, 10);
+            ctx.fillStyle = m.fieldMeterColor;
+            ctx.fillRect(xOff, yOff, range * m.energy, 10);
         }
         // else {
-        //   mech.energy = mech.maxEnergy
+        //   m.energy = m.maxEnergy
         // }
     },
     lookingAt(who) {
         //calculate a vector from body to player and make it length 1
-        const diff = Vector.normalise(Vector.sub(who.position, mech.pos));
+        const diff = Vector.normalise(Vector.sub(who.position, m.pos));
         //make a vector for the player's direction of length 1
         const dir = {
-            x: Math.cos(mech.angle),
-            y: Math.sin(mech.angle)
+            x: Math.cos(m.angle),
+            y: Math.sin(m.angle)
         };
         //the dot product of diff and dir will return how much over lap between the vectors
         // console.log(Vector.dot(dir, diff))
-        if (Vector.dot(dir, diff) > mech.fieldThreshold) {
+        if (Vector.dot(dir, diff) > m.fieldThreshold) {
             return true;
         }
         return false;
     },
     drop() {
-        if (mech.isHolding) {
-            mech.fieldCDcycle = mech.cycle + 15;
-            mech.isHolding = false;
-            mech.throwCharge = 0;
-            mech.definePlayerMass()
-            if (mech.holdingTarget) {
-                mech.holdingTarget.collisionFilter.category = cat.body;
-                mech.holdingTarget.collisionFilter.mask = cat.player | cat.map | cat.body | cat.bullet | cat.mob | cat.mobBullet
-                mech.holdingTarget = null;
+        if (m.isHolding) {
+            m.fieldCDcycle = m.cycle + 15;
+            m.isHolding = false;
+            m.throwCharge = 0;
+            m.definePlayerMass()
+            if (m.holdingTarget) {
+                m.holdingTarget.collisionFilter.category = cat.body;
+                m.holdingTarget.collisionFilter.mask = cat.player | cat.map | cat.body | cat.bullet | cat.mob | cat.mobBullet
+                m.holdingTarget = null;
             }
         }
     },
-    definePlayerMass(mass = mech.defaultMass) {
+    definePlayerMass(mass = m.defaultMass) {
         Matter.Body.setMass(player, mass);
         //reduce air and ground move forces
-        mech.Fx = 0.08 / mass * tech.squirrelFx //base player mass is 5
-        mech.FxAir = 0.4 / mass / mass //base player mass is 5
+        m.Fx = 0.08 / mass * tech.squirrelFx //base player mass is 5
+        m.FxAir = 0.4 / mass / mass //base player mass is 5
         //make player stand a bit lower when holding heavy masses
-        mech.yOffWhen.stand = Math.max(mech.yOffWhen.crouch, Math.min(49, 49 - (mass - 5) * 6))
-        if (mech.onGround && !mech.crouch) mech.yOffGoal = mech.yOffWhen.stand;
+        m.yOffWhen.stand = Math.max(m.yOffWhen.crouch, Math.min(49, 49 - (mass - 5) * 6))
+        if (m.onGround && !m.crouch) m.yOffGoal = m.yOffWhen.stand;
     },
     drawHold(target, stroke = true) {
         if (target) {
@@ -984,8 +984,8 @@ const mech = {
             ctx.strokeStyle = "#000";
             ctx.beginPath();
             ctx.moveTo(
-                mech.pos.x + eye * Math.cos(mech.angle),
-                mech.pos.y + eye * Math.sin(mech.angle)
+                m.pos.x + eye * Math.cos(m.angle),
+                m.pos.y + eye * Math.sin(m.angle)
             );
             ctx.lineTo(target.vertices[len].x, target.vertices[len].y);
             ctx.lineTo(target.vertices[0].x, target.vertices[0].y);
@@ -994,8 +994,8 @@ const mech = {
             for (let i = 0; i < len; i++) {
                 ctx.beginPath();
                 ctx.moveTo(
-                    mech.pos.x + eye * Math.cos(mech.angle),
-                    mech.pos.y + eye * Math.sin(mech.angle)
+                    m.pos.x + eye * Math.cos(m.angle),
+                    m.pos.y + eye * Math.sin(m.angle)
                 );
                 ctx.lineTo(target.vertices[i].x, target.vertices[i].y);
                 ctx.lineTo(target.vertices[i + 1].x, target.vertices[i + 1].y);
@@ -1005,147 +1005,147 @@ const mech = {
         }
     },
     holding() {
-        if (mech.fireCDcycle < mech.cycle) mech.fireCDcycle = mech.cycle - 1
-        if (mech.holdingTarget) {
-            mech.energy -= mech.fieldRegen;
-            if (mech.energy < 0) mech.energy = 0;
-            Matter.Body.setPosition(mech.holdingTarget, {
-                x: mech.pos.x + 70 * Math.cos(mech.angle),
-                y: mech.pos.y + 70 * Math.sin(mech.angle)
+        if (m.fireCDcycle < m.cycle) m.fireCDcycle = m.cycle - 1
+        if (m.holdingTarget) {
+            m.energy -= m.fieldRegen;
+            if (m.energy < 0) m.energy = 0;
+            Matter.Body.setPosition(m.holdingTarget, {
+                x: m.pos.x + 70 * Math.cos(m.angle),
+                y: m.pos.y + 70 * Math.sin(m.angle)
             });
-            Matter.Body.setVelocity(mech.holdingTarget, player.velocity);
-            Matter.Body.rotate(mech.holdingTarget, 0.01 / mech.holdingTarget.mass); //gently spin the block
+            Matter.Body.setVelocity(m.holdingTarget, player.velocity);
+            Matter.Body.rotate(m.holdingTarget, 0.01 / m.holdingTarget.mass); //gently spin the block
         } else {
-            mech.isHolding = false
+            m.isHolding = false
         }
     },
     throwBlock() {
-        if (mech.holdingTarget) {
+        if (m.holdingTarget) {
             if (input.field) {
-                if (mech.energy > 0.001) {
-                    if (mech.fireCDcycle < mech.cycle) mech.fireCDcycle = mech.cycle
-                    mech.energy -= 0.001 / tech.throwChargeRate;
-                    mech.throwCharge += 0.5 * tech.throwChargeRate / mech.holdingTarget.mass
+                if (m.energy > 0.001) {
+                    if (m.fireCDcycle < m.cycle) m.fireCDcycle = m.cycle
+                    m.energy -= 0.001 / tech.throwChargeRate;
+                    m.throwCharge += 0.5 * tech.throwChargeRate / m.holdingTarget.mass
                     //draw charge
-                    const x = mech.pos.x + 15 * Math.cos(mech.angle);
-                    const y = mech.pos.y + 15 * Math.sin(mech.angle);
-                    const len = mech.holdingTarget.vertices.length - 1;
-                    const edge = mech.throwCharge * mech.throwCharge * mech.throwCharge;
+                    const x = m.pos.x + 15 * Math.cos(m.angle);
+                    const y = m.pos.y + 15 * Math.sin(m.angle);
+                    const len = m.holdingTarget.vertices.length - 1;
+                    const edge = m.throwCharge * m.throwCharge * m.throwCharge;
                     const grd = ctx.createRadialGradient(x, y, edge, x, y, edge + 5);
                     grd.addColorStop(0, "rgba(255,50,150,0.3)");
                     grd.addColorStop(1, "transparent");
                     ctx.fillStyle = grd;
                     ctx.beginPath();
                     ctx.moveTo(x, y);
-                    ctx.lineTo(mech.holdingTarget.vertices[len].x, mech.holdingTarget.vertices[len].y);
-                    ctx.lineTo(mech.holdingTarget.vertices[0].x, mech.holdingTarget.vertices[0].y);
+                    ctx.lineTo(m.holdingTarget.vertices[len].x, m.holdingTarget.vertices[len].y);
+                    ctx.lineTo(m.holdingTarget.vertices[0].x, m.holdingTarget.vertices[0].y);
                     ctx.fill();
                     for (let i = 0; i < len; i++) {
                         ctx.beginPath();
                         ctx.moveTo(x, y);
-                        ctx.lineTo(mech.holdingTarget.vertices[i].x, mech.holdingTarget.vertices[i].y);
-                        ctx.lineTo(mech.holdingTarget.vertices[i + 1].x, mech.holdingTarget.vertices[i + 1].y);
+                        ctx.lineTo(m.holdingTarget.vertices[i].x, m.holdingTarget.vertices[i].y);
+                        ctx.lineTo(m.holdingTarget.vertices[i + 1].x, m.holdingTarget.vertices[i + 1].y);
                         ctx.fill();
                     }
                 } else {
-                    mech.drop()
+                    m.drop()
                 }
-            } else if (mech.throwCharge > 0) { //Matter.Query.region(mob, player.bounds)
+            } else if (m.throwCharge > 0) { //Matter.Query.region(mob, player.bounds)
                 //throw the body
-                mech.fieldCDcycle = mech.cycle + 15;
-                mech.isHolding = false;
+                m.fieldCDcycle = m.cycle + 15;
+                m.isHolding = false;
                 //bullet-like collisions
-                mech.holdingTarget.collisionFilter.category = cat.body; //cat.bullet;
-                mech.holdingTarget.collisionFilter.mask = cat.map | cat.body | cat.bullet | cat.mob | cat.mobBullet | cat.mobShield;
+                m.holdingTarget.collisionFilter.category = cat.body; //cat.bullet;
+                m.holdingTarget.collisionFilter.mask = cat.map | cat.body | cat.bullet | cat.mob | cat.mobBullet | cat.mobShield;
                 //check every second to see if player is away from thrown body, and make solid
                 const solid = function(that) {
                     const dx = that.position.x - player.position.x;
                     const dy = that.position.y - player.position.y;
-                    if (dx * dx + dy * dy > 10000 && that !== mech.holdingTarget) {
+                    if (dx * dx + dy * dy > 10000 && that !== m.holdingTarget) {
                         // that.collisionFilter.category = cat.body; //make solid
                         that.collisionFilter.mask = cat.player | cat.map | cat.body | cat.bullet | cat.mob | cat.mobBullet; //can hit player now
                     } else {
                         setTimeout(solid, 25, that);
                     }
                 };
-                setTimeout(solid, 150, mech.holdingTarget);
+                setTimeout(solid, 150, m.holdingTarget);
 
-                const charge = Math.min(mech.throwCharge / 5, 1)
+                const charge = Math.min(m.throwCharge / 5, 1)
                 //***** scale throw speed with the first number, 80 *****
-                let speed = 80 * charge * Math.min(1, 0.8 / Math.pow(mech.holdingTarget.mass, 0.25));
+                let speed = 80 * charge * Math.min(1, 0.8 / Math.pow(m.holdingTarget.mass, 0.25));
 
-                if (Matter.Query.collides(mech.holdingTarget, map).length !== 0) {
+                if (Matter.Query.collides(m.holdingTarget, map).length !== 0) {
                     speed *= 0.7 //drop speed by 30% if touching map
-                    if (Matter.Query.ray(map, mech.holdingTarget.position, mech.pos).length !== 0) speed = 0 //drop to zero if the center of the block can't see the center of the player through the map
-                    //|| Matter.Query.ray(body, mech.holdingTarget.position, mech.pos).length > 1
+                    if (Matter.Query.ray(map, m.holdingTarget.position, m.pos).length !== 0) speed = 0 //drop to zero if the center of the block can't see the center of the player through the map
+                    //|| Matter.Query.ray(body, m.holdingTarget.position, m.pos).length > 1
                 }
 
-                mech.throwCharge = 0;
-                Matter.Body.setVelocity(mech.holdingTarget, {
-                    x: player.velocity.x * 0.5 + Math.cos(mech.angle) * speed,
-                    y: player.velocity.y * 0.5 + Math.sin(mech.angle) * speed
+                m.throwCharge = 0;
+                Matter.Body.setVelocity(m.holdingTarget, {
+                    x: player.velocity.x * 0.5 + Math.cos(m.angle) * speed,
+                    y: player.velocity.y * 0.5 + Math.sin(m.angle) * speed
                 });
                 //player recoil //stronger in x-dir to prevent jump hacking
 
                 Matter.Body.setVelocity(player, {
-                    x: player.velocity.x - Math.cos(mech.angle) * speed / (mech.crouch ? 30 : 10) * Math.sqrt(mech.holdingTarget.mass),
-                    y: player.velocity.y - Math.sin(mech.angle) * speed / 30 * Math.sqrt(mech.holdingTarget.mass)
+                    x: player.velocity.x - Math.cos(m.angle) * speed / (m.crouch ? 30 : 10) * Math.sqrt(m.holdingTarget.mass),
+                    y: player.velocity.y - Math.sin(m.angle) * speed / 30 * Math.sqrt(m.holdingTarget.mass)
                 });
-                mech.definePlayerMass() //return to normal player mass
+                m.definePlayerMass() //return to normal player mass
             }
         } else {
-            mech.isHolding = false
+            m.isHolding = false
         }
     },
     drawField() {
-        if (mech.holdingTarget) {
-            ctx.fillStyle = "rgba(110,170,200," + (mech.energy * (0.05 + 0.05 * Math.random())) + ")";
+        if (m.holdingTarget) {
+            ctx.fillStyle = "rgba(110,170,200," + (m.energy * (0.05 + 0.05 * Math.random())) + ")";
             ctx.strokeStyle = "rgba(110, 200, 235, " + (0.3 + 0.08 * Math.random()) + ")" //"#9bd" //"rgba(110, 200, 235, " + (0.5 + 0.1 * Math.random()) + ")"
         } else {
-            ctx.fillStyle = "rgba(110,170,200," + (0.02 + mech.energy * (0.15 + 0.15 * Math.random())) + ")";
+            ctx.fillStyle = "rgba(110,170,200," + (0.02 + m.energy * (0.15 + 0.15 * Math.random())) + ")";
             ctx.strokeStyle = "rgba(110, 200, 235, " + (0.6 + 0.2 * Math.random()) + ")" //"#9bd" //"rgba(110, 200, 235, " + (0.5 + 0.1 * Math.random()) + ")"
         }
         // const off = 2 * Math.cos(simulation.cycle * 0.1)
-        const range = mech.fieldRange;
+        const range = m.fieldRange;
         ctx.beginPath();
-        ctx.arc(mech.pos.x, mech.pos.y, range, mech.angle - Math.PI * mech.fieldArc, mech.angle + Math.PI * mech.fieldArc, false);
+        ctx.arc(m.pos.x, m.pos.y, range, m.angle - Math.PI * m.fieldArc, m.angle + Math.PI * m.fieldArc, false);
         ctx.lineWidth = 2;
         ctx.lineCap = "butt"
         ctx.stroke();
         let eye = 13;
-        let aMag = 0.75 * Math.PI * mech.fieldArc
-        let a = mech.angle + aMag
-        let cp1x = mech.pos.x + 0.6 * range * Math.cos(a)
-        let cp1y = mech.pos.y + 0.6 * range * Math.sin(a)
-        ctx.quadraticCurveTo(cp1x, cp1y, mech.pos.x + eye * Math.cos(mech.angle), mech.pos.y + eye * Math.sin(mech.angle))
-        a = mech.angle - aMag
-        cp1x = mech.pos.x + 0.6 * range * Math.cos(a)
-        cp1y = mech.pos.y + 0.6 * range * Math.sin(a)
-        ctx.quadraticCurveTo(cp1x, cp1y, mech.pos.x + 1 * range * Math.cos(mech.angle - Math.PI * mech.fieldArc), mech.pos.y + 1 * range * Math.sin(mech.angle - Math.PI * mech.fieldArc))
+        let aMag = 0.75 * Math.PI * m.fieldArc
+        let a = m.angle + aMag
+        let cp1x = m.pos.x + 0.6 * range * Math.cos(a)
+        let cp1y = m.pos.y + 0.6 * range * Math.sin(a)
+        ctx.quadraticCurveTo(cp1x, cp1y, m.pos.x + eye * Math.cos(m.angle), m.pos.y + eye * Math.sin(m.angle))
+        a = m.angle - aMag
+        cp1x = m.pos.x + 0.6 * range * Math.cos(a)
+        cp1y = m.pos.y + 0.6 * range * Math.sin(a)
+        ctx.quadraticCurveTo(cp1x, cp1y, m.pos.x + 1 * range * Math.cos(m.angle - Math.PI * m.fieldArc), m.pos.y + 1 * range * Math.sin(m.angle - Math.PI * m.fieldArc))
         ctx.fill();
-        // ctx.lineTo(mech.pos.x + eye * Math.cos(mech.angle), mech.pos.y + eye * Math.sin(mech.angle));
+        // ctx.lineTo(m.pos.x + eye * Math.cos(m.angle), m.pos.y + eye * Math.sin(m.angle));
 
         //draw random lines in field for cool effect
-        let offAngle = mech.angle + 1.7 * Math.PI * mech.fieldArc * (Math.random() - 0.5);
+        let offAngle = m.angle + 1.7 * Math.PI * m.fieldArc * (Math.random() - 0.5);
         ctx.beginPath();
         eye = 15;
-        ctx.moveTo(mech.pos.x + eye * Math.cos(mech.angle), mech.pos.y + eye * Math.sin(mech.angle));
-        ctx.lineTo(mech.pos.x + range * Math.cos(offAngle), mech.pos.y + range * Math.sin(offAngle));
+        ctx.moveTo(m.pos.x + eye * Math.cos(m.angle), m.pos.y + eye * Math.sin(m.angle));
+        ctx.lineTo(m.pos.x + range * Math.cos(offAngle), m.pos.y + range * Math.sin(offAngle));
         ctx.strokeStyle = "rgba(120,170,255,0.6)";
         ctx.lineWidth = 1;
         ctx.stroke();
     },
     grabPowerUp() { //look for power ups to grab with field
-        if (mech.fireCDcycle < mech.cycle) mech.fireCDcycle = mech.cycle - 1
+        if (m.fireCDcycle < m.cycle) m.fireCDcycle = m.cycle - 1
         for (let i = 0, len = powerUp.length; i < len; ++i) {
-            const dxP = mech.pos.x - powerUp[i].position.x;
-            const dyP = mech.pos.y - powerUp[i].position.y;
+            const dxP = m.pos.x - powerUp[i].position.x;
+            const dyP = m.pos.y - powerUp[i].position.y;
             const dist2 = dxP * dxP + dyP * dyP;
             // float towards player  if looking at and in range  or  if very close to player
-            if (dist2 < mech.grabPowerUpRange2 &&
-                (mech.lookingAt(powerUp[i]) || dist2 < 16000) &&
-                !(mech.health === mech.maxHealth && powerUp[i].name === "heal") &&
-                Matter.Query.ray(map, powerUp[i].position, mech.pos).length === 0
+            if (dist2 < m.grabPowerUpRange2 &&
+                (m.lookingAt(powerUp[i]) || dist2 < 16000) &&
+                !(m.health === m.maxHealth && powerUp[i].name === "heal") &&
+                Matter.Query.ray(map, powerUp[i].position, m.pos).length === 0
             ) {
                 powerUp[i].force.x += 0.05 * (dxP / Math.sqrt(dist2)) * powerUp[i].mass;
                 powerUp[i].force.y += 0.05 * (dyP / Math.sqrt(dist2)) * powerUp[i].mass - powerUp[i].mass * simulation.g; //negate gravity
@@ -1170,15 +1170,15 @@ const mech = {
     },
     pushMass(who) {
         const speed = Vector.magnitude(Vector.sub(who.velocity, player.velocity))
-        const fieldBlockCost = (0.03 + Math.sqrt(who.mass) * speed * 0.003) * mech.fieldShieldingScale;
+        const fieldBlockCost = (0.03 + Math.sqrt(who.mass) * speed * 0.003) * m.fieldShieldingScale;
         const unit = Vector.normalise(Vector.sub(player.position, who.position))
 
-        if (mech.energy > fieldBlockCost * 0.2) { //shield needs at least some of the cost to block
-            mech.energy -= fieldBlockCost
-            if (mech.energy < 0) {
-                mech.energy = 0;
+        if (m.energy > fieldBlockCost * 0.2) { //shield needs at least some of the cost to block
+            m.energy -= fieldBlockCost
+            if (m.energy < 0) {
+                m.energy = 0;
             }
-            // if (mech.energy > mech.maxEnergy) mech.energy = mech.maxEnergy;
+            // if (m.energy > m.maxEnergy) m.energy = m.maxEnergy;
 
             if (tech.blockDmg) {
                 who.damage(tech.blockDmg * b.dmgScale)
@@ -1186,8 +1186,8 @@ const mech = {
                 const step = 40
                 ctx.beginPath();
                 for (let i = 0, len = 2.5 * tech.blockDmg; i < len; i++) {
-                    let x = mech.pos.x - 20 * unit.x;
-                    let y = mech.pos.y - 20 * unit.y;
+                    let x = m.pos.x - 20 * unit.x;
+                    let y = m.pos.y - 20 * unit.y;
                     ctx.moveTo(x, y);
                     for (let i = 0; i < 8; i++) {
                         x += step * (-unit.x + 1.5 * (Math.random() - 0.5))
@@ -1199,20 +1199,20 @@ const mech = {
                 ctx.strokeStyle = "#f0f";
                 ctx.stroke();
             } else {
-                mech.drawHold(who);
+                m.drawHold(who);
             }
             // if (tech.isFreezeMobs) mobs.statusSlow(who, 60) //this works but doesn't have a fun effect
 
-            // mech.holdingTarget = null
+            // m.holdingTarget = null
             //knock backs
-            if (mech.fieldShieldingScale > 0) {
+            if (m.fieldShieldingScale > 0) {
                 const massRoot = Math.sqrt(Math.min(12, Math.max(0.15, who.mass))); // masses above 12 can start to overcome the push back
                 Matter.Body.setVelocity(who, {
                     x: player.velocity.x - (15 * unit.x) / massRoot,
                     y: player.velocity.y - (15 * unit.y) / massRoot
                 });
-                mech.fieldCDcycle = mech.cycle + mech.fieldBlockCD;
-                if (mech.crouch) {
+                m.fieldCDcycle = m.cycle + m.fieldBlockCD;
+                if (m.crouch) {
                     Matter.Body.setVelocity(player, {
                         x: player.velocity.x + 0.4 * unit.x * massRoot,
                         y: player.velocity.y + 0.4 * unit.y * massRoot
@@ -1224,7 +1224,7 @@ const mech = {
                     });
                 }
             } else {
-                if (tech.isStunField && mech.fieldUpgrades[mech.fieldMode].name === "perfect diamagnetism") mobs.statusStun(who, tech.isStunField)
+                if (tech.isStunField && m.fieldUpgrades[m.fieldMode].name === "perfect diamagnetism") mobs.statusStun(who, tech.isStunField)
                 // mobs.statusSlow(who, tech.isStunField)
                 const massRoot = Math.sqrt(Math.max(0.15, who.mass)); // masses above 12 can start to overcome the push back
                 Matter.Body.setVelocity(who, {
@@ -1244,38 +1244,38 @@ const mech = {
     pushMobsFacing() { // find mobs in range and in direction looking
         for (let i = 0, len = mob.length; i < len; ++i) {
             if (
-                Vector.magnitude(Vector.sub(mob[i].position, player.position)) - mob[i].radius < mech.fieldRange &&
-                mech.lookingAt(mob[i]) &&
-                Matter.Query.ray(map, mob[i].position, mech.pos).length === 0
+                Vector.magnitude(Vector.sub(mob[i].position, player.position)) - mob[i].radius < m.fieldRange &&
+                m.lookingAt(mob[i]) &&
+                Matter.Query.ray(map, mob[i].position, m.pos).length === 0
             ) {
                 mob[i].locatePlayer();
-                mech.pushMass(mob[i]);
+                m.pushMass(mob[i]);
             }
         }
     },
-    pushMobs360(range = mech.fieldRange * 0.75) { // find mobs in range in any direction
+    pushMobs360(range = m.fieldRange * 0.75) { // find mobs in range in any direction
         for (let i = 0, len = mob.length; i < len; ++i) {
             if (
-                Vector.magnitude(Vector.sub(mob[i].position, mech.pos)) < range &&
-                Matter.Query.ray(map, mob[i].position, mech.pos).length === 0
+                Vector.magnitude(Vector.sub(mob[i].position, m.pos)) < range &&
+                Matter.Query.ray(map, mob[i].position, m.pos).length === 0
             ) {
                 mob[i].locatePlayer();
-                mech.pushMass(mob[i]);
+                m.pushMass(mob[i]);
             }
         }
     },
     lookForPickUp() { //find body to pickup
-        if (mech.energy > mech.fieldRegen) mech.energy -= mech.fieldRegen;
+        if (m.energy > m.fieldRegen) m.energy -= m.fieldRegen;
         const grabbing = {
             targetIndex: null,
             targetRange: 150,
             // lookingAt: false //false to pick up object in range, but not looking at
         };
         for (let i = 0, len = body.length; i < len; ++i) {
-            if (Matter.Query.ray(map, body[i].position, mech.pos).length === 0) {
-                //is mech next body a better target then my current best
-                const dist = Vector.magnitude(Vector.sub(body[i].position, mech.pos));
-                const looking = mech.lookingAt(body[i]);
+            if (Matter.Query.ray(map, body[i].position, m.pos).length === 0) {
+                //is m next body a better target then my current best
+                const dist = Vector.magnitude(Vector.sub(body[i].position, m.pos));
+                const looking = m.lookingAt(body[i]);
                 // if (dist < grabbing.targetRange && (looking || !grabbing.lookingAt) && !body[i].isNotHoldable) {
                 if (dist < grabbing.targetRange && looking && !body[i].isNotHoldable) {
                     grabbing.targetRange = dist;
@@ -1286,10 +1286,10 @@ const mech = {
         }
         // set pick up target for when mouse is released
         if (body[grabbing.targetIndex]) {
-            mech.holdingTarget = body[grabbing.targetIndex];
+            m.holdingTarget = body[grabbing.targetIndex];
             //
             ctx.beginPath(); //draw on each valid body
-            let vertices = mech.holdingTarget.vertices;
+            let vertices = m.holdingTarget.vertices;
             ctx.moveTo(vertices[0].x, vertices[0].y);
             for (let j = 1; j < vertices.length; j += 1) {
                 ctx.lineTo(vertices[j].x, vertices[j].y);
@@ -1299,27 +1299,27 @@ const mech = {
             ctx.fill();
 
             ctx.globalAlpha = 0.2;
-            mech.drawHold(mech.holdingTarget);
+            m.drawHold(m.holdingTarget);
             ctx.globalAlpha = 1;
         } else {
-            mech.holdingTarget = null;
+            m.holdingTarget = null;
         }
     },
     pickUp() {
         //triggers when a hold target exits and field button is released
-        mech.isHolding = true;
+        m.isHolding = true;
         //conserve momentum when player mass changes
-        totalMomentum = Vector.add(Vector.mult(player.velocity, player.mass), Vector.mult(mech.holdingTarget.velocity, mech.holdingTarget.mass))
-        Matter.Body.setVelocity(player, Vector.mult(totalMomentum, 1 / (mech.defaultMass + mech.holdingTarget.mass)));
+        totalMomentum = Vector.add(Vector.mult(player.velocity, player.mass), Vector.mult(m.holdingTarget.velocity, m.holdingTarget.mass))
+        Matter.Body.setVelocity(player, Vector.mult(totalMomentum, 1 / (m.defaultMass + m.holdingTarget.mass)));
 
-        mech.definePlayerMass(mech.defaultMass + mech.holdingTarget.mass * mech.holdingMassScale)
+        m.definePlayerMass(m.defaultMass + m.holdingTarget.mass * m.holdingMassScale)
         //make block collide with nothing
-        mech.holdingTarget.collisionFilter.category = 0;
-        mech.holdingTarget.collisionFilter.mask = 0;
+        m.holdingTarget.collisionFilter.category = 0;
+        m.holdingTarget.collisionFilter.mask = 0;
     },
     wakeCheck() {
-        if (mech.isBodiesAsleep) {
-            mech.isBodiesAsleep = false;
+        if (m.isBodiesAsleep) {
+            m.isBodiesAsleep = false;
 
             function wake(who) {
                 for (let i = 0, len = who.length; i < len; ++i) {
@@ -1355,8 +1355,8 @@ const mech = {
     setField(index) {
         if (isNaN(index)) { //find index by name
             let found = false
-            for (let i = 0; i < mech.fieldUpgrades.length; i++) {
-                if (index === mech.fieldUpgrades[i].name) {
+            for (let i = 0; i < m.fieldUpgrades.length; i++) {
+                if (index === m.fieldUpgrades[i].name) {
                     index = i;
                     found = true;
                     break;
@@ -1364,33 +1364,33 @@ const mech = {
             }
             if (!found) return //if you can't find the field don't give a field to avoid game crash
         }
-        mech.fieldMode = index;
-        document.getElementById("field").innerHTML = mech.fieldUpgrades[index].name
-        mech.setHoldDefaults();
-        mech.fieldUpgrades[index].effect();
+        m.fieldMode = index;
+        document.getElementById("field").innerHTML = m.fieldUpgrades[index].name
+        m.setHoldDefaults();
+        m.fieldUpgrades[index].effect();
     },
     fieldUpgrades: [{
             name: "field emitter",
             description: "use <strong class='color-f'>energy</strong> to <strong>block</strong> mobs,<br><strong>grab</strong> power ups, and <strong>throw</strong> blocks",
             effect: () => {
-                mech.hold = function() {
-                    if (mech.isHolding) {
-                        mech.drawHold(mech.holdingTarget);
-                        mech.holding();
-                        mech.throwBlock();
-                    } else if ((input.field && mech.fieldCDcycle < mech.cycle)) { //not hold but field button is pressed
-                        mech.grabPowerUp();
-                        mech.lookForPickUp();
-                        if (mech.energy > 0.05) {
-                            mech.drawField();
-                            mech.pushMobsFacing();
+                m.hold = function() {
+                    if (m.isHolding) {
+                        m.drawHold(m.holdingTarget);
+                        m.holding();
+                        m.throwBlock();
+                    } else if ((input.field && m.fieldCDcycle < m.cycle)) { //not hold but field button is pressed
+                        m.grabPowerUp();
+                        m.lookForPickUp();
+                        if (m.energy > 0.05) {
+                            m.drawField();
+                            m.pushMobsFacing();
                         }
-                    } else if (mech.holdingTarget && mech.fieldCDcycle < mech.cycle) { //holding, but field button is released
-                        mech.pickUp();
+                    } else if (m.holdingTarget && m.fieldCDcycle < m.cycle) { //holding, but field button is released
+                        m.pickUp();
                     } else {
-                        mech.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
+                        m.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
                     }
-                    mech.drawFieldMeter()
+                    m.drawFieldMeter()
                 }
             }
         },
@@ -1398,41 +1398,41 @@ const mech = {
             name: "standing wave harmonics",
             description: "<strong>3</strong> oscillating <strong>shields</strong> are permanently active<br><strong>blocking</strong> drains <strong class='color-f'>energy</strong> with no <strong>cool down</strong><br>reduce <strong class='color-harm'>harm</strong> by <strong>15%</strong>",
             effect: () => {
-                // mech.fieldHarmReduction = 0.80;
-                mech.fieldBlockCD = 0;
-                mech.fieldHarmReduction = 0.85;
-                mech.hold = function() {
-                    if (mech.isHolding) {
-                        mech.drawHold(mech.holdingTarget);
-                        mech.holding();
-                        mech.throwBlock();
-                    } else if ((input.field) && mech.fieldCDcycle < mech.cycle) { //not hold but field button is pressed
-                        mech.grabPowerUp();
-                        mech.lookForPickUp();
-                    } else if (mech.holdingTarget && mech.fieldCDcycle < mech.cycle) { //holding, but field button is released
-                        mech.pickUp();
+                // m.fieldHarmReduction = 0.80;
+                m.fieldBlockCD = 0;
+                m.fieldHarmReduction = 0.85;
+                m.hold = function() {
+                    if (m.isHolding) {
+                        m.drawHold(m.holdingTarget);
+                        m.holding();
+                        m.throwBlock();
+                    } else if ((input.field) && m.fieldCDcycle < m.cycle) { //not hold but field button is pressed
+                        m.grabPowerUp();
+                        m.lookForPickUp();
+                    } else if (m.holdingTarget && m.fieldCDcycle < m.cycle) { //holding, but field button is released
+                        m.pickUp();
                     } else {
-                        mech.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
+                        m.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
                     }
-                    if (mech.energy > 0.1 && mech.fieldCDcycle < mech.cycle) {
-                        const fieldRange1 = (0.7 + 0.3 * Math.sin(mech.cycle / 23)) * mech.fieldRange
-                        const fieldRange2 = (0.63 + 0.37 * Math.sin(mech.cycle / 37)) * mech.fieldRange
-                        const fieldRange3 = (0.65 + 0.35 * Math.sin(mech.cycle / 47)) * mech.fieldRange
+                    if (m.energy > 0.1 && m.fieldCDcycle < m.cycle) {
+                        const fieldRange1 = (0.7 + 0.3 * Math.sin(m.cycle / 23)) * m.fieldRange
+                        const fieldRange2 = (0.63 + 0.37 * Math.sin(m.cycle / 37)) * m.fieldRange
+                        const fieldRange3 = (0.65 + 0.35 * Math.sin(m.cycle / 47)) * m.fieldRange
                         const netfieldRange = Math.max(fieldRange1, fieldRange2, fieldRange3)
-                        ctx.fillStyle = "rgba(110,170,200," + (0.04 + mech.energy * (0.12 + 0.13 * Math.random())) + ")";
+                        ctx.fillStyle = "rgba(110,170,200," + (0.04 + m.energy * (0.12 + 0.13 * Math.random())) + ")";
                         ctx.beginPath();
-                        ctx.arc(mech.pos.x, mech.pos.y, fieldRange1, 0, 2 * Math.PI);
+                        ctx.arc(m.pos.x, m.pos.y, fieldRange1, 0, 2 * Math.PI);
                         ctx.fill();
                         ctx.beginPath();
-                        ctx.arc(mech.pos.x, mech.pos.y, fieldRange2, 0, 2 * Math.PI);
+                        ctx.arc(m.pos.x, m.pos.y, fieldRange2, 0, 2 * Math.PI);
                         ctx.fill();
                         ctx.beginPath();
-                        ctx.arc(mech.pos.x, mech.pos.y, fieldRange3, 0, 2 * Math.PI);
+                        ctx.arc(m.pos.x, m.pos.y, fieldRange3, 0, 2 * Math.PI);
                         ctx.fill();
-                        mech.pushMobs360(netfieldRange);
-                        // mech.pushBody360(netfieldRange);  //can't throw block when pushhing blocks away
+                        m.pushMobs360(netfieldRange);
+                        // m.pushBody360(netfieldRange);  //can't throw block when pushhing blocks away
                     }
-                    mech.drawFieldMeter()
+                    m.drawFieldMeter()
                 }
             }
         },
@@ -1441,23 +1441,23 @@ const mech = {
             // description: "gain <strong class='color-f'>energy</strong> when <strong>blocking</strong><br>no <strong>recoil</strong> when <strong>blocking</strong>",
             description: "<strong>blocking</strong> does not drain <strong class='color-f'>energy</strong><br><strong>blocking</strong> has no <strong>cool down</strong> and less <strong>recoil</strong><br><strong>attract</strong> power ups from <strong>far away</strong>",
             effect: () => {
-                mech.fieldShieldingScale = 0;
-                mech.grabPowerUpRange2 = 10000000
-                mech.hold = function() {
-                    const wave = Math.sin(mech.cycle * 0.022);
-                    mech.fieldRange = 170 + 12 * wave
-                    mech.fieldArc = 0.33 + 0.045 * wave //run calculateFieldThreshold after setting fieldArc, used for powerUp grab and mobPush with lookingAt(mob)
-                    mech.calculateFieldThreshold();
-                    if (mech.isHolding) {
-                        mech.drawHold(mech.holdingTarget);
-                        mech.holding();
-                        mech.throwBlock();
-                    } else if ((input.field && mech.fieldCDcycle < mech.cycle)) { //not hold but field button is pressed
-                        mech.grabPowerUp();
-                        mech.lookForPickUp();
-                        if (mech.energy > 0.05) {
+                m.fieldShieldingScale = 0;
+                m.grabPowerUpRange2 = 10000000
+                m.hold = function() {
+                    const wave = Math.sin(m.cycle * 0.022);
+                    m.fieldRange = 170 + 12 * wave
+                    m.fieldArc = 0.33 + 0.045 * wave //run calculateFieldThreshold after setting fieldArc, used for powerUp grab and mobPush with lookingAt(mob)
+                    m.calculateFieldThreshold();
+                    if (m.isHolding) {
+                        m.drawHold(m.holdingTarget);
+                        m.holding();
+                        m.throwBlock();
+                    } else if ((input.field && m.fieldCDcycle < m.cycle)) { //not hold but field button is pressed
+                        m.grabPowerUp();
+                        m.lookForPickUp();
+                        if (m.energy > 0.05) {
                             //draw field
-                            if (mech.holdingTarget) {
+                            if (m.holdingTarget) {
                                 ctx.fillStyle = "rgba(110,170,200," + (0.06 + 0.03 * Math.random()) + ")";
                                 ctx.strokeStyle = "rgba(110, 200, 235, " + (0.35 + 0.05 * Math.random()) + ")"
                             } else {
@@ -1465,43 +1465,43 @@ const mech = {
                                 ctx.strokeStyle = "rgba(110, 200, 235, " + (0.4 + 0.5 * Math.random()) + ")"
                             }
                             ctx.beginPath();
-                            ctx.arc(mech.pos.x, mech.pos.y, mech.fieldRange, mech.angle - Math.PI * mech.fieldArc, mech.angle + Math.PI * mech.fieldArc, false);
+                            ctx.arc(m.pos.x, m.pos.y, m.fieldRange, m.angle - Math.PI * m.fieldArc, m.angle + Math.PI * m.fieldArc, false);
                             ctx.lineWidth = 2.5 - 1.5 * wave;
                             ctx.lineCap = "butt"
                             ctx.stroke();
                             const curve = 0.57 + 0.04 * wave
-                            const aMag = (1 - curve * 1.2) * Math.PI * mech.fieldArc
-                            let a = mech.angle + aMag
-                            let cp1x = mech.pos.x + curve * mech.fieldRange * Math.cos(a)
-                            let cp1y = mech.pos.y + curve * mech.fieldRange * Math.sin(a)
-                            ctx.quadraticCurveTo(cp1x, cp1y, mech.pos.x + 30 * Math.cos(mech.angle), mech.pos.y + 30 * Math.sin(mech.angle))
-                            a = mech.angle - aMag
-                            cp1x = mech.pos.x + curve * mech.fieldRange * Math.cos(a)
-                            cp1y = mech.pos.y + curve * mech.fieldRange * Math.sin(a)
-                            ctx.quadraticCurveTo(cp1x, cp1y, mech.pos.x + 1 * mech.fieldRange * Math.cos(mech.angle - Math.PI * mech.fieldArc), mech.pos.y + 1 * mech.fieldRange * Math.sin(mech.angle - Math.PI * mech.fieldArc))
+                            const aMag = (1 - curve * 1.2) * Math.PI * m.fieldArc
+                            let a = m.angle + aMag
+                            let cp1x = m.pos.x + curve * m.fieldRange * Math.cos(a)
+                            let cp1y = m.pos.y + curve * m.fieldRange * Math.sin(a)
+                            ctx.quadraticCurveTo(cp1x, cp1y, m.pos.x + 30 * Math.cos(m.angle), m.pos.y + 30 * Math.sin(m.angle))
+                            a = m.angle - aMag
+                            cp1x = m.pos.x + curve * m.fieldRange * Math.cos(a)
+                            cp1y = m.pos.y + curve * m.fieldRange * Math.sin(a)
+                            ctx.quadraticCurveTo(cp1x, cp1y, m.pos.x + 1 * m.fieldRange * Math.cos(m.angle - Math.PI * m.fieldArc), m.pos.y + 1 * m.fieldRange * Math.sin(m.angle - Math.PI * m.fieldArc))
                             ctx.fill();
-                            mech.pushMobsFacing();
+                            m.pushMobsFacing();
                         }
-                    } else if (mech.holdingTarget && mech.fieldCDcycle < mech.cycle) { //holding, but field button is released
-                        mech.pickUp();
+                    } else if (m.holdingTarget && m.fieldCDcycle < m.cycle) { //holding, but field button is released
+                        m.pickUp();
                     } else {
-                        mech.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
+                        m.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
                     }
-                    mech.drawFieldMeter()
+                    m.drawFieldMeter()
 
                     if (tech.isPerfectBrake) { //cap mob speed around player
-                        const range = 160 + 140 * wave + 150 * mech.energy
+                        const range = 160 + 140 * wave + 150 * m.energy
                         for (let i = 0; i < mob.length; i++) {
-                            const distance = Vector.magnitude(Vector.sub(mech.pos, mob[i].position))
+                            const distance = Vector.magnitude(Vector.sub(m.pos, mob[i].position))
                             if (distance < range) {
                                 const cap = mob[i].isShielded ? 8.5 : 4.5
-                                if (mob[i].speed > cap && Vector.dot(mob[i].velocity, Vector.sub(mech.pos, mob[i].position)) > 0) { // if velocity is directed towards player
+                                if (mob[i].speed > cap && Vector.dot(mob[i].velocity, Vector.sub(m.pos, mob[i].position)) > 0) { // if velocity is directed towards player
                                     Matter.Body.setVelocity(mob[i], Vector.mult(Vector.normalise(mob[i].velocity), cap)); //set velocity to cap, but keep the direction
                                 }
                             }
                         }
                         ctx.beginPath();
-                        ctx.arc(mech.pos.x, mech.pos.y, range, 0, 2 * Math.PI);
+                        ctx.arc(m.pos.x, m.pos.y, range, 0, 2 * Math.PI);
                         ctx.fillStyle = "hsla(200,50%,61%,0.08)";
                         ctx.fill();
                     }
@@ -1512,43 +1512,43 @@ const mech = {
             name: "nano-scale manufacturing",
             description: "use <strong class='color-f'>energy</strong> to <strong>block</strong> mobs<br>excess <strong class='color-f'>energy</strong> used to build <strong>drones</strong><br><strong>double</strong> your default <strong class='color-f'>energy</strong> regeneration",
             effect: () => {
-                mech.hold = function() {
-                    if (mech.energy > mech.maxEnergy - 0.02 && mech.fieldCDcycle < mech.cycle && !input.field && bullet.length < 200) {
+                m.hold = function() {
+                    if (m.energy > m.maxEnergy - 0.02 && m.fieldCDcycle < m.cycle && !input.field && bullet.length < 200) {
                         if (tech.isSporeField) {
                             // const len = Math.floor(5 + 4 * Math.random())
-                            const len = Math.ceil(mech.energy * 10)
-                            mech.energy = 0;
-                            for (let i = 0; i < len; i++) b.spore(mech.pos)
+                            const len = Math.ceil(m.energy * 10)
+                            m.energy = 0;
+                            for (let i = 0; i < len; i++) b.spore(m.pos)
                         } else if (tech.isMissileField) {
-                            mech.energy -= 0.5;
-                            b.missile({ x: mech.pos.x, y: mech.pos.y - 40 }, -Math.PI / 2, 0, 1)
+                            m.energy -= 0.5;
+                            b.missile({ x: m.pos.x, y: m.pos.y - 40 }, -Math.PI / 2, 0, 1)
                         } else if (tech.isIceField) {
-                            mech.energy -= 0.057;
+                            m.energy -= 0.057;
                             b.iceIX(1)
                         } else {
-                            mech.energy -= 0.45;
+                            m.energy -= 0.45;
                             b.drone(1)
                         }
                     }
 
-                    if (mech.isHolding) {
-                        mech.drawHold(mech.holdingTarget);
-                        mech.holding();
-                        mech.throwBlock();
-                    } else if ((input.field && mech.fieldCDcycle < mech.cycle)) { //not hold but field button is pressed
-                        mech.grabPowerUp();
-                        mech.lookForPickUp();
-                        if (mech.energy > 0.05) {
-                            mech.drawField();
-                            mech.pushMobsFacing();
+                    if (m.isHolding) {
+                        m.drawHold(m.holdingTarget);
+                        m.holding();
+                        m.throwBlock();
+                    } else if ((input.field && m.fieldCDcycle < m.cycle)) { //not hold but field button is pressed
+                        m.grabPowerUp();
+                        m.lookForPickUp();
+                        if (m.energy > 0.05) {
+                            m.drawField();
+                            m.pushMobsFacing();
                         }
-                    } else if (mech.holdingTarget && mech.fieldCDcycle < mech.cycle) { //holding, but field button is released
-                        mech.pickUp();
+                    } else if (m.holdingTarget && m.fieldCDcycle < m.cycle) { //holding, but field button is released
+                        m.pickUp();
                     } else {
-                        mech.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
+                        m.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
                     }
-                    mech.energy += mech.fieldRegen;
-                    mech.drawFieldMeter()
+                    m.energy += m.fieldRegen;
+                    m.drawFieldMeter()
                 }
             }
         },
@@ -1557,33 +1557,33 @@ const mech = {
             description: "use <strong class='color-f'>energy</strong> to nullify &nbsp;<strong style='letter-spacing: 7px;'>gravity</strong><br>reduce <strong class='color-harm'>harm</strong> by <strong>45%</strong><br><strong>blocks</strong> held by the field have a lower <strong>mass</strong>",
             fieldDrawRadius: 0,
             effect: () => {
-                mech.fieldFire = true;
-                mech.holdingMassScale = 0.03; //can hold heavier blocks with lower cost to jumping
-                mech.fieldMeterColor = "#000"
-                mech.fieldHarmReduction = 0.55;
-                mech.fieldDrawRadius = 0;
+                m.fieldFire = true;
+                m.holdingMassScale = 0.03; //can hold heavier blocks with lower cost to jumping
+                m.fieldMeterColor = "#000"
+                m.fieldHarmReduction = 0.55;
+                m.fieldDrawRadius = 0;
 
-                mech.hold = function() {
-                    mech.airSpeedLimit = 125 //5 * player.mass * player.mass
-                    mech.FxAir = 0.016
-                    mech.isFieldActive = false;
-                    if (mech.isHolding) {
-                        mech.drawHold(mech.holdingTarget);
-                        mech.holding();
-                        mech.throwBlock();
-                    } else if (input.field && mech.fieldCDcycle < mech.cycle) { //push away
-                        mech.grabPowerUp();
-                        mech.lookForPickUp();
+                m.hold = function() {
+                    m.airSpeedLimit = 125 //5 * player.mass * player.mass
+                    m.FxAir = 0.016
+                    m.isFieldActive = false;
+                    if (m.isHolding) {
+                        m.drawHold(m.holdingTarget);
+                        m.holding();
+                        m.throwBlock();
+                    } else if (input.field && m.fieldCDcycle < m.cycle) { //push away
+                        m.grabPowerUp();
+                        m.lookForPickUp();
                         const DRAIN = 0.00035
-                        if (mech.energy > DRAIN) {
-                            mech.isFieldActive = true; //used with tech.isHarmReduce
-                            mech.airSpeedLimit = 400 // 7* player.mass * player.mass
-                            mech.FxAir = 0.005
-                            // mech.pushMobs360();
+                        if (m.energy > DRAIN) {
+                            m.isFieldActive = true; //used with tech.isHarmReduce
+                            m.airSpeedLimit = 400 // 7* player.mass * player.mass
+                            m.FxAir = 0.005
+                            // m.pushMobs360();
 
                             //repulse mobs
                             // for (let i = 0, len = mob.length; i < len; ++i) {
-                            //   sub = Vector.sub(mob[i].position, mech.pos);
+                            //   sub = Vector.sub(mob[i].position, m.pos);
                             //   dist2 = Vector.magnitudeSquared(sub);
                             //   if (dist2 < this.fieldDrawRadius * this.fieldDrawRadius && mob[i].speed > 6) {
                             //     const force = Vector.mult(Vector.perp(Vector.normalise(sub)), 0.00004 * mob[i].speed * mob[i].mass)
@@ -1594,7 +1594,7 @@ const mech = {
                             //look for nearby objects to make zero-g
                             function zeroG(who, range, mag = 1.06) {
                                 for (let i = 0, len = who.length; i < len; ++i) {
-                                    sub = Vector.sub(who[i].position, mech.pos);
+                                    sub = Vector.sub(who[i].position, m.pos);
                                     dist = Vector.magnitude(sub);
                                     if (dist < range) {
                                         who[i].force.y -= who[i].mass * (simulation.g * mag); //add a bit more then standard gravity
@@ -1610,21 +1610,21 @@ const mech = {
                                 zeroG(powerUp, this.fieldDrawRadius, 0.7);
                                 zeroG(body, this.fieldDrawRadius, 0.7);
                             } else if (input.up) { //up
-                                mech.energy -= 5 * DRAIN;
+                                m.energy -= 5 * DRAIN;
                                 this.fieldDrawRadius = this.fieldDrawRadius * 0.97 + 850 * 0.03;
                                 player.force.y -= 1.45 * player.mass * simulation.g;
                                 zeroG(powerUp, this.fieldDrawRadius, 1.38);
                                 zeroG(body, this.fieldDrawRadius, 1.38);
                             } else {
-                                mech.energy -= DRAIN;
+                                m.energy -= DRAIN;
                                 this.fieldDrawRadius = this.fieldDrawRadius * 0.97 + 650 * 0.03;
                                 player.force.y -= 1.07 * player.mass * simulation.g; // slow upward drift
                                 zeroG(powerUp, this.fieldDrawRadius);
                                 zeroG(body, this.fieldDrawRadius);
                             }
-                            if (mech.energy < 0.001) {
-                                mech.fieldCDcycle = mech.cycle + 120;
-                                mech.energy = 0;
+                            if (m.energy < 0.001) {
+                                m.fieldCDcycle = m.cycle + 120;
+                                m.energy = 0;
                             }
                             //add extra friction for horizontal motion
                             if (input.down || input.up || input.left || input.right) {
@@ -1642,8 +1642,8 @@ const mech = {
                                 const ICE_DRAIN = 0.0005
                                 for (let i = 0, len = mob.length; i < len; i++) {
                                     if (((mob[i].distanceToPlayer() + mob[i].radius) < this.fieldDrawRadius) && !mob[i].shield && !mob[i].isShielded) {
-                                        if (mech.energy > ICE_DRAIN * 2) {
-                                            mech.energy -= ICE_DRAIN;
+                                        if (m.energy > ICE_DRAIN * 2) {
+                                            m.energy -= ICE_DRAIN;
                                             this.fieldDrawRadius -= 2;
                                             mobs.statusSlow(mob[i], 45)
                                         } else {
@@ -1655,20 +1655,20 @@ const mech = {
 
                             //draw zero-G range
                             ctx.beginPath();
-                            ctx.arc(mech.pos.x, mech.pos.y, this.fieldDrawRadius, 0, 2 * Math.PI);
+                            ctx.arc(m.pos.x, m.pos.y, this.fieldDrawRadius, 0, 2 * Math.PI);
                             ctx.fillStyle = "#f5f5ff";
                             ctx.globalCompositeOperation = "difference";
                             ctx.fill();
                             ctx.globalCompositeOperation = "source-over";
                         }
-                    } else if (mech.holdingTarget && mech.fieldCDcycle < mech.cycle) { //holding, but field button is released
-                        mech.pickUp();
+                    } else if (m.holdingTarget && m.fieldCDcycle < m.cycle) { //holding, but field button is released
+                        m.pickUp();
                         this.fieldDrawRadius = 0
                     } else {
-                        mech.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
+                        m.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
                         this.fieldDrawRadius = 0
                     }
-                    mech.drawFieldMeter("rgba(0,0,0,0.2)")
+                    m.drawFieldMeter("rgba(0,0,0,0.2)")
                 }
             }
         },
@@ -1676,27 +1676,27 @@ const mech = {
             name: "plasma torch",
             description: "use <strong class='color-f'>energy</strong> to emit short range <strong class='color-plasma'>plasma</strong><br><strong class='color-d'>damages</strong> and <strong>pushes</strong> mobs away",
             effect() {
-                mech.fieldMeterColor = "#f0f"
-                mech.hold = function() {
+                m.fieldMeterColor = "#f0f"
+                m.hold = function() {
                     b.isExtruderOn = false
-                    if (mech.isHolding) {
-                        mech.drawHold(mech.holdingTarget);
-                        mech.holding();
-                        mech.throwBlock();
-                    } else if (input.field && mech.fieldCDcycle < mech.cycle) { //not hold but field button is pressed
-                        mech.grabPowerUp();
-                        mech.lookForPickUp();
+                    if (m.isHolding) {
+                        m.drawHold(m.holdingTarget);
+                        m.holding();
+                        m.throwBlock();
+                    } else if (input.field && m.fieldCDcycle < m.cycle) { //not hold but field button is pressed
+                        m.grabPowerUp();
+                        m.lookForPickUp();
                         if (tech.isExtruder) {
                             b.extruder();
                         } else {
                             b.plasma();
                         }
-                    } else if (mech.holdingTarget && mech.fieldCDcycle < mech.cycle) { //holding, but field button is released
-                        mech.pickUp();
+                    } else if (m.holdingTarget && m.fieldCDcycle < m.cycle) { //holding, but field button is released
+                        m.pickUp();
                     } else {
-                        mech.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
+                        m.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
                     }
-                    mech.drawFieldMeter("rgba(0, 0, 0, 0.2)")
+                    m.drawFieldMeter("rgba(0, 0, 0, 0.2)")
 
                     if (tech.isExtruder) {
                         if (input.field) {
@@ -1718,7 +1718,7 @@ const mech = {
                                 }
                             }
                         }
-                        if (b.wasExtruderOn && b.isExtruderOn) ctx.lineTo(mech.pos.x + 15 * Math.cos(mech.angle), mech.pos.y + 15 * Math.sin(mech.angle))
+                        if (b.wasExtruderOn && b.isExtruderOn) ctx.lineTo(m.pos.x + 15 * Math.cos(m.angle), m.pos.y + 15 * Math.sin(m.angle))
                         ctx.stroke();
                     }
                 }
@@ -1728,26 +1728,26 @@ const mech = {
             name: "time dilation field",
             description: "use <strong class='color-f'>energy</strong> to <strong style='letter-spacing: 1px;'>stop time</strong><br><strong>move</strong> and <strong>fire</strong> while time is stopped",
             effect: () => {
-                // mech.fieldMeterColor = "#000"
-                mech.fieldFire = true;
-                mech.isBodiesAsleep = false;
-                mech.hold = function() {
-                    if (mech.isHolding) {
-                        mech.wakeCheck();
-                        mech.drawHold(mech.holdingTarget);
-                        mech.holding();
-                        mech.throwBlock();
-                    } else if (input.field && mech.fieldCDcycle < mech.cycle) {
-                        mech.grabPowerUp();
-                        mech.lookForPickUp(180);
+                // m.fieldMeterColor = "#000"
+                m.fieldFire = true;
+                m.isBodiesAsleep = false;
+                m.hold = function() {
+                    if (m.isHolding) {
+                        m.wakeCheck();
+                        m.drawHold(m.holdingTarget);
+                        m.holding();
+                        m.throwBlock();
+                    } else if (input.field && m.fieldCDcycle < m.cycle) {
+                        m.grabPowerUp();
+                        m.lookForPickUp(180);
 
                         const DRAIN = 0.0013
-                        if (mech.energy > DRAIN) {
-                            mech.energy -= DRAIN;
-                            if (mech.energy < DRAIN) {
-                                mech.fieldCDcycle = mech.cycle + 120;
-                                mech.energy = 0;
-                                mech.wakeCheck();
+                        if (m.energy > DRAIN) {
+                            m.energy -= DRAIN;
+                            if (m.energy < DRAIN) {
+                                m.fieldCDcycle = m.cycle + 120;
+                                m.energy = 0;
+                                m.wakeCheck();
                             }
                             //draw field everywhere
                             ctx.globalCompositeOperation = "saturation"
@@ -1755,7 +1755,7 @@ const mech = {
                             ctx.fillRect(-100000, -100000, 200000, 200000)
                             ctx.globalCompositeOperation = "source-over"
                             //stop time
-                            mech.isBodiesAsleep = true;
+                            m.isBodiesAsleep = true;
 
                             function sleep(who) {
                                 for (let i = 0, len = who.length; i < len; ++i) {
@@ -1779,20 +1779,20 @@ const mech = {
 
                             simulation.cycle--; //pause all functions that depend on game cycle increasing
                             if (tech.isTimeSkip) {
-                                mech.immuneCycle = mech.cycle + 10;
+                                m.immuneCycle = m.cycle + 10;
                                 simulation.isTimeSkipping = true;
-                                mech.cycle++;
+                                m.cycle++;
                                 simulation.gravity();
                                 Engine.update(engine, simulation.delta);
                                 // level.checkZones();
                                 // level.checkQuery();
-                                mech.move();
+                                m.move();
                                 simulation.checks();
                                 // mobs.loop();
-                                // mech.draw();
-                                mech.walk_cycle += mech.flipLegs * mech.Vx;
-                                // mech.hold();
-                                // mech.energy += DRAIN; // 1 to undo the energy drain from time speed up, 0.5 to cut energy drain in half
+                                // m.draw();
+                                m.walk_cycle += m.flipLegs * m.Vx;
+                                // m.hold();
+                                // m.energy += DRAIN; // 1 to undo the energy drain from time speed up, 0.5 to cut energy drain in half
                                 b.fire();
                                 // b.bulletRemove();
                                 b.bulletDo();
@@ -1801,17 +1801,17 @@ const mech = {
                             // simulation.cycle--; //pause all functions that depend on game cycle increasing
                             // if (tech.isTimeSkip && !simulation.isTimeSkipping) { //speed up the rate of time
                             //   simulation.timeSkip(1)
-                            //   mech.energy += 1.5 * DRAIN; //x1 to undo the energy drain from time speed up, x1.5 to cut energy drain in half
+                            //   m.energy += 1.5 * DRAIN; //x1 to undo the energy drain from time speed up, x1.5 to cut energy drain in half
                             // }
                         }
-                    } else if (mech.holdingTarget && mech.fieldCDcycle < mech.cycle) { //holding, but field button is released
-                        mech.wakeCheck();
-                        mech.pickUp();
+                    } else if (m.holdingTarget && m.fieldCDcycle < m.cycle) { //holding, but field button is released
+                        m.wakeCheck();
+                        m.pickUp();
                     } else {
-                        mech.wakeCheck();
-                        mech.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
+                        m.wakeCheck();
+                        m.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
                     }
-                    mech.drawFieldMeter()
+                    m.drawFieldMeter()
                 }
             }
         },
@@ -1819,41 +1819,41 @@ const mech = {
             name: "metamaterial cloaking", //"weak photonic coupling" "electromagnetically induced transparency" "optical non-coupling" "slow light field" "electro-optic transparency"
             description: "<strong class='color-cloaked'>cloak</strong> after not using your gun or field<br>while <strong class='color-cloaked'>cloaked</strong> mobs can't see you<br>increase <strong class='color-d'>damage</strong> by <strong>133%</strong>",
             effect: () => {
-                mech.fieldFire = true;
-                mech.fieldMeterColor = "#fff";
-                mech.fieldPhase = 0;
-                mech.isCloak = false
-                mech.fieldDamage = 2.33 // 1 + 111/100
-                mech.fieldDrawRadius = 0
+                m.fieldFire = true;
+                m.fieldMeterColor = "#fff";
+                m.fieldPhase = 0;
+                m.isCloak = false
+                m.fieldDamage = 2.33 // 1 + 111/100
+                m.fieldDrawRadius = 0
                 const drawRadius = 1000
 
-                mech.hold = function() {
-                    if (mech.isHolding) {
-                        mech.drawHold(mech.holdingTarget);
-                        mech.holding();
-                        mech.throwBlock();
-                    } else if (input.field && mech.fieldCDcycle < mech.cycle) { //not hold and field button is pressed
-                        mech.grabPowerUp();
-                        mech.lookForPickUp();
-                    } else if (mech.holdingTarget && mech.fieldCDcycle < mech.cycle) { //holding target exists, and field button is not pressed
-                        mech.pickUp();
+                m.hold = function() {
+                    if (m.isHolding) {
+                        m.drawHold(m.holdingTarget);
+                        m.holding();
+                        m.throwBlock();
+                    } else if (input.field && m.fieldCDcycle < m.cycle) { //not hold and field button is pressed
+                        m.grabPowerUp();
+                        m.lookForPickUp();
+                    } else if (m.holdingTarget && m.fieldCDcycle < m.cycle) { //holding target exists, and field button is not pressed
+                        m.pickUp();
                     } else {
-                        mech.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
+                        m.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
                     }
 
                     //120 cycles after shooting (or using field) enable cloak
-                    if (mech.energy < 0.05 && mech.fireCDcycle < mech.cycle && !input.fire) mech.fireCDcycle = mech.cycle
-                    if (mech.fireCDcycle + 50 < mech.cycle) {
-                        if (!mech.isCloak) {
-                            mech.isCloak = true //enter cloak
+                    if (m.energy < 0.05 && m.fireCDcycle < m.cycle && !input.fire) m.fireCDcycle = m.cycle
+                    if (m.fireCDcycle + 50 < m.cycle) {
+                        if (!m.isCloak) {
+                            m.isCloak = true //enter cloak
                             if (tech.isIntangible) {
                                 for (let i = 0; i < bullet.length; i++) {
                                     if (bullet[i].botType && bullet[i].botType !== "orbit") bullet[i].collisionFilter.mask = cat.map | cat.bullet | cat.mobBullet | cat.mobShield
                                 }
                             }
                         }
-                    } else if (mech.isCloak) { //exit cloak
-                        mech.isCloak = false
+                    } else if (m.isCloak) { //exit cloak
+                        m.isCloak = false
                         if (tech.isIntangible) {
                             for (let i = 0; i < bullet.length; i++) {
                                 if (bullet[i].botType && bullet[i].botType !== "orbit") bullet[i].collisionFilter.mask = cat.map | cat.body | cat.bullet | cat.mob | cat.mobBullet | cat.mobShield
@@ -1861,28 +1861,28 @@ const mech = {
                         }
                         if (tech.isCloakStun) { //stun nearby mobs after exiting cloak
                             let isMobsAround = false
-                            const stunRange = mech.fieldDrawRadius * 1.15
-                            const drain = 0.3 * mech.energy
+                            const stunRange = m.fieldDrawRadius * 1.15
+                            const drain = 0.3 * m.energy
                             for (let i = 0, len = mob.length; i < len; ++i) {
                                 if (
-                                    Vector.magnitude(Vector.sub(mob[i].position, mech.pos)) < stunRange &&
-                                    Matter.Query.ray(map, mob[i].position, mech.pos).length === 0
+                                    Vector.magnitude(Vector.sub(mob[i].position, m.pos)) < stunRange &&
+                                    Matter.Query.ray(map, mob[i].position, m.pos).length === 0
                                 ) {
                                     isMobsAround = true
                                     mobs.statusStun(mob[i], 30 + drain * 300)
                                 }
                             }
-                            if (isMobsAround && mech.energy > drain) {
-                                mech.energy -= drain
+                            if (isMobsAround && m.energy > drain) {
+                                m.energy -= drain
                                 simulation.drawList.push({
-                                    x: mech.pos.x,
-                                    y: mech.pos.y,
+                                    x: m.pos.x,
+                                    y: m.pos.y,
                                     radius: stunRange,
                                     color: "hsla(0,50%,100%,0.6)",
                                     time: 4
                                 });
                                 // ctx.beginPath();
-                                // ctx.arc(mech.pos.x, mech.pos.y, 800, 0, 2 * Math.PI);
+                                // ctx.arc(m.pos.x, m.pos.y, 800, 0, 2 * Math.PI);
                                 // ctx.fillStyle = "#000"
                                 // ctx.fill();
                             }
@@ -1890,45 +1890,45 @@ const mech = {
                     }
 
                     function drawField() {
-                        mech.fieldPhase += 0.007 + 0.07 * (1 - energy)
-                        const wiggle = 0.15 * Math.sin(mech.fieldPhase * 0.5)
+                        m.fieldPhase += 0.007 + 0.07 * (1 - energy)
+                        const wiggle = 0.15 * Math.sin(m.fieldPhase * 0.5)
                         ctx.beginPath();
-                        ctx.ellipse(mech.pos.x, mech.pos.y, mech.fieldDrawRadius * (1 - wiggle), mech.fieldDrawRadius * (1 + wiggle), mech.fieldPhase, 0, 2 * Math.PI);
-                        if (mech.fireCDcycle > mech.cycle && (input.field)) {
+                        ctx.ellipse(m.pos.x, m.pos.y, m.fieldDrawRadius * (1 - wiggle), m.fieldDrawRadius * (1 + wiggle), m.fieldPhase, 0, 2 * Math.PI);
+                        if (m.fireCDcycle > m.cycle && (input.field)) {
                             ctx.lineWidth = 5;
                             ctx.strokeStyle = `rgba(0, 204, 255,1)`
                             ctx.stroke()
                         }
-                        ctx.fillStyle = "#fff" //`rgba(0,0,0,${0.5+0.5*mech.energy})`;
+                        ctx.fillStyle = "#fff" //`rgba(0,0,0,${0.5+0.5*m.energy})`;
                         ctx.globalCompositeOperation = "destination-in"; //in or atop
                         ctx.fill();
                         ctx.globalCompositeOperation = "source-over";
                         ctx.clip();
                     }
 
-                    const energy = Math.max(0.01, Math.min(mech.energy, 1))
-                    if (mech.isCloak) {
+                    const energy = Math.max(0.01, Math.min(m.energy, 1))
+                    if (m.isCloak) {
                         this.fieldRange = this.fieldRange * 0.9 + 0.1 * drawRadius
-                        mech.fieldDrawRadius = this.fieldRange * Math.min(1, 0.3 + 0.5 * Math.min(1, energy * energy));
+                        m.fieldDrawRadius = this.fieldRange * Math.min(1, 0.3 + 0.5 * Math.min(1, energy * energy));
                         drawField()
                     } else {
                         if (this.fieldRange < 3000) {
                             this.fieldRange += 200
-                            mech.fieldDrawRadius = this.fieldRange * Math.min(1, 0.3 + 0.5 * Math.min(1, energy * energy));
+                            m.fieldDrawRadius = this.fieldRange * Math.min(1, 0.3 + 0.5 * Math.min(1, energy * energy));
                             drawField()
                         }
                     }
                     if (tech.isIntangible) {
-                        if (mech.isCloak) {
+                        if (m.isCloak) {
                             player.collisionFilter.mask = cat.map
                             let inPlayer = Matter.Query.region(mob, player.bounds)
                             if (inPlayer.length > 0) {
                                 for (let i = 0; i < inPlayer.length; i++) {
-                                    if (mech.energy > 0) {
+                                    if (m.energy > 0) {
                                         if (inPlayer[i].shield) { //shields drain player energy
-                                            mech.energy -= 0.014;
+                                            m.energy -= 0.014;
                                         } else {
-                                            mech.energy -= 0.004;
+                                            m.energy -= 0.004;
                                         }
                                     }
                                 }
@@ -1938,17 +1938,17 @@ const mech = {
                         }
                     }
 
-                    if (mech.energy < mech.maxEnergy) { // replaces mech.drawFieldMeter() with custom code
-                        mech.energy += mech.fieldRegen;
-                        if (mech.energy < 0) mech.energy = 0
-                        const xOff = mech.pos.x - mech.radius * mech.maxEnergy
-                        const yOff = mech.pos.y - 50
+                    if (m.energy < m.maxEnergy) { // replaces m.drawFieldMeter() with custom code
+                        m.energy += m.fieldRegen;
+                        if (m.energy < 0) m.energy = 0
+                        const xOff = m.pos.x - m.radius * m.maxEnergy
+                        const yOff = m.pos.y - 50
                         ctx.fillStyle = "rgba(0, 0, 0, 0.3)";
-                        ctx.fillRect(xOff, yOff, 60 * mech.maxEnergy, 10);
-                        ctx.fillStyle = mech.fieldMeterColor;
-                        ctx.fillRect(xOff, yOff, 60 * mech.energy, 10);
+                        ctx.fillRect(xOff, yOff, 60 * m.maxEnergy, 10);
+                        ctx.fillStyle = m.fieldMeterColor;
+                        ctx.fillRect(xOff, yOff, 60 * m.energy, 10);
                         ctx.beginPath()
-                        ctx.rect(xOff, yOff, 60 * mech.maxEnergy, 10);
+                        ctx.rect(xOff, yOff, 60 * m.maxEnergy, 10);
                         ctx.strokeStyle = "rgb(0, 0, 0)";
                         ctx.lineWidth = 1;
                         ctx.stroke();
@@ -1960,61 +1960,61 @@ const mech = {
         //   name: "phase decoherence field",
         //   description: "use <strong class='color-f'>energy</strong> to become <strong>intangible</strong><br><strong>firing</strong> and touching <strong>shields</strong> <strong>drains</strong> <strong class='color-f'>energy</strong><br>unable to <strong>see</strong> and be <strong>seen</strong> by mobs",
         //   effect: () => {
-        //     mech.fieldFire = true;
-        //     mech.fieldMeterColor = "#fff";
-        //     mech.fieldPhase = 0;
+        //     m.fieldFire = true;
+        //     m.fieldMeterColor = "#fff";
+        //     m.fieldPhase = 0;
 
-        //     mech.hold = function () {
+        //     m.hold = function () {
         //       function drawField(radius) {
-        //         radius *= Math.min(4, 0.9 + 2.2 * mech.energy * mech.energy);
-        //         const rotate = mech.cycle * 0.005;
-        //         mech.fieldPhase += 0.5 - 0.5 * Math.sqrt(Math.max(0.01, Math.min(mech.energy, 1)));
-        //         const off1 = 1 + 0.06 * Math.sin(mech.fieldPhase);
-        //         const off2 = 1 - 0.06 * Math.sin(mech.fieldPhase);
+        //         radius *= Math.min(4, 0.9 + 2.2 * m.energy * m.energy);
+        //         const rotate = m.cycle * 0.005;
+        //         m.fieldPhase += 0.5 - 0.5 * Math.sqrt(Math.max(0.01, Math.min(m.energy, 1)));
+        //         const off1 = 1 + 0.06 * Math.sin(m.fieldPhase);
+        //         const off2 = 1 - 0.06 * Math.sin(m.fieldPhase);
         //         ctx.beginPath();
-        //         ctx.ellipse(mech.pos.x, mech.pos.y, radius * off1, radius * off2, rotate, 0, 2 * Math.PI);
-        //         if (mech.fireCDcycle > mech.cycle && (input.field)) {
+        //         ctx.ellipse(m.pos.x, m.pos.y, radius * off1, radius * off2, rotate, 0, 2 * Math.PI);
+        //         if (m.fireCDcycle > m.cycle && (input.field)) {
         //           ctx.lineWidth = 5;
         //           ctx.strokeStyle = `rgba(0, 204, 255,1)`
         //           ctx.stroke()
         //         }
-        //         ctx.fillStyle = "#fff" //`rgba(0,0,0,${0.5+0.5*mech.energy})`;
+        //         ctx.fillStyle = "#fff" //`rgba(0,0,0,${0.5+0.5*m.energy})`;
         //         ctx.globalCompositeOperation = "destination-in"; //in or atop
         //         ctx.fill();
         //         ctx.globalCompositeOperation = "source-over";
         //         ctx.clip();
         //       }
 
-        //       mech.isCloak = false //isCloak disables most uses of foundPlayer() 
+        //       m.isCloak = false //isCloak disables most uses of foundPlayer() 
         //       player.collisionFilter.mask = cat.body | cat.map | cat.mob | cat.mobBullet | cat.mobShield //normal collisions
-        //       if (mech.isHolding) {
+        //       if (m.isHolding) {
         //         if (this.fieldRange < 2000) {
         //           this.fieldRange += 100
         //           drawField(this.fieldRange)
         //         }
-        //         mech.drawHold(mech.holdingTarget);
-        //         mech.holding();
-        //         mech.throwBlock();
+        //         m.drawHold(m.holdingTarget);
+        //         m.holding();
+        //         m.throwBlock();
         //       } else if (input.field) {
-        //         mech.grabPowerUp();
-        //         mech.lookForPickUp();
+        //         m.grabPowerUp();
+        //         m.lookForPickUp();
 
-        //         if (mech.fieldCDcycle < mech.cycle) {
+        //         if (m.fieldCDcycle < m.cycle) {
         //           // simulation.draw.bodyFill = "transparent"
         //           // simulation.draw.bodyStroke = "transparent"
 
-        //           const DRAIN = 0.00013 + (mech.fireCDcycle > mech.cycle ? 0.005 : 0)
-        //           if (mech.energy > DRAIN) {
-        //             mech.energy -= DRAIN;
-        //             // if (mech.energy < 0.001) {
-        //             //   mech.fieldCDcycle = mech.cycle + 120;
-        //             //   mech.energy = 0;
-        //             //   mech.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
+        //           const DRAIN = 0.00013 + (m.fireCDcycle > m.cycle ? 0.005 : 0)
+        //           if (m.energy > DRAIN) {
+        //             m.energy -= DRAIN;
+        //             // if (m.energy < 0.001) {
+        //             //   m.fieldCDcycle = m.cycle + 120;
+        //             //   m.energy = 0;
+        //             //   m.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
         //             // }
         //             this.fieldRange = this.fieldRange * 0.8 + 0.2 * 160
         //             drawField(this.fieldRange)
 
-        //             mech.isCloak = true //isCloak disables most uses of foundPlayer() 
+        //             m.isCloak = true //isCloak disables most uses of foundPlayer() 
         //             player.collisionFilter.mask = cat.map
 
 
@@ -2022,13 +2022,13 @@ const mech = {
         //             if (inPlayer.length > 0) {
         //               for (let i = 0; i < inPlayer.length; i++) {
         //                 if (inPlayer[i].shield) {
-        //                   mech.energy -= 0.005; //shields drain player energy
+        //                   m.energy -= 0.005; //shields drain player energy
         //                   //draw outline of shield
         //                   ctx.fillStyle = `rgba(140,217,255,0.5)`
         //                   ctx.fill()
         //                 } else if (tech.superposition && inPlayer[i].dropPowerUp) {
         //                   // inPlayer[i].damage(0.4 * b.dmgScale); //damage mobs inside the player
-        //                   // mech.energy += 0.005;
+        //                   // m.energy += 0.005;
 
         //                   mobs.statusStun(inPlayer[i], 300)
         //                   //draw outline of mob in a few random locations to show blurriness
@@ -2051,42 +2051,42 @@ const mech = {
         //               }
         //             }
         //           } else {
-        //             mech.fieldCDcycle = mech.cycle + 120;
-        //             mech.energy = 0;
-        //             mech.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
+        //             m.fieldCDcycle = m.cycle + 120;
+        //             m.energy = 0;
+        //             m.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
         //             drawField(this.fieldRange)
         //           }
         //         }
-        //       } else if (mech.holdingTarget && mech.fieldCDcycle < mech.cycle) { //holding, but field button is released
-        //         mech.pickUp();
+        //       } else if (m.holdingTarget && m.fieldCDcycle < m.cycle) { //holding, but field button is released
+        //         m.pickUp();
         //         if (this.fieldRange < 2000) {
         //           this.fieldRange += 100
         //           drawField(this.fieldRange)
         //         }
         //       } else {
         //         // this.fieldRange = 3000
-        //         if (this.fieldRange < 2000 && mech.holdingTarget === null) {
+        //         if (this.fieldRange < 2000 && m.holdingTarget === null) {
         //           this.fieldRange += 100
         //           drawField(this.fieldRange)
         //         }
-        //         mech.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
+        //         m.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
         //       }
 
-        //       if (mech.energy < mech.maxEnergy) {
-        //         mech.energy += mech.fieldRegen;
-        //         const xOff = mech.pos.x - mech.radius * mech.maxEnergy
-        //         const yOff = mech.pos.y - 50
+        //       if (m.energy < m.maxEnergy) {
+        //         m.energy += m.fieldRegen;
+        //         const xOff = m.pos.x - m.radius * m.maxEnergy
+        //         const yOff = m.pos.y - 50
         //         ctx.fillStyle = "rgba(0, 0, 0, 0.3)";
-        //         ctx.fillRect(xOff, yOff, 60 * mech.maxEnergy, 10);
-        //         ctx.fillStyle = mech.fieldMeterColor;
-        //         ctx.fillRect(xOff, yOff, 60 * mech.energy, 10);
+        //         ctx.fillRect(xOff, yOff, 60 * m.maxEnergy, 10);
+        //         ctx.fillStyle = m.fieldMeterColor;
+        //         ctx.fillRect(xOff, yOff, 60 * m.energy, 10);
         //         ctx.beginPath()
-        //         ctx.rect(xOff, yOff, 60 * mech.maxEnergy, 10);
+        //         ctx.rect(xOff, yOff, 60 * m.maxEnergy, 10);
         //         ctx.strokeStyle = "rgb(0, 0, 0)";
         //         ctx.lineWidth = 1;
         //         ctx.stroke();
         //       }
-        //       if (mech.energy < 0) mech.energy = 0
+        //       if (m.energy < 0) m.energy = 0
         //     }
         //   }
         // },
@@ -2094,64 +2094,64 @@ const mech = {
             name: "pilot wave",
             description: "use <strong class='color-f'>energy</strong> to push <strong>blocks</strong> with your mouse<br>field <strong>radius</strong> decreases out of <strong>line of sight</strong><br>allows <strong class='color-m'>tech</strong> that normally require other <strong class='color-f'>fields</strong>",
             effect: () => {
-                mech.fieldPhase = 0;
-                mech.fieldPosition = {
+                m.fieldPhase = 0;
+                m.fieldPosition = {
                     x: simulation.mouseInGame.x,
                     y: simulation.mouseInGame.y
                 }
-                mech.lastFieldPosition = {
+                m.lastFieldPosition = {
                     x: simulation.mouseInGame.x,
                     y: simulation.mouseInGame.y
                 }
-                mech.fieldOn = false;
-                mech.fieldRadius = 0;
-                mech.drop();
-                mech.hold = function() {
+                m.fieldOn = false;
+                m.fieldRadius = 0;
+                m.drop();
+                m.hold = function() {
                     if (input.field) {
-                        if (mech.fieldCDcycle < mech.cycle) {
+                        if (m.fieldCDcycle < m.cycle) {
                             const scale = 25
                             const bounds = {
                                 min: {
-                                    x: mech.fieldPosition.x - scale,
-                                    y: mech.fieldPosition.y - scale
+                                    x: m.fieldPosition.x - scale,
+                                    y: m.fieldPosition.y - scale
                                 },
                                 max: {
-                                    x: mech.fieldPosition.x + scale,
-                                    y: mech.fieldPosition.y + scale
+                                    x: m.fieldPosition.x + scale,
+                                    y: m.fieldPosition.y + scale
                                 }
                             }
                             const isInMap = Matter.Query.region(map, bounds).length
-                            // const isInMap = Matter.Query.point(map, mech.fieldPosition).length
+                            // const isInMap = Matter.Query.point(map, m.fieldPosition).length
 
-                            if (!mech.fieldOn) { // if field was off, and it starting up, teleport to new mouse location
-                                mech.fieldOn = true;
-                                mech.fieldPosition = { //smooth the mouse position
+                            if (!m.fieldOn) { // if field was off, and it starting up, teleport to new mouse location
+                                m.fieldOn = true;
+                                m.fieldPosition = { //smooth the mouse position
                                     x: simulation.mouseInGame.x,
                                     y: simulation.mouseInGame.y
                                 }
-                                mech.lastFieldPosition = { //used to find velocity of field changes
-                                    x: mech.fieldPosition.x,
-                                    y: mech.fieldPosition.y
+                                m.lastFieldPosition = { //used to find velocity of field changes
+                                    x: m.fieldPosition.x,
+                                    y: m.fieldPosition.y
                                 }
                             } else { //when field is on it smoothly moves towards the mouse
-                                mech.lastFieldPosition = { //used to find velocity of field changes
-                                    x: mech.fieldPosition.x,
-                                    y: mech.fieldPosition.y
+                                m.lastFieldPosition = { //used to find velocity of field changes
+                                    x: m.fieldPosition.x,
+                                    y: m.fieldPosition.y
                                 }
                                 const smooth = isInMap ? 0.985 : 0.96;
-                                mech.fieldPosition = { //smooth the mouse position
-                                    x: mech.fieldPosition.x * smooth + simulation.mouseInGame.x * (1 - smooth),
-                                    y: mech.fieldPosition.y * smooth + simulation.mouseInGame.y * (1 - smooth),
+                                m.fieldPosition = { //smooth the mouse position
+                                    x: m.fieldPosition.x * smooth + simulation.mouseInGame.x * (1 - smooth),
+                                    y: m.fieldPosition.y * smooth + simulation.mouseInGame.y * (1 - smooth),
                                 }
                             }
 
                             //grab power ups into the field
                             for (let i = 0, len = powerUp.length; i < len; ++i) {
-                                const dxP = mech.fieldPosition.x - powerUp[i].position.x;
-                                const dyP = mech.fieldPosition.y - powerUp[i].position.y;
+                                const dxP = m.fieldPosition.x - powerUp[i].position.x;
+                                const dyP = m.fieldPosition.y - powerUp[i].position.y;
                                 const dist2 = dxP * dxP + dyP * dyP;
                                 // float towards field  if looking at and in range  or  if very close to player
-                                if (dist2 < mech.fieldRadius * mech.fieldRadius && (mech.lookingAt(powerUp[i]) || dist2 < 16000) && !(mech.health === mech.maxHealth && powerUp[i].name === "heal")) {
+                                if (dist2 < m.fieldRadius * m.fieldRadius && (m.lookingAt(powerUp[i]) || dist2 < 16000) && !(m.health === m.maxHealth && powerUp[i].name === "heal")) {
                                     powerUp[i].force.x += 7 * (dxP / dist2) * powerUp[i].mass;
                                     powerUp[i].force.y += 7 * (dyP / dist2) * powerUp[i].mass - powerUp[i].mass * simulation.g; //negate gravity
                                     //extra friction
@@ -2164,46 +2164,46 @@ const mech = {
                                         powerUp[i].effect();
                                         Matter.World.remove(engine.world, powerUp[i]);
                                         powerUp.splice(i, 1);
-                                        // mech.fieldRadius += 50
+                                        // m.fieldRadius += 50
                                         break; //because the array order is messed up after splice
                                     }
                                 }
                             }
                             //grab power ups normally too
-                            mech.grabPowerUp();
+                            m.grabPowerUp();
 
-                            if (mech.energy > 0.01) {
+                            if (m.energy > 0.01) {
                                 //find mouse velocity
-                                const diff = Vector.sub(mech.fieldPosition, mech.lastFieldPosition)
+                                const diff = Vector.sub(m.fieldPosition, m.lastFieldPosition)
                                 const speed = Vector.magnitude(diff)
                                 const velocity = Vector.mult(Vector.normalise(diff), Math.min(speed, 45)) //limit velocity
                                 let radius, radiusSmooth
-                                if (Matter.Query.ray(map, mech.fieldPosition, player.position).length) { //is there something block the player's view of the field
+                                if (Matter.Query.ray(map, m.fieldPosition, player.position).length) { //is there something block the player's view of the field
                                     radius = 0
                                     radiusSmooth = Math.max(0, isInMap ? 0.96 - 0.02 * speed : 0.995); //0.99
                                 } else {
                                     radius = Math.max(50, 250 - 2 * speed)
                                     radiusSmooth = 0.97
                                 }
-                                mech.fieldRadius = mech.fieldRadius * radiusSmooth + radius * (1 - radiusSmooth)
+                                m.fieldRadius = m.fieldRadius * radiusSmooth + radius * (1 - radiusSmooth)
 
                                 for (let i = 0, len = body.length; i < len; ++i) {
-                                    if (Vector.magnitude(Vector.sub(body[i].position, mech.fieldPosition)) < mech.fieldRadius && !body[i].isNotHoldable) {
+                                    if (Vector.magnitude(Vector.sub(body[i].position, m.fieldPosition)) < m.fieldRadius && !body[i].isNotHoldable) {
                                         const DRAIN = speed * body[i].mass * 0.000013
-                                        if (mech.energy > DRAIN) {
-                                            mech.energy -= DRAIN;
+                                        if (m.energy > DRAIN) {
+                                            m.energy -= DRAIN;
                                             Matter.Body.setVelocity(body[i], velocity); //give block mouse velocity
                                             Matter.Body.setAngularVelocity(body[i], body[i].angularVelocity * 0.8)
                                             // body[i].force.y -= body[i].mass * simulation.g; //remove gravity effects
                                             //blocks drift towards center of pilot wave
-                                            const sub = Vector.sub(mech.fieldPosition, body[i].position)
+                                            const sub = Vector.sub(m.fieldPosition, body[i].position)
                                             const unit = Vector.mult(Vector.normalise(sub), 0.00005 * Vector.magnitude(sub))
                                             body[i].force.x += unit.x
                                             body[i].force.y += unit.y - body[i].mass * simulation.g //remove gravity effects
                                         } else {
-                                            mech.fieldCDcycle = mech.cycle + 120;
-                                            mech.fieldOn = false
-                                            mech.fieldRadius = 0
+                                            m.fieldCDcycle = m.cycle + 120;
+                                            m.fieldOn = false
+                                            m.fieldRadius = 0
                                             break
                                         }
                                     }
@@ -2211,41 +2211,41 @@ const mech = {
 
                                 if (tech.isFreezeMobs) {
                                     for (let i = 0, len = mob.length; i < len; ++i) {
-                                        if (Vector.magnitude(Vector.sub(mob[i].position, mech.fieldPosition)) < mech.fieldRadius) {
+                                        if (Vector.magnitude(Vector.sub(mob[i].position, m.fieldPosition)) < m.fieldRadius) {
                                             mobs.statusSlow(mob[i], 120)
                                         }
                                     }
                                 }
 
                                 ctx.beginPath();
-                                const rotate = mech.cycle * 0.008;
-                                mech.fieldPhase += 0.2 // - 0.5 * Math.sqrt(Math.min(mech.energy, 1));
-                                const off1 = 1 + 0.06 * Math.sin(mech.fieldPhase);
-                                const off2 = 1 - 0.06 * Math.sin(mech.fieldPhase);
+                                const rotate = m.cycle * 0.008;
+                                m.fieldPhase += 0.2 // - 0.5 * Math.sqrt(Math.min(m.energy, 1));
+                                const off1 = 1 + 0.06 * Math.sin(m.fieldPhase);
+                                const off2 = 1 - 0.06 * Math.sin(m.fieldPhase);
                                 ctx.beginPath();
-                                ctx.ellipse(mech.fieldPosition.x, mech.fieldPosition.y, 1.2 * mech.fieldRadius * off1, 1.2 * mech.fieldRadius * off2, rotate, 0, 2 * Math.PI);
+                                ctx.ellipse(m.fieldPosition.x, m.fieldPosition.y, 1.2 * m.fieldRadius * off1, 1.2 * m.fieldRadius * off2, rotate, 0, 2 * Math.PI);
                                 ctx.globalCompositeOperation = "exclusion"; //"exclusion" "difference";
                                 ctx.fillStyle = "#fff"; //"#eef";
                                 ctx.fill();
                                 ctx.globalCompositeOperation = "source-over";
                                 ctx.beginPath();
-                                ctx.ellipse(mech.fieldPosition.x, mech.fieldPosition.y, 1.2 * mech.fieldRadius * off1, 1.2 * mech.fieldRadius * off2, rotate, 0, 2 * Math.PI * mech.energy / mech.maxEnergy);
+                                ctx.ellipse(m.fieldPosition.x, m.fieldPosition.y, 1.2 * m.fieldRadius * off1, 1.2 * m.fieldRadius * off2, rotate, 0, 2 * Math.PI * m.energy / m.maxEnergy);
                                 ctx.strokeStyle = "#000";
                                 ctx.lineWidth = 4;
                                 ctx.stroke();
                             } else {
-                                mech.fieldCDcycle = mech.cycle + 120;
-                                mech.fieldOn = false
-                                mech.fieldRadius = 0
+                                m.fieldCDcycle = m.cycle + 120;
+                                m.fieldOn = false
+                                m.fieldRadius = 0
                             }
                         } else {
-                            mech.grabPowerUp();
+                            m.grabPowerUp();
                         }
                     } else {
-                        mech.fieldOn = false
-                        mech.fieldRadius = 0
+                        m.fieldOn = false
+                        m.fieldRadius = 0
                     }
-                    mech.drawFieldMeter()
+                    m.drawFieldMeter()
                 }
             }
         },
@@ -2253,28 +2253,28 @@ const mech = {
             name: "wormhole",
             description: "use <strong class='color-f'>energy</strong> to <strong>tunnel</strong> through a <strong class='color-worm'>wormhole</strong><br><strong class='color-worm'>wormholes</strong> attract blocks and power ups<br><strong>10%</strong> chance to <strong class='color-dup'>duplicate</strong> spawned <strong>power ups</strong>", //<br>bullets may also traverse <strong class='color-worm'>wormholes</strong>
             effect: function() {
-                mech.drop();
-                mech.duplicateChance = 0.1
+                m.drop();
+                m.duplicateChance = 0.1
                 simulation.draw.powerUp = simulation.draw.powerUpBonus //change power up draw
 
                 // if (tech.isRewindGun) {
-                //     mech.hold = this.rewind
+                //     m.hold = this.rewind
                 // } else {
-                mech.hold = this.teleport
+                m.hold = this.teleport
                 // }
             },
             rewindCount: 0,
             // rewind: function() {
             //     if (input.down) {
-            //         if (input.field && mech.fieldCDcycle < mech.cycle) { //not hold but field button is pressed
+            //         if (input.field && m.fieldCDcycle < m.cycle) { //not hold but field button is pressed
             //             const DRAIN = 0.01
-            //             if (this.rewindCount < 289 && mech.energy > DRAIN) {
-            //                 mech.energy -= DRAIN
+            //             if (this.rewindCount < 289 && m.energy > DRAIN) {
+            //                 m.energy -= DRAIN
 
 
             //                 if (this.rewindCount === 0) {
             //                     const shortPause = function() {
-            //                         if (mech.defaultFPSCycle < mech.cycle) { //back to default values
+            //                         if (m.defaultFPSCycle < m.cycle) { //back to default values
             //                             simulation.fpsCap = simulation.fpsCapDefault
             //                             simulation.fpsInterval = 1000 / simulation.fpsCap;
             //                             // document.getElementById("dmg").style.transition = "opacity 1s";
@@ -2283,10 +2283,10 @@ const mech = {
             //                             requestAnimationFrame(shortPause);
             //                         }
             //                     };
-            //                     if (mech.defaultFPSCycle < mech.cycle) requestAnimationFrame(shortPause);
+            //                     if (m.defaultFPSCycle < m.cycle) requestAnimationFrame(shortPause);
             //                     simulation.fpsCap = 4 //1 is longest pause, 4 is standard
             //                     simulation.fpsInterval = 1000 / simulation.fpsCap;
-            //                     mech.defaultFPSCycle = mech.cycle
+            //                     m.defaultFPSCycle = m.cycle
             //                 }
 
 
@@ -2296,24 +2296,24 @@ const mech = {
             //                     ctx.fillStyle = `rgba(221,221,221,${0.004})`;
             //                     ctx.fillRect(0, 0, canvas.width, canvas.height);
             //                 }
-            //                 let history = mech.history[(mech.cycle - this.rewindCount) % 300]
+            //                 let history = m.history[(m.cycle - this.rewindCount) % 300]
             //                 Matter.Body.setPosition(player, history.position);
             //                 Matter.Body.setVelocity(player, { x: history.velocity.x, y: history.velocity.y });
-            //                 if (history.health > mech.health) {
-            //                     mech.health = history.health
-            //                     mech.displayHealth();
+            //                 if (history.health > m.health) {
+            //                     m.health = history.health
+            //                     m.displayHealth();
             //                 }
             //                 //grab power ups
             //                 for (let i = 0, len = powerUp.length; i < len; ++i) {
             //                     const dxP = player.position.x - powerUp[i].position.x;
             //                     const dyP = player.position.y - powerUp[i].position.y;
-            //                     if (dxP * dxP + dyP * dyP < 50000 && !simulation.isChoosing && !(mech.health === mech.maxHealth && powerUp[i].name === "heal")) {
+            //                     if (dxP * dxP + dyP * dyP < 50000 && !simulation.isChoosing && !(m.health === m.maxHealth && powerUp[i].name === "heal")) {
             //                         powerUps.onPickUp(player.position);
             //                         powerUp[i].effect();
             //                         Matter.World.remove(engine.world, powerUp[i]);
             //                         powerUp.splice(i, 1);
             //                         const shortPause = function() {
-            //                             if (mech.defaultFPSCycle < mech.cycle) { //back to default values
+            //                             if (m.defaultFPSCycle < m.cycle) { //back to default values
             //                                 simulation.fpsCap = simulation.fpsCapDefault
             //                                 simulation.fpsInterval = 1000 / simulation.fpsCap;
             //                                 // document.getElementById("dmg").style.transition = "opacity 1s";
@@ -2322,34 +2322,34 @@ const mech = {
             //                                 requestAnimationFrame(shortPause);
             //                             }
             //                         };
-            //                         if (mech.defaultFPSCycle < mech.cycle) requestAnimationFrame(shortPause);
+            //                         if (m.defaultFPSCycle < m.cycle) requestAnimationFrame(shortPause);
             //                         simulation.fpsCap = 3 //1 is longest pause, 4 is standard
             //                         simulation.fpsInterval = 1000 / simulation.fpsCap;
-            //                         mech.defaultFPSCycle = mech.cycle
+            //                         m.defaultFPSCycle = m.cycle
             //                         break; //because the array order is messed up after splice
             //                     }
             //                 }
-            //                 mech.immuneCycle = mech.cycle + 5; //player is immune to collision damage for 30 cycles
+            //                 m.immuneCycle = m.cycle + 5; //player is immune to collision damage for 30 cycles
             //             } else {
-            //                 mech.fieldCDcycle = mech.cycle + 30;
-            //                 // mech.resetHistory();
+            //                 m.fieldCDcycle = m.cycle + 30;
+            //                 // m.resetHistory();
             //             }
             //         } else {
             //             if (this.rewindCount !== 0) {
-            //                 mech.fieldCDcycle = mech.cycle + 30;
-            //                 mech.resetHistory();
+            //                 m.fieldCDcycle = m.cycle + 30;
+            //                 m.resetHistory();
             //                 this.rewindCount = 0;
             //                 simulation.wipe = function() { //set wipe to normal
             //                     ctx.clearRect(0, 0, canvas.width, canvas.height);
             //                 }
             //             }
-            //             mech.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
+            //             m.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
             //         }
             //     }
-            //     mech.drawFieldMeter()
+            //     m.drawFieldMeter()
             // },
             teleport: function() {
-                // mech.hole = {  //this is reset with each new field, but I'm leaving it here for reference
+                // m.hole = {  //this is reset with each new field, but I'm leaving it here for reference
                 //   isOn: false,
                 //   isReady: true,
                 //   pos1: {x: 0,y: 0},
@@ -2357,34 +2357,34 @@ const mech = {
                 //   angle: 0,
                 //   unit:{x:0,y:0},
                 // }
-                if (mech.hole.isOn) {
+                if (m.hole.isOn) {
                     // draw holes
-                    mech.fieldRange = 0.97 * mech.fieldRange + 0.03 * (50 + 10 * Math.sin(simulation.cycle * 0.025))
-                    const semiMajorAxis = mech.fieldRange + 30
-                    const edge1a = Vector.add(Vector.mult(mech.hole.unit, semiMajorAxis), mech.hole.pos1)
-                    const edge1b = Vector.add(Vector.mult(mech.hole.unit, -semiMajorAxis), mech.hole.pos1)
-                    const edge2a = Vector.add(Vector.mult(mech.hole.unit, semiMajorAxis), mech.hole.pos2)
-                    const edge2b = Vector.add(Vector.mult(mech.hole.unit, -semiMajorAxis), mech.hole.pos2)
+                    m.fieldRange = 0.97 * m.fieldRange + 0.03 * (50 + 10 * Math.sin(simulation.cycle * 0.025))
+                    const semiMajorAxis = m.fieldRange + 30
+                    const edge1a = Vector.add(Vector.mult(m.hole.unit, semiMajorAxis), m.hole.pos1)
+                    const edge1b = Vector.add(Vector.mult(m.hole.unit, -semiMajorAxis), m.hole.pos1)
+                    const edge2a = Vector.add(Vector.mult(m.hole.unit, semiMajorAxis), m.hole.pos2)
+                    const edge2b = Vector.add(Vector.mult(m.hole.unit, -semiMajorAxis), m.hole.pos2)
                     ctx.beginPath();
                     ctx.moveTo(edge1a.x, edge1a.y)
-                    ctx.bezierCurveTo(mech.hole.pos1.x, mech.hole.pos1.y, mech.hole.pos2.x, mech.hole.pos2.y, edge2a.x, edge2a.y);
+                    ctx.bezierCurveTo(m.hole.pos1.x, m.hole.pos1.y, m.hole.pos2.x, m.hole.pos2.y, edge2a.x, edge2a.y);
                     ctx.lineTo(edge2b.x, edge2b.y)
-                    ctx.bezierCurveTo(mech.hole.pos2.x, mech.hole.pos2.y, mech.hole.pos1.x, mech.hole.pos1.y, edge1b.x, edge1b.y);
-                    ctx.fillStyle = `rgba(255,255,255,${200 / mech.fieldRange / mech.fieldRange})` //"rgba(0,0,0,0.1)"
+                    ctx.bezierCurveTo(m.hole.pos2.x, m.hole.pos2.y, m.hole.pos1.x, m.hole.pos1.y, edge1b.x, edge1b.y);
+                    ctx.fillStyle = `rgba(255,255,255,${200 / m.fieldRange / m.fieldRange})` //"rgba(0,0,0,0.1)"
                     ctx.fill();
                     ctx.beginPath();
-                    ctx.ellipse(mech.hole.pos1.x, mech.hole.pos1.y, mech.fieldRange, semiMajorAxis, mech.hole.angle, 0, 2 * Math.PI)
-                    ctx.ellipse(mech.hole.pos2.x, mech.hole.pos2.y, mech.fieldRange, semiMajorAxis, mech.hole.angle, 0, 2 * Math.PI)
-                    ctx.fillStyle = `rgba(255,255,255,${32 / mech.fieldRange})`
+                    ctx.ellipse(m.hole.pos1.x, m.hole.pos1.y, m.fieldRange, semiMajorAxis, m.hole.angle, 0, 2 * Math.PI)
+                    ctx.ellipse(m.hole.pos2.x, m.hole.pos2.y, m.fieldRange, semiMajorAxis, m.hole.angle, 0, 2 * Math.PI)
+                    ctx.fillStyle = `rgba(255,255,255,${32 / m.fieldRange})`
                     ctx.fill();
 
                     //suck power ups
                     for (let i = 0, len = powerUp.length; i < len; ++i) {
                         //which hole is closer
-                        const dxP1 = mech.hole.pos1.x - powerUp[i].position.x;
-                        const dyP1 = mech.hole.pos1.y - powerUp[i].position.y;
-                        const dxP2 = mech.hole.pos2.x - powerUp[i].position.x;
-                        const dyP2 = mech.hole.pos2.y - powerUp[i].position.y;
+                        const dxP1 = m.hole.pos1.x - powerUp[i].position.x;
+                        const dyP1 = m.hole.pos1.y - powerUp[i].position.y;
+                        const dxP2 = m.hole.pos2.x - powerUp[i].position.x;
+                        const dyP2 = m.hole.pos2.y - powerUp[i].position.y;
                         let dxP, dyP, dist2
                         if (dxP1 * dxP1 + dyP1 * dyP1 < dxP2 * dxP2 + dyP2 * dyP2) {
                             dxP = dxP1
@@ -2394,7 +2394,7 @@ const mech = {
                             dyP = dyP2
                         }
                         dist2 = dxP * dxP + dyP * dyP;
-                        if (dist2 < 600000 && !(mech.health === mech.maxHealth && powerUp[i].name === "heal")) {
+                        if (dist2 < 600000 && !(m.health === m.maxHealth && powerUp[i].name === "heal")) {
                             powerUp[i].force.x += 4 * (dxP / dist2) * powerUp[i].mass; // float towards hole
                             powerUp[i].force.y += 4 * (dyP / dist2) * powerUp[i].mass - powerUp[i].mass * simulation.g; //negate gravity
                             Matter.Body.setVelocity(powerUp[i], { //extra friction
@@ -2402,7 +2402,7 @@ const mech = {
                                 y: powerUp[i].velocity.y * 0.05
                             });
                             if (dist2 < 1000 && !simulation.isChoosing) { //use power up if it is close enough
-                                mech.fieldRange *= 0.8
+                                m.fieldRange *= 0.8
                                 powerUps.onPickUp(powerUp[i]);
                                 powerUp[i].effect();
                                 Matter.World.remove(engine.world, powerUp[i]);
@@ -2418,28 +2418,28 @@ const mech = {
                     const slowScale = 0.9
                     for (let i = 0, len = body.length; i < len; i++) {
                         if (!body[i].isNotHoldable) {
-                            const dist1 = Vector.magnitude(Vector.sub(mech.hole.pos1, body[i].position))
-                            const dist2 = Vector.magnitude(Vector.sub(mech.hole.pos2, body[i].position))
+                            const dist1 = Vector.magnitude(Vector.sub(m.hole.pos1, body[i].position))
+                            const dist2 = Vector.magnitude(Vector.sub(m.hole.pos2, body[i].position))
                             if (dist1 < dist2) {
                                 if (dist1 < suckRange) {
-                                    const pull = Vector.mult(Vector.normalise(Vector.sub(mech.hole.pos1, body[i].position)), 1)
+                                    const pull = Vector.mult(Vector.normalise(Vector.sub(m.hole.pos1, body[i].position)), 1)
                                     const slow = Vector.mult(body[i].velocity, slowScale)
                                     Matter.Body.setVelocity(body[i], Vector.add(slow, pull));
                                     //shrink
-                                    if (Vector.magnitude(Vector.sub(mech.hole.pos1, body[i].position)) < shrinkRange) {
+                                    if (Vector.magnitude(Vector.sub(m.hole.pos1, body[i].position)) < shrinkRange) {
                                         Matter.Body.scale(body[i], shrinkScale, shrinkScale);
                                         if (body[i].mass < 0.05) {
                                             Matter.World.remove(engine.world, body[i]);
                                             body.splice(i, 1);
-                                            mech.fieldRange *= 0.8
-                                            if (tech.isWormholeEnergy) mech.energy += 0.5
+                                            m.fieldRange *= 0.8
+                                            if (tech.isWormholeEnergy) m.energy += 0.5
                                             if (tech.isWormSpores) { //pandimensionalspermia
                                                 for (let i = 0, len = Math.ceil(3 * Math.random()); i < len; i++) {
-                                                    b.spore(Vector.add(mech.hole.pos2, Vector.rotate({
-                                                        x: mech.fieldRange * 0.4,
+                                                    b.spore(Vector.add(m.hole.pos2, Vector.rotate({
+                                                        x: m.fieldRange * 0.4,
                                                         y: 0
                                                     }, 2 * Math.PI * Math.random())))
-                                                    Matter.Body.setVelocity(bullet[bullet.length - 1], Vector.mult(Vector.rotate(mech.hole.unit, Math.PI / 2), -15));
+                                                    Matter.Body.setVelocity(bullet[bullet.length - 1], Vector.mult(Vector.rotate(m.hole.unit, Math.PI / 2), -15));
                                                 }
                                             }
                                             break
@@ -2447,25 +2447,25 @@ const mech = {
                                     }
                                 }
                             } else if (dist2 < suckRange) {
-                                const pull = Vector.mult(Vector.normalise(Vector.sub(mech.hole.pos2, body[i].position)), 1)
+                                const pull = Vector.mult(Vector.normalise(Vector.sub(m.hole.pos2, body[i].position)), 1)
                                 const slow = Vector.mult(body[i].velocity, slowScale)
                                 Matter.Body.setVelocity(body[i], Vector.add(slow, pull));
                                 //shrink
-                                if (Vector.magnitude(Vector.sub(mech.hole.pos2, body[i].position)) < shrinkRange) {
+                                if (Vector.magnitude(Vector.sub(m.hole.pos2, body[i].position)) < shrinkRange) {
                                     Matter.Body.scale(body[i], shrinkScale, shrinkScale);
                                     if (body[i].mass < 0.05) {
                                         Matter.World.remove(engine.world, body[i]);
                                         body.splice(i, 1);
-                                        mech.fieldRange *= 0.8
-                                        // if (tech.isWormholeEnergy && mech.energy < mech.maxEnergy * 2) mech.energy = mech.maxEnergy * 2
-                                        if (tech.isWormholeEnergy) mech.energy += 0.5
+                                        m.fieldRange *= 0.8
+                                        // if (tech.isWormholeEnergy && m.energy < m.maxEnergy * 2) m.energy = m.maxEnergy * 2
+                                        if (tech.isWormholeEnergy) m.energy += 0.5
                                         if (tech.isWormSpores) { //pandimensionalspermia
                                             for (let i = 0, len = Math.ceil(3 * Math.random()); i < len; i++) {
-                                                b.spore(Vector.add(mech.hole.pos1, Vector.rotate({
-                                                    x: mech.fieldRange * 0.4,
+                                                b.spore(Vector.add(m.hole.pos1, Vector.rotate({
+                                                    x: m.fieldRange * 0.4,
                                                     y: 0
                                                 }, 2 * Math.PI * Math.random())))
-                                                Matter.Body.setVelocity(bullet[bullet.length - 1], Vector.mult(Vector.rotate(mech.hole.unit, Math.PI / 2), 15));
+                                                Matter.Body.setVelocity(bullet[bullet.length - 1], Vector.mult(Vector.rotate(m.hole.unit, Math.PI / 2), 15));
                                             }
                                         }
                                         break
@@ -2478,36 +2478,36 @@ const mech = {
                         //teleport bullets
                         for (let i = 0, len = bullet.length; i < len; ++i) { //teleport bullets from hole1 to hole2
                             if (!bullet[i].botType && !bullet[i].isInHole) { //don't teleport bots
-                                if (Vector.magnitude(Vector.sub(mech.hole.pos1, bullet[i].position)) < mech.fieldRange) { //find if bullet is touching hole1
-                                    Matter.Body.setPosition(bullet[i], Vector.add(mech.hole.pos2, Vector.sub(mech.hole.pos1, bullet[i].position)));
-                                    mech.fieldRange += 5
+                                if (Vector.magnitude(Vector.sub(m.hole.pos1, bullet[i].position)) < m.fieldRange) { //find if bullet is touching hole1
+                                    Matter.Body.setPosition(bullet[i], Vector.add(m.hole.pos2, Vector.sub(m.hole.pos1, bullet[i].position)));
+                                    m.fieldRange += 5
                                     bullet[i].isInHole = true
-                                } else if (Vector.magnitude(Vector.sub(mech.hole.pos2, bullet[i].position)) < mech.fieldRange) { //find if bullet is touching hole1
-                                    Matter.Body.setPosition(bullet[i], Vector.add(mech.hole.pos1, Vector.sub(mech.hole.pos2, bullet[i].position)));
-                                    mech.fieldRange += 5
+                                } else if (Vector.magnitude(Vector.sub(m.hole.pos2, bullet[i].position)) < m.fieldRange) { //find if bullet is touching hole1
+                                    Matter.Body.setPosition(bullet[i], Vector.add(m.hole.pos1, Vector.sub(m.hole.pos2, bullet[i].position)));
+                                    m.fieldRange += 5
                                     bullet[i].isInHole = true
                                 }
                             }
                         }
                         // mobs get pushed away
                         for (let i = 0, len = mob.length; i < len; i++) {
-                            if (Vector.magnitude(Vector.sub(mech.hole.pos1, mob[i].position)) < 200) {
-                                const pull = Vector.mult(Vector.normalise(Vector.sub(mech.hole.pos1, mob[i].position)), -0.07)
+                            if (Vector.magnitude(Vector.sub(m.hole.pos1, mob[i].position)) < 200) {
+                                const pull = Vector.mult(Vector.normalise(Vector.sub(m.hole.pos1, mob[i].position)), -0.07)
                                 Matter.Body.setVelocity(mob[i], Vector.add(mob[i].velocity, pull));
                             }
-                            if (Vector.magnitude(Vector.sub(mech.hole.pos2, mob[i].position)) < 200) {
-                                const pull = Vector.mult(Vector.normalise(Vector.sub(mech.hole.pos2, mob[i].position)), -0.07)
+                            if (Vector.magnitude(Vector.sub(m.hole.pos2, mob[i].position)) < 200) {
+                                const pull = Vector.mult(Vector.normalise(Vector.sub(m.hole.pos2, mob[i].position)), -0.07)
                                 Matter.Body.setVelocity(mob[i], Vector.add(mob[i].velocity, pull));
                             }
                         }
                     }
                 }
 
-                if (input.field && mech.fieldCDcycle < mech.cycle) { //not hold but field button is pressed
-                    const justPastMouse = Vector.add(Vector.mult(Vector.normalise(Vector.sub(simulation.mouseInGame, mech.pos)), 50), simulation.mouseInGame)
+                if (input.field && m.fieldCDcycle < m.cycle) { //not hold but field button is pressed
+                    const justPastMouse = Vector.add(Vector.mult(Vector.normalise(Vector.sub(simulation.mouseInGame, m.pos)), 50), simulation.mouseInGame)
                     const scale = 60
                     // console.log(Matter.Query.region(map, bounds))
-                    if (mech.hole.isReady &&
+                    if (m.hole.isReady &&
                         (
                             Matter.Query.region(map, {
                                 min: {
@@ -2519,27 +2519,27 @@ const mech = {
                                     y: simulation.mouseInGame.y + scale
                                 }
                             }).length === 0 &&
-                            Matter.Query.ray(map, mech.pos, justPastMouse).length === 0
-                            // Matter.Query.ray(map, mech.pos, simulation.mouseInGame).length === 0 &&
+                            Matter.Query.ray(map, m.pos, justPastMouse).length === 0
+                            // Matter.Query.ray(map, m.pos, simulation.mouseInGame).length === 0 &&
                             // Matter.Query.ray(map, player.position, simulation.mouseInGame).length === 0 &&
                             // Matter.Query.ray(map, player.position, justPastMouse).length === 0
                         )
                     ) {
-                        const sub = Vector.sub(simulation.mouseInGame, mech.pos)
+                        const sub = Vector.sub(simulation.mouseInGame, m.pos)
                         const mag = Vector.magnitude(sub)
                         const drain = 0.03 + 0.005 * Math.sqrt(mag)
-                        if (mech.energy > drain && mag > 300) {
-                            mech.energy -= drain
-                            mech.hole.isReady = false;
-                            mech.fieldRange = 0
+                        if (m.energy > drain && mag > 300) {
+                            m.energy -= drain
+                            m.hole.isReady = false;
+                            m.fieldRange = 0
                             Matter.Body.setPosition(player, simulation.mouseInGame);
-                            mech.buttonCD_jump = 0 //this might fix a bug with jumping
+                            m.buttonCD_jump = 0 //this might fix a bug with jumping
                             const velocity = Vector.mult(Vector.normalise(sub), 18)
                             Matter.Body.setVelocity(player, {
                                 x: velocity.x,
                                 y: velocity.y - 4 //an extra vertical kick so the player hangs in place longer
                             });
-                            mech.immuneCycle = mech.cycle + 15; //player is immune to collision damage 
+                            m.immuneCycle = m.cycle + 15; //player is immune to collision damage 
                             // move bots to follow player
                             for (let i = 0; i < bullet.length; i++) {
                                 if (bullet[i].botType) {
@@ -2555,16 +2555,16 @@ const mech = {
                             }
 
                             //set holes
-                            mech.hole.isOn = true;
-                            mech.hole.pos1.x = mech.pos.x
-                            mech.hole.pos1.y = mech.pos.y
-                            mech.hole.pos2.x = player.position.x
-                            mech.hole.pos2.y = player.position.y
-                            mech.hole.angle = Math.atan2(sub.y, sub.x)
-                            mech.hole.unit = Vector.perp(Vector.normalise(sub))
+                            m.hole.isOn = true;
+                            m.hole.pos1.x = m.pos.x
+                            m.hole.pos1.y = m.pos.y
+                            m.hole.pos2.x = player.position.x
+                            m.hole.pos2.y = player.position.y
+                            m.hole.angle = Math.atan2(sub.y, sub.x)
+                            m.hole.unit = Vector.perp(Vector.normalise(sub))
 
                             if (tech.isWormholeDamage) {
-                                who = Matter.Query.ray(mob, mech.pos, simulation.mouseInGame, 80)
+                                who = Matter.Query.ray(mob, m.pos, simulation.mouseInGame, 80)
                                 for (let i = 0; i < who.length; i++) {
                                     if (who[i].body.alive) {
                                         mobs.statusDoT(who[i].body, 0.6, 420)
@@ -2573,18 +2573,18 @@ const mech = {
                                 }
                             }
                         } else {
-                            mech.grabPowerUp();
+                            m.grabPowerUp();
                         }
                     } else {
-                        mech.grabPowerUp();
+                        m.grabPowerUp();
                     }
-                } else if (mech.holdingTarget && mech.fieldCDcycle < mech.cycle) { //holding, but field button is released
-                    mech.pickUp();
+                } else if (m.holdingTarget && m.fieldCDcycle < m.cycle) { //holding, but field button is released
+                    m.pickUp();
                 } else {
-                    mech.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
-                    mech.hole.isReady = true;
+                    m.holdingTarget = null; //clears holding target (this is so you only pick up right after the field button is released and a hold target exists)
+                    m.hole.isReady = true;
                 }
-                mech.drawFieldMeter()
+                m.drawFieldMeter()
             },
         },
     ],
diff --git a/js/powerup.js b/js/powerup.js
index 7eb1d0b..540a49d 100644
--- a/js/powerup.js
+++ b/js/powerup.js
@@ -12,8 +12,8 @@ const powerUps = {
             <br>input.key.previousGun<span class='color-symbol'>:</span> ["<span class='color-text'>${input.key.previousGun}</span>","<span class='color-text'>MouseWheel</span>"]`
             simulation.makeTextLog(text);
         } else if (type === "field") {
-            mech.setField(index)
-            simulation.makeTextLog(`<span class='color-var'>mech</span>.setField("<span class='color-text'>${mech.fieldUpgrades[mech.fieldMode].name}</span>")`);
+            m.setField(index)
+            simulation.makeTextLog(`<span class='color-var'>m</span>.setField("<span class='color-text'>${m.fieldUpgrades[m.fieldMode].name}</span>")`);
         } else if (type === "tech") {
             tech.giveTech(index)
             simulation.makeTextLog(`<span class='color-var'>tech</span>.giveTech("<span class='color-text'>${tech.tech[index].name}</span>")`);
@@ -38,13 +38,13 @@ const powerUps = {
         if (isCanceled) {
             if (tech.isCancelDuplication) tech.cancelCount++
             if (tech.isCancelRerolls) {
-                let spawnType = (mech.health < 0.25 || tech.isEnergyNoAmmo) ? "heal" : "ammo"
+                let spawnType = (m.health < 0.25 || tech.isEnergyNoAmmo) ? "heal" : "ammo"
                 if (Math.random() < 0.33) {
                     spawnType = "heal"
                 } else if (Math.random() < 0.5 && !tech.isSuperDeterminism) {
                     spawnType = "research"
                 }
-                for (let i = 0; i < 6; i++) powerUps.spawn(mech.pos.x + 40 * (Math.random() - 0.5), mech.pos.y + 40 * (Math.random() - 0.5), spawnType, false);
+                for (let i = 0; i < 6; i++) powerUps.spawn(m.pos.x + 40 * (Math.random() - 0.5), m.pos.y + 40 * (Math.random() - 0.5), spawnType, false);
             }
             if (tech.isBanish && type === 'tech') { // banish researched tech by adding them to the list of banished tech
                 const banishLength = tech.isDeterminism ? 1 : 3 + tech.isExtraChoice * 2
@@ -57,7 +57,7 @@ const powerUps = {
             }
         }
         if (tech.manyWorlds && powerUps.research.count === 0) {
-            for (let i = 0; i < 2; i++) powerUps.spawn(mech.pos.x + 40 * (Math.random() - 0.5), mech.pos.y + 40 * (Math.random() - 0.5), "research", false);
+            for (let i = 0; i < 2; i++) powerUps.spawn(m.pos.x + 40 * (Math.random() - 0.5), m.pos.y + 40 * (Math.random() - 0.5), "research", false);
         }
         document.getElementById("choose-grid").style.display = "none"
         document.getElementById("choose-background").style.display = "none"
@@ -65,7 +65,7 @@ const powerUps = {
         document.body.style.overflow = "hidden"
         simulation.paused = false;
         simulation.isChoosing = false; //stops p from un pausing on key down
-        mech.immuneCycle = mech.cycle + 60; //player is immune to collision damage for 30 cycles
+        m.immuneCycle = m.cycle + 60; //player is immune to collision damage for 30 cycles
         build.unPauseGrid()
         requestAnimationFrame(cycle);
     },
@@ -95,8 +95,8 @@ const powerUps = {
                     if (tech.renormalization) {
                         for (let i = 0; i < limit; i++) {
                             if (Math.random() < 0.37) {
-                                mech.fieldCDcycle = mech.cycle + 30;
-                                powerUps.spawn(mech.pos.x, mech.pos.y, "research");
+                                m.fieldCDcycle = m.cycle + 30;
+                                powerUps.spawn(m.pos.x, m.pos.y, "research");
                             }
                         }
                     }
@@ -105,7 +105,7 @@ const powerUps = {
             if (tech.isDeathAvoid && document.getElementById("tech-anthropic")) {
                 document.getElementById("tech-anthropic").innerHTML = `-${powerUps.research.count}`
             }
-            if (tech.renormalization && Math.random() < 0.37 && amount < 0) powerUps.spawn(mech.pos.x, mech.pos.y, "research");
+            if (tech.renormalization && Math.random() < 0.37 && amount < 0) powerUps.spawn(m.pos.x, m.pos.y, "research");
             if (tech.isRerollHaste) {
                 if (powerUps.research.count === 0) {
                     tech.researchHaste = 0.66;
@@ -118,7 +118,7 @@ const powerUps = {
         },
         use(type) { //runs when you actually research a list of selections, type can be field, gun, or tech
             powerUps.research.changeRerolls(-1)
-            // simulation.makeTextLog(`<span class='color-var'>mech</span>.<span class='color-r'>research</span><span class='color-symbol'>--</span>
+            // simulation.makeTextLog(`<span class='color-var'>m</span>.<span class='color-r'>research</span><span class='color-symbol'>--</span>
             // <br>${powerUps.research.count}`)
             if (tech.isBanish && type === 'tech') { // banish researched tech
                 const banishLength = tech.isDeterminism ? 1 : 3 + tech.isExtraChoice * 2
@@ -140,18 +140,18 @@ const powerUps = {
             return 40 * (simulation.healScale ** 0.25) * Math.sqrt(tech.largerHeals) * Math.sqrt(0.1 + Math.random() * 0.5); //(simulation.healScale ** 0.25)  gives a smaller radius as heal scale goes down
         },
         effect() {
-            if (!tech.isEnergyHealth && mech.alive) {
-                const heal = tech.largerHeals * (this.size / 40 / Math.sqrt(tech.largerHeals) / (simulation.healScale ** 0.25)) ** 2 //heal scale is undone here because heal scale is properly affected on mech.addHealth()
+            if (!tech.isEnergyHealth && m.alive) {
+                const heal = tech.largerHeals * (this.size / 40 / Math.sqrt(tech.largerHeals) / (simulation.healScale ** 0.25)) ** 2 //heal scale is undone here because heal scale is properly affected on m.addHealth()
                 if (heal > 0) {
-                    const healOutput = Math.min(mech.maxHealth - mech.health, heal) * simulation.healScale
-                    mech.addHealth(heal);
-                    simulation.makeTextLog(`<span class='color-var'>mech</span>.health <span class='color-symbol'>+=</span> ${(healOutput).toFixed(3)}`) // <br>${mech.health.toFixed(3)}
-                    // simulation.makeTextLog("<div class='circle heal'></div> &nbsp; <span style='font-size:115%;'> <strong style = 'letter-spacing: 2px;'>heal</strong>  " + (Math.min(mech.maxHealth - mech.health, heal) * simulation.healScale * 100).toFixed(0) + "%</span>", 300)
+                    const healOutput = Math.min(m.maxHealth - m.health, heal) * simulation.healScale
+                    m.addHealth(heal);
+                    simulation.makeTextLog(`<span class='color-var'>m</span>.health <span class='color-symbol'>+=</span> ${(healOutput).toFixed(3)}`) // <br>${m.health.toFixed(3)}
+                    // simulation.makeTextLog("<div class='circle heal'></div> &nbsp; <span style='font-size:115%;'> <strong style = 'letter-spacing: 2px;'>heal</strong>  " + (Math.min(m.maxHealth - m.health, heal) * simulation.healScale * 100).toFixed(0) + "%</span>", 300)
                 }
             }
             if (tech.healGiveMaxEnergy) {
                 tech.healMaxEnergyBonus += 0.04
-                mech.setMaxEnergy();
+                m.setMaxEnergy();
             }
         },
         spawn(x, y, size) { //used to spawn a heal with a specific size / heal amount, not normally used
@@ -201,7 +201,7 @@ const powerUps = {
             function pick(who, skip1 = -1, skip2 = -1, skip3 = -1, skip4 = -1) {
                 let options = [];
                 for (let i = 1; i < who.length; i++) {
-                    if (i !== mech.fieldMode && i !== skip1 && i !== skip2 && i !== skip3 && i !== skip4) options.push(i);
+                    if (i !== m.fieldMode && i !== skip1 && i !== skip2 && i !== skip3 && i !== skip4) options.push(i);
                 }
                 //remove repeats from last selection
                 const totalChoices = tech.isDeterminism ? 1 : 3 + tech.isExtraChoice * 2
@@ -222,25 +222,25 @@ const powerUps = {
                 }
             }
 
-            let choice1 = pick(mech.fieldUpgrades)
+            let choice1 = pick(m.fieldUpgrades)
             let choice2 = -1
             let choice3 = -1
             if (choice1 > -1) {
                 let text = ""
                 if (!tech.isDeterminism) text += `<div class='cancel' onclick='powerUps.endDraft("field",true)'>✕</div>`
                 text += `<h3 style = 'color:#fff; text-align:left; margin: 0px;'>field</h3>`
-                text += `<div class="choose-grid-module" onclick="powerUps.choose('field',${choice1})"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${mech.fieldUpgrades[choice1].name}</div> ${mech.fieldUpgrades[choice1].description}</div>`
+                text += `<div class="choose-grid-module" onclick="powerUps.choose('field',${choice1})"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${m.fieldUpgrades[choice1].name}</div> ${m.fieldUpgrades[choice1].description}</div>`
                 if (!tech.isDeterminism) {
-                    choice2 = pick(mech.fieldUpgrades, choice1)
-                    if (choice2 > -1) text += `<div class="choose-grid-module" onclick="powerUps.choose('field',${choice2})"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${mech.fieldUpgrades[choice2].name}</div> ${mech.fieldUpgrades[choice2].description}</div>`
-                    choice3 = pick(mech.fieldUpgrades, choice1, choice2)
-                    if (choice3 > -1) text += `<div class="choose-grid-module" onclick="powerUps.choose('field',${choice3})"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${mech.fieldUpgrades[choice3].name}</div> ${mech.fieldUpgrades[choice3].description}</div>`
+                    choice2 = pick(m.fieldUpgrades, choice1)
+                    if (choice2 > -1) text += `<div class="choose-grid-module" onclick="powerUps.choose('field',${choice2})"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${m.fieldUpgrades[choice2].name}</div> ${m.fieldUpgrades[choice2].description}</div>`
+                    choice3 = pick(m.fieldUpgrades, choice1, choice2)
+                    if (choice3 > -1) text += `<div class="choose-grid-module" onclick="powerUps.choose('field',${choice3})"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${m.fieldUpgrades[choice3].name}</div> ${m.fieldUpgrades[choice3].description}</div>`
                 }
                 if (tech.isExtraChoice) {
-                    let choice4 = pick(mech.fieldUpgrades, choice1, choice2, choice3)
-                    if (choice4 > -1) text += `<div class="choose-grid-module" onclick="powerUps.choose('field',${choice4})"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${mech.fieldUpgrades[choice4].name}</div> ${mech.fieldUpgrades[choice4].description}</div>`
-                    let choice5 = pick(mech.fieldUpgrades, choice1, choice2, choice3, choice4)
-                    if (choice5 > -1) text += `<div class="choose-grid-module" onclick="powerUps.choose('field',${choice5})"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${mech.fieldUpgrades[choice5].name}</div> ${mech.fieldUpgrades[choice5].description}</div>`
+                    let choice4 = pick(m.fieldUpgrades, choice1, choice2, choice3)
+                    if (choice4 > -1) text += `<div class="choose-grid-module" onclick="powerUps.choose('field',${choice4})"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${m.fieldUpgrades[choice4].name}</div> ${m.fieldUpgrades[choice4].description}</div>`
+                    let choice5 = pick(m.fieldUpgrades, choice1, choice2, choice3, choice4)
+                    if (choice5 > -1) text += `<div class="choose-grid-module" onclick="powerUps.choose('field',${choice5})"><div class="grid-title"><div class="circle-grid field"></div> &nbsp; ${m.fieldUpgrades[choice5].name}</div> ${m.fieldUpgrades[choice5].description}</div>`
                     powerUps.field.choiceLog.push(choice4)
                     powerUps.field.choiceLog.push(choice5)
                 }
@@ -272,7 +272,7 @@ const powerUps = {
         lastTotalChoices: 0, //tracks how many tech were available for random selection last time a tech was picked up
         banishLog: [], //records all tech permanently removed from the selection pool
         effect() {
-            if (mech.alive) {
+            if (m.alive) {
                 function pick(skip1 = -1, skip2 = -1, skip3 = -1, skip4 = -1) {
                     let options = [];
                     for (let i = 0; i < tech.tech.length; i++) {
@@ -378,7 +378,7 @@ const powerUps = {
                         }
                         // simulation.makeTextLog(`No <strong class='color-m'>tech</strong> left<br>erased <strong class='color-m'>tech</strong> have been recovered`)
                         simulation.makeTextLog(`powerUps.tech.length: ${Math.max(0,powerUps.tech.lastTotalChoices - powerUps.tech.banishLog.length)}`)
-                        powerUps.spawn(mech.pos.x, mech.pos.y, "tech");
+                        powerUps.spawn(m.pos.x, m.pos.y, "tech");
                         powerUps.endDraft("tech");
                     } else {
                         powerUps.giveRandomAmmo()
@@ -465,8 +465,8 @@ const powerUps = {
         }
     },
     onPickUp(who) {
-        if (tech.isTechDamage && who.name === "tech") mech.damage(0.11)
-        if (tech.isMassEnergy) mech.energy += 2.5;
+        if (tech.isTechDamage && who.name === "tech") m.damage(0.11)
+        if (tech.isMassEnergy) m.energy += 2.5;
         if (tech.isMineDrop) {
             if (tech.isLaserMine) { //laser mine
                 b.laserMine(who.position)
@@ -485,7 +485,7 @@ const powerUps = {
         }
     },
     spawnRandomPowerUp(x, y) { //mostly used after mob dies,  doesn't always return a power up
-        if ((Math.random() * Math.random() - 0.3 > Math.sqrt(mech.health) && !tech.isEnergyHealth) || Math.random() < 0.04) { //spawn heal chance is higher at low health
+        if ((Math.random() * Math.random() - 0.3 > Math.sqrt(m.health) && !tech.isEnergyHealth) || Math.random() < 0.04) { //spawn heal chance is higher at low health
             powerUps.spawn(x, y, "heal");
             return;
         }
@@ -512,7 +512,7 @@ const powerUps = {
     },
     randomPowerUpCounter: 0,
     spawnBossPowerUp(x, y) { //boss spawns field and gun tech upgrades
-        if (mech.fieldMode === 0) {
+        if (m.fieldMode === 0) {
             powerUps.spawn(x, y, "field")
         } else {
             powerUps.randomPowerUpCounter++;
@@ -530,7 +530,7 @@ const powerUps = {
                     powerUps.spawn(x, y, "gun")
                 }
             } else {
-                if (mech.health < 0.65 && !tech.isEnergyHealth) {
+                if (m.health < 0.65 && !tech.isEnergyHealth) {
                     powerUps.spawn(x, y, "heal");
                     powerUps.spawn(x, y, "heal");
                 } else {
@@ -560,7 +560,7 @@ const powerUps = {
             //bonus power ups for clearing runs in the last game
             if (level.levelsCleared === 0 && !simulation.isCheating) {
                 for (let i = 0; i < localSettings.levelsClearedLastGame / 4 - 1; i++) {
-                    powerUps.spawn(mech.pos.x, mech.pos.y, "tech", false); //spawn a tech for levels cleared in last game
+                    powerUps.spawn(m.pos.x, m.pos.y, "tech", false); //spawn a tech for levels cleared in last game
                 }
                 localSettings.levelsClearedLastGame = 0 //after getting bonus power ups reset run history
                 localStorage.setItem("localSettings", JSON.stringify(localSettings)); //update local storage
@@ -601,7 +601,7 @@ const powerUps = {
                 simulation.makeTextLog(`<span class='color-var'>tech</span>.remove("<span class='color-text'>${tech.tech[choose].name}</span>")`)
 
                 for (let i = 0; i < tech.tech[choose].count; i++) {
-                    powerUps.directSpawn(mech.pos.x, mech.pos.y, "tech");
+                    powerUps.directSpawn(m.pos.x, m.pos.y, "tech");
                     powerUp[powerUp.length - 1].isBonus = true
                 }
                 // remove a random tech from the list of tech you have
@@ -609,14 +609,14 @@ const powerUps = {
                 tech.tech[choose].count = 0;
                 tech.tech[choose].isLost = true;
                 simulation.updateTechHUD();
-                mech.fieldCDcycle = mech.cycle + 30; //disable field so you can't pick up the ejected tech
+                m.fieldCDcycle = m.cycle + 30; //disable field so you can't pick up the ejected tech
             }
         } else {
             // simulation.makeTextLog(`<div class='circle tech'></div> &nbsp; <strong>${tech.tech[choose].name}</strong> was ejected`, 600) //message about what tech was lost
             simulation.makeTextLog(`<span class='color-var'>tech</span>.remove("<span class='color-text'>${tech.tech[choose].name}</span>")`)
 
             for (let i = 0; i < tech.tech[choose].count; i++) {
-                powerUps.directSpawn(mech.pos.x, mech.pos.y, "tech");
+                powerUps.directSpawn(m.pos.x, m.pos.y, "tech");
                 powerUp[powerUp.length - 1].isBonus = true
             }
             // remove a random tech from the list of tech you have
@@ -624,7 +624,7 @@ const powerUps = {
             tech.tech[choose].count = 0;
             tech.tech[choose].isLost = true;
             simulation.updateTechHUD();
-            mech.fieldCDcycle = mech.cycle + 30; //disable field so you can't pick up the ejected tech
+            m.fieldCDcycle = m.cycle + 30; //disable field so you can't pick up the ejected tech
         }
     },
     directSpawn(x, y, target, moving = true, mode = null, size = powerUps[target].size()) {
diff --git a/js/simulation.js b/js/simulation.js
index 7147dba..dc7f807 100644
--- a/js/simulation.js
+++ b/js/simulation.js
@@ -7,15 +7,15 @@ const simulation = {
         Engine.update(engine, simulation.delta);
         simulation.wipe();
         simulation.textLog();
-        if (mech.onGround) {
-            mech.groundControl()
+        if (m.onGround) {
+            m.groundControl()
         } else {
-            mech.airControl()
+            m.airControl()
         }
         // level.checkZones();
         level.checkQuery();
-        mech.move();
-        mech.look();
+        m.move();
+        m.look();
         simulation.checks();
         ctx.save();
         simulation.camera();
@@ -29,8 +29,8 @@ const simulation = {
         simulation.draw.body();
         mobs.loop();
         mobs.healthBar();
-        mech.draw();
-        mech.hold();
+        m.draw();
+        m.hold();
         // v.draw(); //working on visibility work in progress
         level.drawFills();
         level.customTopLayer();
@@ -50,20 +50,20 @@ const simulation = {
         Engine.update(engine, simulation.delta);
         simulation.wipe();
         simulation.textLog();
-        if (mech.onGround) {
-            mech.groundControl()
+        if (m.onGround) {
+            m.groundControl()
         } else {
-            mech.airControl()
+            m.airControl()
         }
         // level.checkZones();
         level.custom();
         level.checkQuery();
-        mech.move();
-        mech.look();
+        m.move();
+        m.look();
         simulation.checks();
         ctx.save();
         simulation.camera();
-        mech.draw();
+        m.draw();
         level.customTopLayer();
         simulation.draw.wireFrame();
         simulation.draw.cons();
@@ -79,24 +79,24 @@ const simulation = {
         simulation.isTimeSkipping = true;
         for (let i = 0; i < cycles; i++) {
             simulation.cycle++;
-            mech.cycle++;
+            m.cycle++;
             simulation.gravity();
             Engine.update(engine, simulation.delta);
-            if (mech.onGround) {
-                mech.groundControl()
+            if (m.onGround) {
+                m.groundControl()
             } else {
-                mech.airControl()
+                m.airControl()
             }
 
             level.checkZones();
             level.checkQuery();
-            mech.move();
+            m.move();
             simulation.checks();
             mobs.loop();
-            // mech.draw();
-            mech.walk_cycle += mech.flipLegs * mech.Vx;
+            // m.draw();
+            m.walk_cycle += m.flipLegs * m.Vx;
 
-            mech.hold();
+            m.hold();
             b.fire();
             b.bulletRemove();
             b.bulletDo();
@@ -326,18 +326,18 @@ const simulation = {
     // SVGrightMouse: '<svg viewBox="750 0 200 765" class="mouse-icon" width="40px" height = "60px" stroke-linecap="round" stroke-linejoin="round" stroke-width="25px" stroke="#000" fill="none">  <path fill="#fff" stroke="none" d="M827,112 h30 a140,140,0,0,1,140,140 v268 a140,140,0,0,1-140,140 h-60 a140,140,0,0,1-140-140v-268 a140,140,0,0,1,140-140h60" />  <path d="M827,112 h30 a140,140,0,0,1,140,140 v68 h-167 z" fill="#0cf" stroke="none" />  <path fill="none" d="M827,112 h30 a140,140,0,0,1,140,140 v268 a140,140,0,0,1-140,140 h-60 a140,140,0,0,1-140-140v-268 a140,140,0,0,1,140-140h60" />  <path d="M657 317 h 340 h-170 v-207" />  <ellipse fill="#fff" cx="827.57" cy="218.64" rx="29" ry="68" />  </svg>',
     makeTextLog(text, time = 120) {
         if (simulation.isTextLogOpen && !build.isExperimentSelection) {
-            if (simulation.lastLogTime > mech.cycle) { //if there is an older message
+            if (simulation.lastLogTime > m.cycle) { //if there is an older message
                 document.getElementById("text-log").innerHTML = document.getElementById("text-log").innerHTML + '<br>' + text;
-                simulation.lastLogTime = mech.cycle + time;
+                simulation.lastLogTime = m.cycle + time;
             } else {
                 document.getElementById("text-log").innerHTML = text;
                 document.getElementById("text-log").style.opacity = 1;
-                simulation.lastLogTime = mech.cycle + time;
+                simulation.lastLogTime = m.cycle + time;
             }
         }
     },
     textLog() {
-        if (simulation.lastLogTime && simulation.lastLogTime < mech.cycle) {
+        if (simulation.lastLogTime && simulation.lastLogTime < m.cycle) {
             simulation.lastLogTime = 0;
             // document.getElementById("text-log").innerHTML = " ";
             document.getElementById("text-log").style.opacity = 0;
@@ -362,19 +362,19 @@ const simulation = {
         b.activeGun = b.inventory[b.inventoryGun];
         simulation.updateGunHUD();
         simulation.boldActiveGunHUD();
-        // mech.drop();
-        if (true && powerUps.research.count > 0) {
+        // m.drop();
+        if (tech.isGunSwitchField && powerUps.research.count > 0) {
             powerUps.research.changeRerolls(-1)
-            const energy = mech.energy
-            mech.setField((mech.fieldMode === mech.fieldUpgrades.length - 1) ? 1 : mech.fieldMode + 1) //cycle to next field
-            mech.energy = energy //field swap sets energy to max, this undoes that
+            const energy = m.energy
+            m.setField((m.fieldMode === m.fieldUpgrades.length - 1) ? 1 : m.fieldMode + 1) //cycle to next field
+            m.energy = energy //field swap sets energy to max, this undoes that
 
             //update text to show next field
             for (let i = tech.tech.length - 1; i > 0; i--) {
                 if (tech.tech[i].name === "unified field theory") {
-                    const index = (mech.fieldMode === mech.fieldUpgrades.length - 1) ? 1 : mech.fieldMode + 1
+                    const index = (m.fieldMode === m.fieldUpgrades.length - 1) ? 1 : m.fieldMode + 1
                     tech.tech[i].description = `after switching <strong>guns</strong><br>use a <strong class='color-r'>research</strong> to cycle your <strong class='color-f'>field</strong>
-                    <br>(next <strong class='color-f'>field</strong>: ${mech.fieldUpgrades[index].name})`
+                    <br>(next <strong class='color-f'>field</strong>: ${m.fieldUpgrades[index].name})`
                     break
                 }
             }
@@ -435,13 +435,13 @@ const simulation = {
     },
     noCameraScroll() { //makes the camera not scroll after changing locations
         //only works if velocity is zero
-        mech.pos.x = player.position.x;
-        mech.pos.y = playerBody.position.y - mech.yOff;
+        m.pos.x = player.position.x;
+        m.pos.y = playerBody.position.y - m.yOff;
         const scale = 0.8;
-        mech.transSmoothX = canvas.width2 - mech.pos.x - (simulation.mouse.x - canvas.width2) * scale;
-        mech.transSmoothY = canvas.height2 - mech.pos.y - (simulation.mouse.y - canvas.height2) * scale;
-        mech.transX += (mech.transSmoothX - mech.transX) * 1;
-        mech.transY += (mech.transSmoothY - mech.transY) * 1;
+        m.transSmoothX = canvas.width2 - m.pos.x - (simulation.mouse.x - canvas.width2) * scale;
+        m.transSmoothY = canvas.height2 - m.pos.y - (simulation.mouse.y - canvas.height2) * scale;
+        m.transX += (m.transSmoothX - m.transX) * 1;
+        m.transY += (m.transSmoothY - m.transY) * 1;
     },
     edgeZoomOutSmooth: 1,
     camera() {
@@ -455,10 +455,10 @@ const simulation = {
         ctx.save();
         ctx.translate(canvas.width2, canvas.height2); //center
         ctx.scale(simulation.zoom / simulation.edgeZoomOutSmooth, simulation.zoom / simulation.edgeZoomOutSmooth); //zoom in once centered
-        ctx.translate(-canvas.width2 + mech.transX, -canvas.height2 + mech.transY); //translate
+        ctx.translate(-canvas.width2 + m.transX, -canvas.height2 + m.transY); //translate
         //calculate in game mouse position by undoing the zoom and translations
-        simulation.mouseInGame.x = (simulation.mouse.x - canvas.width2) / simulation.zoom * simulation.edgeZoomOutSmooth + canvas.width2 - mech.transX;
-        simulation.mouseInGame.y = (simulation.mouse.y - canvas.height2) / simulation.zoom * simulation.edgeZoomOutSmooth + canvas.height2 - mech.transY;
+        simulation.mouseInGame.x = (simulation.mouse.x - canvas.width2) / simulation.zoom * simulation.edgeZoomOutSmooth + canvas.width2 - m.transX;
+        simulation.mouseInGame.y = (simulation.mouse.y - canvas.height2) / simulation.zoom * simulation.edgeZoomOutSmooth + canvas.height2 - m.transY;
     },
     restoreCamera() {
         ctx.restore();
@@ -510,7 +510,7 @@ const simulation = {
         document.getElementById("splash").style.display = "none"; //hides the element that spawned the function
         document.getElementById("dmg").style.display = "inline";
         document.getElementById("health-bg").style.display = "inline";
-        mech.spawn(); //spawns the player
+        m.spawn(); //spawns the player
 
         level.levels = level.playableLevels.slice(0) //copy array, not by just by assignment
         if (simulation.isCommunityMaps) {
@@ -546,15 +546,15 @@ const simulation = {
         // simulation.updateTechHUD();
         powerUps.totalPowerUps = 0;
         powerUps.research.count = 0;
-        mech.setFillColors();
-        // mech.maxHealth = 1
-        // mech.maxEnergy = 1
-        // mech.energy = 1
+        m.setFillColors();
+        // m.maxHealth = 1
+        // m.maxEnergy = 1
+        // m.energy = 1
         input.isPauseKeyReady = true
         simulation.wipe = function() { //set wipe to normal
             ctx.clearRect(0, 0, canvas.width, canvas.height);
         }
-        mech.hole.isOn = false
+        m.hole.isOn = false
         simulation.paused = false;
         engine.timing.timeScale = 1;
         simulation.fpsCap = simulation.fpsCapDefault;
@@ -579,25 +579,25 @@ const simulation = {
         document.getElementById("fade-out").style.opacity = 0;
         document.title = "n-gon";
 
-        mech.alive = true;
-        mech.setMaxHealth()
-        mech.health = 0;
-        mech.addHealth(0.25)
-        mech.drop();
-        mech.holdingTarget = null
+        m.alive = true;
+        m.setMaxHealth()
+        m.health = 0;
+        m.addHealth(0.25)
+        m.drop();
+        m.holdingTarget = null
 
         //set to default field
-        mech.fieldMode = 0;
-        // simulation.makeTextLog(`${simulation.SVGrightMouse}<strong style='font-size:30px;'> ${mech.fieldUpgrades[mech.fieldMode].name}</strong><br><span class='faded'></span><br>${mech.fieldUpgrades[mech.fieldMode].description}`, 600);
+        m.fieldMode = 0;
+        // simulation.makeTextLog(`${simulation.SVGrightMouse}<strong style='font-size:30px;'> ${m.fieldUpgrades[m.fieldMode].name}</strong><br><span class='faded'></span><br>${m.fieldUpgrades[m.fieldMode].description}`, 600);
         // simulation.makeTextLog(`
         // input.key.up <span class='color-symbol'>=</span> ["<span class='color-text'>${input.key.up}</span>", "<span class='color-text'>ArrowUp</span>"]
         // <br>input.key.left <span class='color-symbol'>=</span> ["<span class='color-text'>${input.key.left}</span>", "<span class='color-text'>ArrowLeft</span>"]
         // <br>input.key.down <span class='color-symbol'>=</span> ["<span class='color-text'>${input.key.down}</span>", "<span class='color-text'>ArrowDown</span>"]
         // <br>input.key.right <span class='color-symbol'>=</span> ["<span class='color-text'>${input.key.right}</span>", "<span class='color-text'>ArrowRight</span>"]
         // <br>
-        // <br><span class='color-var'>mech</span>.fieldMode <span class='color-symbol'>=</span> "<span class='color-text'>${mech.fieldUpgrades[mech.fieldMode].name}</span>"
+        // <br><span class='color-var'>m</span>.fieldMode <span class='color-symbol'>=</span> "<span class='color-text'>${m.fieldUpgrades[m.fieldMode].name}</span>"
         // <br>input.key.field <span class='color-symbol'>=</span> ["<span class='color-text'>${input.key.field}</span>", "<span class='color-text'>right mouse</span>"]
-        // <br><span class='color-var'>mech</span>.field.description <span class='color-symbol'>=</span> "<span class='color-text'>${mech.fieldUpgrades[mech.fieldMode].description}</span>"
+        // <br><span class='color-var'>m</span>.field.description <span class='color-symbol'>=</span> "<span class='color-text'>${m.fieldUpgrades[m.fieldMode].description}</span>"
         // `, 800);
 
 
@@ -616,14 +616,14 @@ const simulation = {
             simulation.makeTextLog(`input.key.right<span class='color-symbol'>:</span> ["<span class='color-text'>${input.key.right}</span>", "<span class='color-text'>ArrowRight</span>"]`);
         }, delay += step);
         setTimeout(function() {
-            simulation.makeTextLog(`<br><span class='color-var'>mech</span>.fieldMode <span class='color-symbol'>=</span> "<span class='color-text'>${mech.fieldUpgrades[mech.fieldMode].name}</span>"`);
+            simulation.makeTextLog(`<br><span class='color-var'>m</span>.fieldMode <span class='color-symbol'>=</span> "<span class='color-text'>${m.fieldUpgrades[m.fieldMode].name}</span>"`);
         }, delay += step);
         setTimeout(function() {
             simulation.makeTextLog(`input.key.field<span class='color-symbol'>:</span> ["<span class='color-text'>${input.key.field}</span>", "<span class='color-text'>MouseRight</span>"]`);
         }, delay += step);
 
-        mech.setField(mech.fieldMode)
-        // mech.energy = 0;
+        m.setField(m.fieldMode)
+        // m.energy = 0;
         //exit testing
         if (simulation.testing) {
             simulation.testing = false;
@@ -664,9 +664,9 @@ const simulation = {
         if (tech.isMutualism && !tech.isEnergyHealth) {
             for (let i = 0; i < bullet.length; i++) {
                 if (bullet[i].isMutualismActive) {
-                    mech.health += 0.005
-                    if (mech.health > mech.maxHealth) mech.health = mech.maxHealth;
-                    mech.displayHealth();
+                    m.health += 0.005
+                    if (m.health > m.maxHealth) m.health = m.maxHealth;
+                    m.displayHealth();
                 }
             }
         }
@@ -678,7 +678,7 @@ const simulation = {
                 } else if (powerUp[i].name === "gun") {
                     if (!tech.isOneGun) b.giveGuns("random")
                 } else if (powerUp[i].name === "field") {
-                    if (mech.fieldMode === 0) mech.setField(Math.ceil(Math.random() * (mech.fieldUpgrades.length - 1))) //pick a random field, but not field 0
+                    if (m.fieldMode === 0) m.setField(Math.ceil(Math.random() * (m.fieldUpgrades.length - 1))) //pick a random field, but not field 0
                 } else {
                     powerUp[i].effect();
                 }
@@ -687,11 +687,11 @@ const simulation = {
         powerUps.totalPowerUps = powerUp.length
 
         let holdTarget; //if player is holding something this remembers it before it gets deleted
-        if (mech.holdingTarget) holdTarget = mech.holdingTarget;
+        if (m.holdingTarget) holdTarget = m.holdingTarget;
 
-        mech.fireCDcycle = 0
-        mech.drop();
-        mech.hole.isOn = false;
+        m.fireCDcycle = 0
+        m.drop();
+        m.hole.isOn = false;
         level.fill = [];
         level.fillBG = [];
         level.zones = [];
@@ -725,12 +725,12 @@ const simulation = {
                 frictionAir: holdTarget.frictionAir,
                 frictionStatic: holdTarget.frictionStatic
             });
-            Matter.Body.setPosition(body[len], mech.pos);
-            mech.isHolding = true
-            mech.holdingTarget = body[len];
-            mech.holdingTarget.collisionFilter.category = 0;
-            mech.holdingTarget.collisionFilter.mask = 0;
-            mech.definePlayerMass(mech.defaultMass + mech.holdingTarget.mass * mech.holdingMassScale)
+            Matter.Body.setPosition(body[len], m.pos);
+            m.isHolding = true
+            m.holdingTarget = body[len];
+            m.holdingTarget.collisionFilter.category = 0;
+            m.holdingTarget.collisionFilter.mask = 0;
+            m.definePlayerMass(m.defaultMass + m.holdingTarget.mass * m.holdingMassScale)
         }
         //set fps back to default
         simulation.fpsCap = simulation.fpsCapDefault
@@ -766,12 +766,12 @@ const simulation = {
     //   }
     // },
     checks() {
-        if (!(mech.cycle % 60)) { //once a second
+        if (!(m.cycle % 60)) { //once a second
 
             //energy overfill 
-            if (mech.energy > mech.maxEnergy) mech.energy = mech.maxEnergy + (mech.energy - mech.maxEnergy) * tech.overfillDrain //every second energy above max energy loses 25%
+            if (m.energy > m.maxEnergy) m.energy = m.maxEnergy + (m.energy - m.maxEnergy) * tech.overfillDrain //every second energy above max energy loses 25%
 
-            if (mech.pos.y > simulation.fallHeight) { // if 4000px deep
+            if (m.pos.y > simulation.fallHeight) { // if 4000px deep
                 Matter.Body.setVelocity(player, {
                     x: 0,
                     y: 0
@@ -793,12 +793,12 @@ const simulation = {
                         });
                     }
                 }
-                mech.damage(0.1 * simulation.difficultyMode);
-                mech.energy -= 0.1 * simulation.difficultyMode
+                m.damage(0.1 * simulation.difficultyMode);
+                m.energy -= 0.1 * simulation.difficultyMode
             }
 
             // if (tech.isEnergyDamage) {
-            //   document.getElementById("tech-capacitor").innerHTML = `(+${(mech.energy/0.05).toFixed(0)}%)`
+            //   document.getElementById("tech-capacitor").innerHTML = `(+${(m.energy/0.05).toFixed(0)}%)`
             // }
             // if (tech.restDamage) {
             //   if (player.speed < 1) {
@@ -808,14 +808,14 @@ const simulation = {
             //   }
             // }
 
-            if (mech.lastKillCycle + 300 > mech.cycle) { //effects active for 5 seconds after killing a mob
-                if (tech.isEnergyRecovery) mech.energy += mech.maxEnergy * 0.05
-                if (tech.isHealthRecovery) mech.addHealth(0.01 * mech.maxHealth)
+            if (m.lastKillCycle + 300 > m.cycle) { //effects active for 5 seconds after killing a mob
+                if (tech.isEnergyRecovery) m.energy += m.maxEnergy * 0.05
+                if (tech.isHealthRecovery) m.addHealth(0.01 * m.maxHealth)
             }
 
             if (!(simulation.cycle % 420)) { //once every 7 seconds
 
-                if (tech.cyclicImmunity && mech.immuneCycle < mech.cycle + tech.cyclicImmunity) mech.immuneCycle = mech.cycle + tech.cyclicImmunity; //player is immune to collision damage for 60 cycles
+                if (tech.cyclicImmunity && m.immuneCycle < m.cycle + tech.cyclicImmunity) m.immuneCycle = m.cycle + tech.cyclicImmunity; //player is immune to collision damage for 60 cycles
 
                 fallCheck = function(who, save = false) {
                     let i = who.length;
@@ -845,13 +845,13 @@ const simulation = {
                 //check for double crouch
                 //crouch playerHead.position.y - player.position.y = 9.7  //positive
                 //standing playerHead.position.y - player.position.y = -30 //negative
-                // mech.undoCrouch()
-                // if (!mech.crouch && ((playerHead.position.y - player.position.y) > 0)) {
+                // m.undoCrouch()
+                // if (!m.crouch && ((playerHead.position.y - player.position.y) > 0)) {
                 //     Matter.Body.translate(playerHead, {
                 //         x: 0,
                 //         y: 40
                 //     });
-                // } else if (mech.crouch && ((playerHead.position.y - player.position.y) > 10)) {
+                // } else if (m.crouch && ((playerHead.position.y - player.position.y) > 10)) {
                 //     Matter.Body.translate(playerHead, {
                 //         x: 0,
                 //         y: 40
@@ -867,7 +867,7 @@ const simulation = {
     },
     draw: {
         powerUp() { //is set by Bayesian tech
-            // ctx.globalAlpha = 0.4 * Math.sin(mech.cycle * 0.15) + 0.6;
+            // ctx.globalAlpha = 0.4 * Math.sin(m.cycle * 0.15) + 0.6;
             // for (let i = 0, len = powerUp.length; i < len; ++i) {
             //   ctx.beginPath();
             //   ctx.arc(powerUp[i].position.x, powerUp[i].position.y, powerUp[i].size, 0, 2 * Math.PI);
@@ -877,7 +877,7 @@ const simulation = {
             // ctx.globalAlpha = 1;
         },
         powerUpNormal() { //back up in case power up draw gets changed
-            ctx.globalAlpha = 0.4 * Math.sin(mech.cycle * 0.15) + 0.6;
+            ctx.globalAlpha = 0.4 * Math.sin(m.cycle * 0.15) + 0.6;
             for (let i = 0, len = powerUp.length; i < len; ++i) {
                 ctx.beginPath();
                 ctx.arc(powerUp[i].position.x, powerUp[i].position.y, powerUp[i].size, 0, 2 * Math.PI);
@@ -887,7 +887,7 @@ const simulation = {
             ctx.globalAlpha = 1;
         },
         powerUpBonus() { //draws crackle effect for bonus power ups
-            ctx.globalAlpha = 0.4 * Math.sin(mech.cycle * 0.15) + 0.6;
+            ctx.globalAlpha = 0.4 * Math.sin(m.cycle * 0.15) + 0.6;
             for (let i = 0, len = powerUp.length; i < len; ++i) {
                 ctx.beginPath();
                 ctx.arc(powerUp[i].position.x, powerUp[i].position.y, powerUp[i].size, 0, 2 * Math.PI);
diff --git a/js/spawn.js b/js/spawn.js
index 1889605..51ded9f 100644
--- a/js/spawn.js
+++ b/js/spawn.js
@@ -99,10 +99,12 @@ const spawn = {
         // spawn.shield(me, x, y, 1);
         me.onDeath = function() {
             //add lore level as next level if player took lore tech earlier in the game
-            if (lore.techCount > 9 && !simulation.isCheating) level.levels.push("null")
-
-            level.exit.x = 5500;
-            level.exit.y = -330;
+            if (lore.techCount > 9 && !simulation.isCheating) {
+                level.levels.push("null")
+                level.exit.x = 5500;
+                level.exit.y = -330;
+                simulation.makeTextLog(`level.levels.push("null")`) // <br>${powerUps.research.count}
+            }
             //ramp up damage
             for (let i = 0; i < 3; i++) level.difficultyIncrease(simulation.difficultyMode)
 
@@ -165,7 +167,7 @@ const spawn = {
             this.modeDo(); //this does different things based on the mode
             this.checkStatus();
             this.cycle++; //switch modes÷
-            // if (!mech.isBodiesAsleep) {
+            // if (!m.isBodiesAsleep) {
             if (this.health > 0.25) {
                 if (this.cycle > this.endCycle) {
                     this.cycle = 0;
@@ -222,7 +224,7 @@ const spawn = {
         }
         me.spawnInterval = 395
         me.modeSpawns = function() {
-            if (!(this.cycle % this.spawnInterval) && !mech.isBodiesAsleep && mob.length < 40) {
+            if (!(this.cycle % this.spawnInterval) && !m.isBodiesAsleep && mob.length < 40) {
                 if (this.mode !== 3) Matter.Body.setAngularVelocity(this, 0.1)
                 //fire a bullet from each vertex
                 let whoSpawn = spawn.fullPickList[Math.floor(Math.random() * spawn.fullPickList.length)];
@@ -273,22 +275,22 @@ const spawn = {
             ctx.fill();
             //when player is inside event horizon
             if (Vector.magnitude(Vector.sub(this.position, player.position)) < eventHorizon) {
-                if (mech.energy > 0) mech.energy -= 0.01
-                if (mech.energy < 0.15) {
-                    mech.damage(0.0004 * simulation.dmgScale);
+                if (m.energy > 0) m.energy -= 0.01
+                if (m.energy < 0.15) {
+                    m.damage(0.0004 * simulation.dmgScale);
                 }
                 const angle = Math.atan2(player.position.y - this.position.y, player.position.x - this.position.x);
-                player.force.x -= 0.0017 * Math.cos(angle) * player.mass * (mech.onGround ? 1.7 : 1);
+                player.force.x -= 0.0017 * Math.cos(angle) * player.mass * (m.onGround ? 1.7 : 1);
                 player.force.y -= 0.0017 * Math.sin(angle) * player.mass;
                 //draw line to player
                 ctx.beginPath();
                 ctx.moveTo(this.position.x, this.position.y);
-                ctx.lineTo(mech.pos.x, mech.pos.y);
+                ctx.lineTo(m.pos.x, m.pos.y);
                 ctx.lineWidth = Math.min(60, this.radius * 2);
                 ctx.strokeStyle = "rgba(0,0,0,0.5)";
                 ctx.stroke();
                 ctx.beginPath();
-                ctx.arc(mech.pos.x, mech.pos.y, 40, 0, 2 * Math.PI);
+                ctx.arc(m.pos.x, m.pos.y, 40, 0, 2 * Math.PI);
                 ctx.fillStyle = "rgba(0,0,0,0.3)";
                 ctx.fill();
             }
@@ -297,7 +299,7 @@ const spawn = {
         me.rotateVelocity = 0.0025
         me.rotateCount = 0;
         me.modeLasers = function() {
-            if (!mech.isBodiesAsleep && !this.isStunned) {
+            if (!m.isBodiesAsleep && !this.isStunned) {
                 let slowed = false //check if slowed
                 for (let i = 0; i < this.status.length; i++) {
                     if (this.status[i].type === "slow") {
@@ -401,10 +403,10 @@ const spawn = {
                 // vertexCollision(where, look, mob);
                 vertexCollision(where, look, map);
                 vertexCollision(where, look, body);
-                if (!mech.isCloak) vertexCollision(where, look, [player]);
-                if (best.who && best.who === player && mech.immuneCycle < mech.cycle) {
-                    mech.immuneCycle = mech.cycle + 60 + tech.collisionImmuneCycles; //player is immune to collision damage for 30 cycles
-                    mech.damage(dmg);
+                if (!m.isCloak) vertexCollision(where, look, [player]);
+                if (best.who && best.who === player && m.immuneCycle < m.cycle) {
+                    m.immuneCycle = m.cycle + 60 + tech.collisionImmuneCycles; //player is immune to collision damage for 30 cycles
+                    m.damage(dmg);
                     simulation.drawList.push({ //add dmg to draw queue
                         x: best.x,
                         y: best.y,
@@ -519,7 +521,7 @@ const spawn = {
             if (Math.random() < 0.33 * dmg * Math.sqrt(this.mass) && this.health > dmg) this.split();
         }
         me.do = function() {
-            if (!mech.isBodiesAsleep) {
+            if (!m.isBodiesAsleep) {
                 this.seePlayerByDistOrLOS();
                 this.checkStatus();
                 this.attraction();
@@ -578,13 +580,13 @@ const spawn = {
             powerUps.spawnBossPowerUp(me.position.x, me.position.y)
             powerUps.spawn(me.position.x, me.position.y, "heal");
             powerUps.spawn(me.position.x, me.position.y, "ammo");
-        } else if (!mech.isCloak) {
+        } else if (!m.isCloak) {
             me.foundPlayer();
         }
         me.onHit = function() { //run this function on hitting player
             powerUps.ejectTech()
-            powerUps.spawn(mech.pos.x, mech.pos.y, "heal");
-            powerUps.spawn(mech.pos.x, mech.pos.y, "heal");
+            powerUps.spawn(m.pos.x, m.pos.y, "heal");
+            powerUps.spawn(m.pos.x, m.pos.y, "heal");
         };
         me.onDeath = function() {
             this.leaveBody = false;
@@ -814,7 +816,7 @@ const spawn = {
             }
             // this.seePlayerCheckByDistance()
             if (!(simulation.cycle % this.seePlayerFreq)) {
-                if (this.distanceToPlayer2() < this.seeAtDistance2) { //&& !mech.isCloak   ignore cloak for black holes
+                if (this.distanceToPlayer2() < this.seeAtDistance2) { //&& !m.isCloak   ignore cloak for black holes
                     this.locatePlayer();
                     if (!this.seePlayer.yes) this.seePlayer.yes = true;
                 } else if (this.seePlayer.recall) {
@@ -848,22 +850,22 @@ const spawn = {
 
                 //when player is inside event horizon
                 if (Vector.magnitude(Vector.sub(this.position, player.position)) < eventHorizon) {
-                    if (mech.energy > 0) mech.energy -= 0.004
-                    if (mech.energy < 0.1) {
-                        mech.damage(0.00015 * simulation.dmgScale);
+                    if (m.energy > 0) m.energy -= 0.004
+                    if (m.energy < 0.1) {
+                        m.damage(0.00015 * simulation.dmgScale);
                     }
                     const angle = Math.atan2(player.position.y - this.position.y, player.position.x - this.position.x);
-                    player.force.x -= 0.00125 * player.mass * Math.cos(angle) * (mech.onGround ? 1.8 : 1);
+                    player.force.x -= 0.00125 * player.mass * Math.cos(angle) * (m.onGround ? 1.8 : 1);
                     player.force.y -= 0.0001 * player.mass * Math.sin(angle);
                     //draw line to player
                     ctx.beginPath();
                     ctx.moveTo(this.position.x, this.position.y);
-                    ctx.lineTo(mech.pos.x, mech.pos.y);
+                    ctx.lineTo(m.pos.x, m.pos.y);
                     ctx.lineWidth = Math.min(60, this.radius * 2);
                     ctx.strokeStyle = "rgba(0,0,0,0.5)";
                     ctx.stroke();
                     ctx.beginPath();
-                    ctx.arc(mech.pos.x, mech.pos.y, 40, 0, 2 * Math.PI);
+                    ctx.arc(m.pos.x, m.pos.y, 40, 0, 2 * Math.PI);
                     ctx.fillStyle = "rgba(0,0,0,0.3)";
                     ctx.fill();
                 }
@@ -910,7 +912,7 @@ const spawn = {
                 });
             }
             if (!(simulation.cycle % this.seePlayerFreq)) {
-                if (this.distanceToPlayer2() < this.seeAtDistance2) { //&& !mech.isCloak   ignore cloak for black holes
+                if (this.distanceToPlayer2() < this.seeAtDistance2) { //&& !m.isCloak   ignore cloak for black holes
                     this.locatePlayer();
                     if (!this.seePlayer.yes) this.seePlayer.yes = true;
                 } else if (this.seePlayer.recall) {
@@ -954,22 +956,22 @@ const spawn = {
                 ctx.fill();
                 //when player is inside event horizon
                 if (Vector.magnitude(Vector.sub(this.position, player.position)) < eventHorizon) {
-                    if (mech.energy > 0) mech.energy -= 0.006
-                    if (mech.energy < 0.1) {
-                        mech.damage(0.0002 * simulation.dmgScale);
+                    if (m.energy > 0) m.energy -= 0.006
+                    if (m.energy < 0.1) {
+                        m.damage(0.0002 * simulation.dmgScale);
                     }
                     const angle = Math.atan2(player.position.y - this.position.y, player.position.x - this.position.x);
-                    player.force.x -= 0.0013 * Math.cos(angle) * player.mass * (mech.onGround ? 1.7 : 1);
+                    player.force.x -= 0.0013 * Math.cos(angle) * player.mass * (m.onGround ? 1.7 : 1);
                     player.force.y -= 0.0013 * Math.sin(angle) * player.mass;
                     //draw line to player
                     ctx.beginPath();
                     ctx.moveTo(this.position.x, this.position.y);
-                    ctx.lineTo(mech.pos.x, mech.pos.y);
+                    ctx.lineTo(m.pos.x, m.pos.y);
                     ctx.lineWidth = Math.min(60, this.radius * 2);
                     ctx.strokeStyle = "rgba(0,0,0,0.5)";
                     ctx.stroke();
                     ctx.beginPath();
-                    ctx.arc(mech.pos.x, mech.pos.y, 40, 0, 2 * Math.PI);
+                    ctx.arc(m.pos.x, m.pos.y, 40, 0, 2 * Math.PI);
                     ctx.fillStyle = "rgba(0,0,0,0.3)";
                     ctx.fill();
                 }
@@ -1179,7 +1181,7 @@ const spawn = {
         };
         spawn.shield(me, x, y);
         me.do = function() {
-            if (!mech.isBodiesAsleep) {
+            if (!m.isBodiesAsleep) {
                 this.seePlayerByLookingAt();
                 this.checkStatus();
                 this.attraction();
@@ -1189,7 +1191,7 @@ const spawn = {
                     const rangeWidth = 2000; //this is sqrt of 4000000 from above if()
                     //targeting laser will slowly move from the mob to the player's position
                     this.laserPos = Vector.add(this.laserPos, Vector.mult(Vector.sub(player.position, this.laserPos), 0.1));
-                    let targetDist = Vector.magnitude(Vector.sub(this.laserPos, mech.pos));
+                    let targetDist = Vector.magnitude(Vector.sub(this.laserPos, m.pos));
                     const r = 12;
                     ctx.beginPath();
                     ctx.moveTo(this.position.x, this.position.y);
@@ -1341,12 +1343,12 @@ const spawn = {
                 };
                 vertexCollision(this.position, look, map);
                 vertexCollision(this.position, look, body);
-                if (!mech.isCloak) vertexCollision(this.position, look, [player]);
+                if (!m.isCloak) vertexCollision(this.position, look, [player]);
                 // hitting player
                 if (best.who === player) {
-                    if (mech.immuneCycle < mech.cycle) {
+                    if (m.immuneCycle < m.cycle) {
                         const dmg = 0.001 * simulation.dmgScale;
-                        mech.damage(dmg);
+                        m.damage(dmg);
                         //draw damage
                         ctx.fillStyle = color;
                         ctx.beginPath();
@@ -1408,7 +1410,7 @@ const spawn = {
             this.checkStatus();
 
             if (!this.isStunned) {
-                if (!mech.isBodiesAsleep) {
+                if (!m.isBodiesAsleep) {
                     //check if slowed
                     let slowed = false
                     for (let i = 0; i < this.status.length; i++) {
@@ -1499,11 +1501,11 @@ const spawn = {
             // vertexCollision(where, look, mob);
             vertexCollision(where, look, map);
             vertexCollision(where, look, body);
-            if (!mech.isCloak) vertexCollision(where, look, [player]);
-            if (best.who && best.who === player && mech.immuneCycle < mech.cycle) {
-                mech.immuneCycle = mech.cycle + tech.collisionImmuneCycles; //player is immune to collision damage for 30 cycles
+            if (!m.isCloak) vertexCollision(where, look, [player]);
+            if (best.who && best.who === player && m.immuneCycle < m.cycle) {
+                m.immuneCycle = m.cycle + tech.collisionImmuneCycles; //player is immune to collision damage for 30 cycles
                 const dmg = 0.14 * simulation.dmgScale;
-                mech.damage(dmg);
+                m.damage(dmg);
                 simulation.drawList.push({ //add dmg to draw queue
                     x: best.x,
                     y: best.y,
@@ -1544,7 +1546,7 @@ const spawn = {
             }
         };
         me.do = function() {
-            if (!mech.isBodiesAsleep) {
+            if (!m.isBodiesAsleep) {
                 // this.gravity();
                 this.seePlayerByLookingAt();
                 this.checkStatus();
@@ -1616,9 +1618,9 @@ const spawn = {
             if (!(simulation.cycle % this.seePlayerFreq)) { // this.seePlayerCheck();  from mobs
                 if (
                     this.distanceToPlayer2() < this.seeAtDistance2 &&
-                    Matter.Query.ray(map, this.position, this.mechPosRange()).length === 0 &&
-                    Matter.Query.ray(body, this.position, this.mechPosRange()).length === 0 &&
-                    !mech.isCloak
+                    Matter.Query.ray(map, this.position, this.mPosRange()).length === 0 &&
+                    Matter.Query.ray(body, this.position, this.mPosRange()).length === 0 &&
+                    !m.isCloak
                 ) {
                     this.foundPlayer();
                     if (this.cd === Infinity) this.cd = simulation.cycle + this.delay * 0.7;
@@ -1674,7 +1676,7 @@ const spawn = {
             this.checkStatus();
             this.attraction();
             //draw
-            if (!mech.isBodiesAsleep) {
+            if (!m.isBodiesAsleep) {
                 if (this.seePlayer.yes) {
                     if (this.alpha < 1) this.alpha += 0.01;
                 } else {
@@ -2019,7 +2021,7 @@ const spawn = {
             this.seePlayerCheck();
             this.checkStatus();
 
-            if (!mech.isBodiesAsleep) {
+            if (!m.isBodiesAsleep) {
                 const setNoseShape = () => {
                     const mag = this.radius + this.radius * this.noseLength;
                     this.vertices[1].x = this.position.x + Math.cos(this.angle) * mag;
@@ -2135,7 +2137,7 @@ const spawn = {
             this.seePlayerCheck();
             this.checkStatus();
             this.attraction();
-            if (this.seePlayer.recall && !(simulation.cycle % this.fireFreq) && !mech.isBodiesAsleep) {
+            if (this.seePlayer.recall && !(simulation.cycle % this.fireFreq) && !m.isBodiesAsleep) {
                 Matter.Body.setAngularVelocity(this, 0.14)
                 //fire a bullet from each vertex
                 for (let i = 0, len = this.vertices.length; i < len; i++) {
@@ -2173,7 +2175,7 @@ const spawn = {
             this.checkStatus();
             this.attraction();
             this.repulsion();
-            if (this.seePlayer.recall && !(simulation.cycle % this.fireFreq) && !mech.isBodiesAsleep) {
+            if (this.seePlayer.recall && !(simulation.cycle % this.fireFreq) && !m.isBodiesAsleep) {
                 Matter.Body.setAngularVelocity(this, 0.11)
                 //fire a bullet from each vertex
                 for (let i = 0, len = this.vertices.length; i < len; i++) {
@@ -2218,7 +2220,7 @@ const spawn = {
             this.repulsion();
 
             this.cycle++
-            if (this.seePlayer.recall && ((this.cycle % 15) === 0) && !mech.isBodiesAsleep) {
+            if (this.seePlayer.recall && ((this.cycle % 15) === 0) && !m.isBodiesAsleep) {
                 if (this.canFire) {
                     if (this.cycle > 120) {
                         this.cycle = 0
@@ -2701,7 +2703,7 @@ const spawn = {
             if (this.freeOfWires) {
                 this.gravity();
             } else {
-                if (mech.pos.x > breakingPoint) {
+                if (m.pos.x > breakingPoint) {
                     this.freeOfWires = true;
                     this.fill = "#000"
                     this.force.x += -0.003;
@@ -2716,9 +2718,9 @@ const spawn = {
                 })
 
                 //player friction from the wires
-                if (mech.pos.x > 700 && player.velocity.x > -2) {
-                    let wireFriction = 0.75 * Math.min(0.6, Math.max(0, 100 / (breakingPoint - mech.pos.x)));
-                    if (!mech.onGround) wireFriction *= 3
+                if (m.pos.x > 700 && player.velocity.x > -2) {
+                    let wireFriction = 0.75 * Math.min(0.6, Math.max(0, 100 / (breakingPoint - m.pos.x)));
+                    if (!m.onGround) wireFriction *= 3
                     Matter.Body.setVelocity(player, {
                         x: player.velocity.x - wireFriction,
                         y: player.velocity.y
@@ -2726,15 +2728,15 @@ const spawn = {
                 }
                 //move to player
                 Matter.Body.setPosition(this, {
-                    x: mech.pos.x + (42 * Math.cos(mech.angle + Math.PI)),
-                    y: mech.pos.y + (42 * Math.sin(mech.angle + Math.PI))
+                    x: m.pos.x + (42 * Math.cos(m.angle + Math.PI)),
+                    y: m.pos.y + (42 * Math.sin(m.angle + Math.PI))
                 })
             }
             //draw wire
             ctx.beginPath();
             ctx.moveTo(wireX, wireY);
             ctx.quadraticCurveTo(wireX, 0, this.position.x, this.position.y);
-            if (!this.freeOfWires) ctx.lineTo(mech.pos.x + (30 * Math.cos(mech.angle + Math.PI)), mech.pos.y + (30 * Math.sin(mech.angle + Math.PI)));
+            if (!this.freeOfWires) ctx.lineTo(m.pos.x + (30 * Math.cos(m.angle + Math.PI)), m.pos.y + (30 * Math.sin(m.angle + Math.PI)));
             ctx.lineCap = "butt";
             ctx.lineWidth = 15;
             ctx.strokeStyle = "#000";
@@ -2769,16 +2771,16 @@ const spawn = {
             if (this.freeOfWires) {
                 this.gravity();
             } else {
-                if (mech.pos.x > breakingPoint) {
+                if (m.pos.x > breakingPoint) {
                     this.freeOfWires = true;
                     this.force.x -= 0.0004;
                     this.fill = "#222";
                 }
                 //move mob to player
-                mech.calcLeg(0, 0);
+                m.calcLeg(0, 0);
                 Matter.Body.setPosition(this, {
-                    x: mech.pos.x + mech.flipLegs * mech.knee.x - 5,
-                    y: mech.pos.y + mech.knee.y
+                    x: m.pos.x + m.flipLegs * m.knee.x - 5,
+                    y: m.pos.y + m.knee.y
                 })
             }
             //draw wire
@@ -2819,16 +2821,16 @@ const spawn = {
             if (this.freeOfWires) {
                 this.gravity();
             } else {
-                if (mech.pos.x > breakingPoint) {
+                if (m.pos.x > breakingPoint) {
                     this.freeOfWires = true;
                     this.force.x += -0.0003;
                     this.fill = "#333";
                 }
                 //move mob to player
-                mech.calcLeg(Math.PI, -3);
+                m.calcLeg(Math.PI, -3);
                 Matter.Body.setPosition(this, {
-                    x: mech.pos.x + mech.flipLegs * mech.knee.x - 5,
-                    y: mech.pos.y + mech.knee.y
+                    x: m.pos.x + m.flipLegs * m.knee.x - 5,
+                    y: m.pos.y + m.knee.y
                 })
             }
             //draw wire
@@ -2868,16 +2870,16 @@ const spawn = {
             if (this.freeOfWires) {
                 this.gravity();
             } else {
-                if (mech.pos.x > breakingPoint) {
+                if (m.pos.x > breakingPoint) {
                     this.freeOfWires = true;
                     this.force.x += -0.0006;
                     this.fill = "#111";
                 }
                 //move mob to player
-                mech.calcLeg(0, 0);
+                m.calcLeg(0, 0);
                 Matter.Body.setPosition(this, {
-                    x: mech.pos.x + mech.flipLegs * mech.foot.x - 5,
-                    y: mech.pos.y + mech.foot.y - 1
+                    x: m.pos.x + m.flipLegs * m.foot.x - 5,
+                    y: m.pos.y + m.foot.y - 1
                 })
             }
             //draw wire
@@ -2917,16 +2919,16 @@ const spawn = {
             if (this.freeOfWires) {
                 this.gravity();
             } else {
-                if (mech.pos.x > breakingPoint) {
+                if (m.pos.x > breakingPoint) {
                     this.freeOfWires = true;
                     this.force.x += -0.0005;
                     this.fill = "#222";
                 }
                 //move mob to player
-                mech.calcLeg(Math.PI, -3);
+                m.calcLeg(Math.PI, -3);
                 Matter.Body.setPosition(this, {
-                    x: mech.pos.x + mech.flipLegs * mech.foot.x - 5,
-                    y: mech.pos.y + mech.foot.y - 1
+                    x: m.pos.x + m.flipLegs * m.foot.x - 5,
+                    y: m.pos.y + m.foot.y - 1
                 })
             }
             //draw wire
diff --git a/js/tech.js b/js/tech.js
index ab51965..32d72b9 100644
--- a/js/tech.js
+++ b/js/tech.js
@@ -91,29 +91,29 @@ const tech = {
         return false
     },
     damageFromTech() {
-        let dmg = mech.fieldDamage
+        let dmg = m.fieldDamage
         if (tech.isTechDamage) dmg *= 2
         if (tech.isDupDamage) dmg *= 1 + Math.min(1, tech.duplicationChance())
-        if (tech.isLowEnergyDamage) dmg *= 1 + Math.max(0, 1 - mech.energy) * 0.5
+        if (tech.isLowEnergyDamage) dmg *= 1 + Math.max(0, 1 - m.energy) * 0.5
         if (tech.isMaxEnergyTech) dmg *= 1.4
         if (tech.isEnergyNoAmmo) dmg *= 1.5
         if (tech.isDamageForGuns) dmg *= 1 + 0.13 * b.inventory.length
-        if (tech.isLowHealthDmg) dmg *= 1 + 0.6 * Math.max(0, 1 - mech.health)
-        if (tech.isHarmDamage && mech.lastHarmCycle + 600 > mech.cycle) dmg *= 3;
+        if (tech.isLowHealthDmg) dmg *= 1 + 0.6 * Math.max(0, 1 - m.health)
+        if (tech.isHarmDamage && m.lastHarmCycle + 600 > m.cycle) dmg *= 3;
         if (tech.isEnergyLoss) dmg *= 1.5;
-        if (tech.isAcidDmg && mech.health > 1) dmg *= 1.4;
+        if (tech.isAcidDmg && m.health > 1) dmg *= 1.4;
         if (tech.restDamage > 1 && player.speed < 1) dmg *= tech.restDamage
-        if (tech.isEnergyDamage) dmg *= 1 + mech.energy / 9;
+        if (tech.isEnergyDamage) dmg *= 1 + m.energy / 9;
         if (tech.isDamageFromBulletCount) dmg *= 1 + bullet.length * 0.0038
         if (tech.isRerollDamage) dmg *= 1 + 0.035 * powerUps.research.count
         if (tech.isOneGun && b.inventory.length < 2) dmg *= 1.25
-        if (tech.isNoFireDamage && mech.cycle > mech.fireCDcycle + 120) dmg *= 1.66
+        if (tech.isNoFireDamage && m.cycle > m.fireCDcycle + 120) dmg *= 1.66
         if (tech.isSpeedDamage) dmg *= 1 + Math.min(0.4, player.speed * 0.013)
         if (tech.isBotDamage) dmg *= 1 + 0.02 * tech.totalBots()
         return dmg * tech.slowFire * tech.aimDamage
     },
     duplicationChance() {
-        return (tech.isBayesian ? 0.2 : 0) + tech.cancelCount * 0.04 + tech.duplicateChance + mech.duplicateChance
+        return (tech.isBayesian ? 0.2 : 0) + tech.cancelCount * 0.04 + tech.duplicateChance + m.duplicateChance
     },
     totalBots() {
         return tech.foamBotCount + tech.nailBotCount + tech.laserBotCount + tech.boomBotCount + tech.orbitBotCount + tech.plasmaBotCount + tech.missileBotCount
@@ -206,7 +206,7 @@ const tech = {
             requires: "arsenal or cyclic rate boost",
             effect() {
                 tech.isGunCycle = true;
-                for (let i = 0; i < 6; i++) powerUps.spawn(mech.pos.x + 10 * Math.random(), mech.pos.y + 10 * Math.random(), "gun");
+                for (let i = 0; i < 6; i++) powerUps.spawn(m.pos.x + 10 * Math.random(), m.pos.y + 10 * Math.random(), "gun");
             },
             remove() {
                 tech.isGunCycle = false;
@@ -226,15 +226,15 @@ const tech = {
             effect() {
                 for (let i = 0; i < b.inventory.length; i++) {
                     if (Math.random() < 0.2) {
-                        powerUps.spawn(mech.pos.x + 10 * Math.random(), mech.pos.y + 10 * Math.random(), "tech");
+                        powerUps.spawn(m.pos.x + 10 * Math.random(), m.pos.y + 10 * Math.random(), "tech");
                     } else if (Math.random() < 0.25) {
-                        powerUps.spawn(mech.pos.x + 10 * Math.random(), mech.pos.y + 10 * Math.random(), "field");
+                        powerUps.spawn(m.pos.x + 10 * Math.random(), m.pos.y + 10 * Math.random(), "field");
                     } else if (Math.random() < 0.33) {
-                        powerUps.spawn(mech.pos.x + 10 * Math.random(), mech.pos.y + 10 * Math.random(), "heal");
+                        powerUps.spawn(m.pos.x + 10 * Math.random(), m.pos.y + 10 * Math.random(), "heal");
                     } else if (Math.random() < 0.5) {
-                        powerUps.spawn(mech.pos.x + 10 * Math.random(), mech.pos.y + 10 * Math.random(), "ammo");
+                        powerUps.spawn(m.pos.x + 10 * Math.random(), m.pos.y + 10 * Math.random(), "ammo");
                     } else {
-                        powerUps.spawn(mech.pos.x + 10 * Math.random(), mech.pos.y + 10 * Math.random(), "research");
+                        powerUps.spawn(m.pos.x + 10 * Math.random(), m.pos.y + 10 * Math.random(), "research");
                     }
 
                 }
@@ -378,7 +378,7 @@ const tech = {
             }
         },
         {
-            name: "Higgs mechanism",
+            name: "Higgs manism",
             description: "while <strong>firing</strong> your <strong>position</strong> is locked<br> and <strong class='color-harm'>harm</strong> is reduced by <strong>60%</strong>",
             maxCount: 1,
             count: 0,
@@ -409,12 +409,12 @@ const tech = {
             effect() { // good with melee builds, content skipping builds
                 tech.squirrelFx += 0.25;
                 tech.squirrelJump += 0.1;
-                mech.setMovement()
+                m.setMovement()
             },
             remove() {
                 tech.squirrelFx = 1;
                 tech.squirrelJump = 1;
-                mech.setMovement()
+                m.setMovement()
             }
         },
         {
@@ -423,7 +423,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.Fx > 0.016 && !tech.isEnergyHealth
+                return m.Fx > 0.016 && !tech.isEnergyHealth
             },
             requires: "speed increase, not mass-energy equivalence",
             effect() {
@@ -439,7 +439,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.Fx > 0.016
+                return m.Fx > 0.016
             },
             requires: "speed increase",
             effect() {
@@ -457,7 +457,7 @@ const tech = {
         //     allowed() {
         //         return tech.isFireNotMove || tech.isFireMoveLock
         //     },
-        //     requires: "inertial frame or Higgs mechanism",
+        //     requires: "inertial frame or Higgs manism",
         //     effect() {
         //         tech.isRestHarm = true
         //     },
@@ -625,7 +625,7 @@ const tech = {
             effect() {
                 tech.sporesOnDeath += 0.09;
                 for (let i = 0; i < 8; i++) {
-                    b.spore(mech.pos)
+                    b.spore(m.pos)
                 }
             },
             remove() {
@@ -675,7 +675,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return (tech.totalBots() > 1 || tech.haveGunCheck("drones") || tech.haveGunCheck("mine") || tech.haveGunCheck("spores") || mech.fieldUpgrades[mech.fieldMode].name === "nano-scale manufacturing") && !tech.isEnergyHealth
+                return (tech.totalBots() > 1 || tech.haveGunCheck("drones") || tech.haveGunCheck("mine") || tech.haveGunCheck("spores") || m.fieldUpgrades[m.fieldMode].name === "nano-scale manufacturing") && !tech.isEnergyHealth
             },
             requires: "drones, spores, mines, or bots",
             effect() {
@@ -840,7 +840,7 @@ const tech = {
             maxCount: 9,
             count: 0,
             allowed() {
-                return mech.maxEnergy > 0.5
+                return m.maxEnergy > 0.5
             },
             requires: "maximum energy above 50%",
             effect() {
@@ -934,7 +934,7 @@ const tech = {
             effect() {
                 tech.isRerollBots = true;
                 powerUps.research.changeRerolls(0)
-                simulation.makeTextLog(`<span class='color-var'>mech</span>.<span class='color-r'>research</span> <span class='color-symbol'>=</span> 0`)
+                simulation.makeTextLog(`<span class='color-var'>m</span>.<span class='color-r'>research</span> <span class='color-symbol'>=</span> 0`)
             },
             remove() {
                 tech.isRerollBots = false;
@@ -1023,7 +1023,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name !== "wormhole"
+                return m.fieldUpgrades[m.fieldMode].name !== "wormhole"
             },
             requires: "not wormhole",
             effect() {
@@ -1060,7 +1060,7 @@ const tech = {
             requires: "",
             effect() {
                 tech.collisionImmuneCycles += 45;
-                mech.immuneCycle = mech.cycle + tech.collisionImmuneCycles; //player is immune to collision damage for 30 cycles
+                m.immuneCycle = m.cycle + tech.collisionImmuneCycles; //player is immune to collision damage for 30 cycles
             },
             remove() {
                 tech.collisionImmuneCycles = 25;
@@ -1088,7 +1088,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.harmReduction() < 1
+                return m.harmReduction() < 1
             },
             requires: "some harm reduction",
             effect() {
@@ -1107,7 +1107,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return !tech.isEnergyHealth && mech.harmReduction() < 1
+                return !tech.isEnergyHealth && m.harmReduction() < 1
             },
             requires: "some harm reduction",
             effect() {
@@ -1123,7 +1123,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.harmReduction() < 1
+                return m.harmReduction() < 1
             },
             requires: "some harm reduction",
             effect() {
@@ -1186,8 +1186,8 @@ const tech = {
             description: "<strong>charge</strong>, <strong>parity</strong>, and <strong>time</strong> invert to undo <strong class='color-harm'>harm</strong><br><strong class='color-rewind'>rewind</strong> <strong>(1.5—5)</strong> seconds for <strong>(66—220)</strong> <strong class='color-f'>energy</strong>",
             maxCount: 1,
             count: 0,
-            allowed() { //&& (mech.fieldUpgrades[mech.fieldMode].name !== "nano-scale manufacturing" || mech.maxEnergy > 1)
-                return mech.maxEnergy > 0.99 && mech.fieldUpgrades[mech.fieldMode].name !== "standing wave harmonics" && !tech.isEnergyHealth && !tech.isRewindGun
+            allowed() { //&& (m.fieldUpgrades[m.fieldMode].name !== "nano-scale manufacturing" || m.maxEnergy > 1)
+                return m.maxEnergy > 0.99 && m.fieldUpgrades[m.fieldMode].name !== "standing wave harmonics" && !tech.isEnergyHealth && !tech.isRewindGun
             },
             requires: "not standing wave, mass-energy, piezo, max energy reduction, CPT gun",
             effect() {
@@ -1240,7 +1240,7 @@ const tech = {
             requires: "not mass-energy equivalence",
             effect() {
                 tech.isPiezo = true;
-                mech.energy += 4;
+                m.energy += 4;
             },
             remove() {
                 tech.isPiezo = false;
@@ -1257,11 +1257,11 @@ const tech = {
             requires: "piezoelectricity, Penrose, half-wave, or thermoelectric, but not time crystals",
             effect: () => {
                 tech.energyRegen = 0;
-                mech.fieldRegen = tech.energyRegen;
+                m.fieldRegen = tech.energyRegen;
             },
             remove() {
                 tech.energyRegen = 0.001;
-                mech.fieldRegen = tech.energyRegen;
+                m.fieldRegen = tech.energyRegen;
             }
         },
         {
@@ -1270,25 +1270,25 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return !tech.isEnergyLoss && !tech.isPiezo && !tech.isRewindAvoidDeath && !tech.isRewindGun && !tech.isSpeedHarm && mech.fieldUpgrades[mech.fieldMode].name !== "negative mass field" && !tech.isHealLowHealth && !tech.isTechDamage
+                return !tech.isEnergyLoss && !tech.isPiezo && !tech.isRewindAvoidDeath && !tech.isRewindGun && !tech.isSpeedHarm && m.fieldUpgrades[m.fieldMode].name !== "negative mass field" && !tech.isHealLowHealth && !tech.isTechDamage
             },
             requires: "not exothermic process, piezoelectricity, CPT, 1st law, negative mass , ...",
             effect: () => {
-                mech.health = 0
-                // mech.displayHealth();
+                m.health = 0
+                // m.displayHealth();
                 document.getElementById("health").style.display = "none"
                 document.getElementById("health-bg").style.display = "none"
                 document.getElementById("dmg").style.backgroundColor = "#0cf";
                 tech.isEnergyHealth = true;
-                mech.displayHealth();
+                m.displayHealth();
             },
             remove() {
                 tech.isEnergyHealth = false;
                 document.getElementById("health").style.display = "inline"
                 document.getElementById("health-bg").style.display = "inline"
                 document.getElementById("dmg").style.backgroundColor = "#f67";
-                mech.health = Math.min(mech.maxHealth, mech.energy);
-                mech.displayHealth();
+                m.health = Math.min(m.maxHealth, m.energy);
+                m.displayHealth();
 
             }
         },
@@ -1323,7 +1323,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.maxEnergy > 1 || tech.isEnergyRecovery || tech.isPiezo || tech.energySiphon > 0
+                return m.maxEnergy > 1 || tech.isEnergyRecovery || tech.isPiezo || tech.energySiphon > 0
             },
             requires: "increased energy regen or max energy",
             effect: () => {
@@ -1339,7 +1339,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return (tech.haveGunCheck("nail gun") && tech.isIceCrystals) || tech.haveGunCheck("laser") || mech.fieldUpgrades[mech.fieldMode].name === "plasma torch" || mech.fieldUpgrades[mech.fieldMode].name === "nano-scale manufacturing" || mech.fieldUpgrades[mech.fieldMode].name === "pilot wave"
+                return (tech.haveGunCheck("nail gun") && tech.isIceCrystals) || tech.haveGunCheck("laser") || m.fieldUpgrades[m.fieldMode].name === "plasma torch" || m.fieldUpgrades[m.fieldMode].name === "nano-scale manufacturing" || m.fieldUpgrades[m.fieldMode].name === "pilot wave"
             },
             requires: "energy based damage",
             effect() {
@@ -1371,16 +1371,16 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return tech.isEnergyLoss && mech.maxEnergy < 1.1 && !tech.isSporeField && !tech.isRewindAvoidDeath
+                return tech.isEnergyLoss && m.maxEnergy < 1.1 && !tech.isSporeField && !tech.isRewindAvoidDeath
             },
             requires: "exothermic process, not max energy increase, CPT, or spore nano-scale",
             effect() {
                 tech.isMaxEnergyTech = true;
-                mech.setMaxEnergy()
+                m.setMaxEnergy()
             },
             remove() {
                 tech.isMaxEnergyTech = false;
-                mech.setMaxEnergy()
+                m.setMaxEnergy()
             }
         },
         {
@@ -1389,7 +1389,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return tech.isEnergyLoss && mech.maxEnergy < 1.1
+                return tech.isEnergyLoss && m.maxEnergy < 1.1
             },
             requires: "exothermic process, not max energy increase",
             effect() {
@@ -1405,18 +1405,18 @@ const tech = {
             maxCount: 9,
             count: 0,
             allowed() {
-                return mech.maxEnergy > 0.99
+                return m.maxEnergy > 0.99
             },
             requires: "max energy >= 1",
             effect() {
-                // mech.maxEnergy += 0.5
-                // mech.energy += 0.5
+                // m.maxEnergy += 0.5
+                // m.energy += 0.5
                 tech.bonusEnergy += 0.5
-                mech.setMaxEnergy()
+                m.setMaxEnergy()
             },
             remove() {
                 tech.bonusEnergy = 0;
-                mech.setMaxEnergy()
+                m.setMaxEnergy()
             }
         },
         {
@@ -1457,7 +1457,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.maxEnergy > 0.99
+                return m.maxEnergy > 0.99
             },
             requires: "max energy >= 1",
             effect() {
@@ -1489,7 +1489,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.health < 0.5 || build.isExperimentSelection
+                return m.health < 0.5 || build.isExperimentSelection
             },
             requires: "health below 60",
             effect() {
@@ -1504,7 +1504,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return (mech.harmReduction() < 1 || tech.healthDrain || tech.isLowHealthDmg || tech.isHealthRecovery || tech.isHealLowHealth || tech.largerHeals > 1 || tech.isPerpetualHeal) && !tech.isEnergyHealth
+                return (m.harmReduction() < 1 || tech.healthDrain || tech.isLowHealthDmg || tech.isHealthRecovery || tech.isHealLowHealth || tech.largerHeals > 1 || tech.isPerpetualHeal) && !tech.isEnergyHealth
             },
             requires: "negative feedback or extra healing tech or harm reduction, not mass-energy",
             effect() {
@@ -1536,7 +1536,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.maxHealth > 1;
+                return m.maxHealth > 1;
             },
             requires: "health above 100",
             effect() {
@@ -1557,12 +1557,12 @@ const tech = {
             requires: "not mass-energy equivalence",
             effect() {
                 tech.bonusHealth += 0.5
-                mech.addHealth(0.50)
-                mech.setMaxHealth();
+                m.addHealth(0.50)
+                m.setMaxHealth();
             },
             remove() {
                 tech.bonusHealth = 0
-                mech.setMaxHealth();
+                m.setMaxHealth();
 
             }
         },
@@ -1581,7 +1581,7 @@ const tech = {
             remove() {
                 tech.isArmorFromPowerUps = false;
                 // tech.armorFromPowerUps = 0;  //this is now reset in tech.setupAllTech();
-                mech.setMaxHealth();
+                m.setMaxHealth();
             }
         },
         {
@@ -1606,7 +1606,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.maxHealth > 1 || tech.isArmorFromPowerUps
+                return m.maxHealth > 1 || tech.isArmorFromPowerUps
             },
             requires: "increased max health",
             effect() {
@@ -1622,7 +1622,7 @@ const tech = {
             maxCount: 3,
             count: 0,
             allowed() {
-                return (mech.health < 0.7 || build.isExperimentSelection) && !tech.isEnergyHealth
+                return (m.health < 0.7 || build.isExperimentSelection) && !tech.isEnergyHealth
             },
             requires: "not mass-energy equivalence",
             effect() {
@@ -1685,7 +1685,7 @@ const tech = {
             requires: "at least 2 research",
             effect() {
                 tech.isImmortal = true;
-                for (let i = 0; i < 4; i++) powerUps.spawn(mech.pos.x + Math.random() * 10, mech.pos.y + Math.random() * 10, "research", false);
+                for (let i = 0; i < 4; i++) powerUps.spawn(m.pos.x + Math.random() * 10, m.pos.y + Math.random() * 10, "research", false);
             },
             remove() {
                 tech.isImmortal = false;
@@ -1814,10 +1814,10 @@ const tech = {
                 const choose = have[Math.floor(Math.random() * have.length)]
                 simulation.makeTextLog(`<span class='color-var'>tech</span>.remove("<span class='color-text'>${tech.tech[choose].name}</span>")`)
                 for (let i = 0; i < tech.tech[choose].count; i++) {
-                    powerUps.spawn(mech.pos.x, mech.pos.y, "gun");
+                    powerUps.spawn(m.pos.x, m.pos.y, "gun");
                 }
-                powerUps.spawn(mech.pos.x, mech.pos.y, "gun");
-                powerUps.spawn(mech.pos.x, mech.pos.y, "gun");
+                powerUps.spawn(m.pos.x, m.pos.y, "gun");
+                powerUps.spawn(m.pos.x, m.pos.y, "gun");
                 tech.tech[choose].count = 0;
                 tech.tech[choose].remove(); // remove a random tech form the list of tech you have
                 tech.tech[choose].isLost = true
@@ -1844,9 +1844,9 @@ const tech = {
                 const choose = have[Math.floor(Math.random() * have.length)]
                 simulation.makeTextLog(`<span class='color-var'>tech</span>.remove("<span class='color-text'>${tech.tech[choose].name}</span>")`)
                 for (let i = 0; i < tech.tech[choose].count; i++) {
-                    powerUps.spawn(mech.pos.x, mech.pos.y, "tech");
+                    powerUps.spawn(m.pos.x, m.pos.y, "tech");
                 }
-                powerUps.spawn(mech.pos.x, mech.pos.y, "tech");
+                powerUps.spawn(m.pos.x, m.pos.y, "tech");
                 tech.tech[choose].count = 0;
                 tech.tech[choose].remove(); // remove a random tech form the list of tech you have
                 tech.tech[choose].isLost = true
@@ -1867,11 +1867,11 @@ const tech = {
             requires: "at least 1 tech and 1 research, a chance to duplicate power ups",
             effect: () => {
                 powerUps.research.changeRerolls(-2)
-                simulation.makeTextLog(`<span class='color-var'>mech</span>.<span class='color-r'>research</span> <span class='color-symbol'>-=</span> 2
+                simulation.makeTextLog(`<span class='color-var'>m</span>.<span class='color-r'>research</span> <span class='color-symbol'>-=</span> 2
                 <br>${powerUps.research.count}`)
                 const chanceStore = tech.duplicateChance
-                tech.duplicateChance = (tech.isBayesian ? 0.2 : 0) + tech.cancelCount * 0.04 + mech.duplicateChance + tech.duplicateChance * 2 //increase duplication chance to simulate doubling all 3 sources of duplication chance
-                powerUps.spawn(mech.pos.x, mech.pos.y, "tech");
+                tech.duplicateChance = (tech.isBayesian ? 0.2 : 0) + tech.cancelCount * 0.04 + m.duplicateChance + tech.duplicateChance * 2 //increase duplication chance to simulate doubling all 3 sources of duplication chance
+                powerUps.spawn(m.pos.x, m.pos.y, "tech");
                 tech.duplicateChance = chanceStore
             },
             remove() {}
@@ -1887,7 +1887,7 @@ const tech = {
             requires: "some power up duplication",
             effect() {
                 tech.isMineDrop = true;
-                if (tech.isMineDrop) b.mine(mech.pos, { x: 0, y: 0 }, 0, tech.isMineAmmoBack)
+                if (tech.isMineDrop) b.mine(m.pos, { x: 0, y: 0 }, 0, tech.isMineAmmoBack)
             },
             remove() {
                 tech.isMineDrop = false;
@@ -1922,7 +1922,7 @@ const tech = {
             effect: () => {
                 tech.isDeterminism = true;
                 for (let i = 0; i < 5; i++) { //if you change the six also change it in Born rule
-                    powerUps.spawn(mech.pos.x, mech.pos.y, "tech");
+                    powerUps.spawn(m.pos.x, m.pos.y, "tech");
                 }
             },
             remove() {
@@ -1942,7 +1942,7 @@ const tech = {
             effect: () => {
                 tech.isSuperDeterminism = true;
                 for (let i = 0; i < 7; i++) { //if you change the six also change it in Born rule
-                    powerUps.spawn(mech.pos.x, mech.pos.y, "tech");
+                    powerUps.spawn(m.pos.x, m.pos.y, "tech");
                 }
             },
             remove() {
@@ -1998,9 +1998,9 @@ const tech = {
                 tech.isGunSwitchField = true;
                 for (let i = tech.tech.length - 1; i > 0; i--) {
                     if (tech.tech[i].name === "unified field theory") {
-                        const index = (mech.fieldMode === mech.fieldUpgrades.length - 1) ? 1 : mech.fieldMode + 1
+                        const index = (m.fieldMode === m.fieldUpgrades.length - 1) ? 1 : m.fieldMode + 1
                         tech.tech[i].description = `after switching <strong>guns</strong><br>use a <strong class='color-r'>research</strong> to cycle your <strong class='color-f'>field</strong>
-                        <br>(next <strong class='color-f'>field</strong>: ${mech.fieldUpgrades[index].name})`
+                        <br>(next <strong class='color-f'>field</strong>: ${m.fieldUpgrades[index].name})`
                         break
                     }
                 }
@@ -2043,7 +2043,7 @@ const tech = {
             effect() {
                 tech.isBanish = true
                 for (let i = 0; i < 4; i++) {
-                    powerUps.spawn(mech.pos.x, mech.pos.y, "research", false);
+                    powerUps.spawn(m.pos.x, m.pos.y, "research", false);
                 }
             },
             remove() {
@@ -2092,9 +2092,9 @@ const tech = {
                 tech.setupAllTech(); // remove all tech
                 tech.addLoreTechToPool();
                 for (let i = 0; i < count; i++) { // spawn new tech power ups
-                    powerUps.spawn(mech.pos.x, mech.pos.y, "tech");
+                    powerUps.spawn(m.pos.x, m.pos.y, "tech");
                 }
-                //have state is checked in mech.death()
+                //have state is checked in m.death()
             },
             remove() {}
         },
@@ -2125,7 +2125,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return (tech.totalBots() > 5 || mech.fieldUpgrades[mech.fieldMode].name === "nano-scale manufacturing" || mech.fieldUpgrades[mech.fieldMode].name === "plasma torch" || mech.fieldUpgrades[mech.fieldMode].name === "pilot wave") && !tech.isEnergyHealth && !tech.isRewindAvoidDeath //build.isExperimentSelection ||
+                return (tech.totalBots() > 5 || m.fieldUpgrades[m.fieldMode].name === "nano-scale manufacturing" || m.fieldUpgrades[m.fieldMode].name === "plasma torch" || m.fieldUpgrades[m.fieldMode].name === "pilot wave") && !tech.isEnergyHealth && !tech.isRewindAvoidDeath //build.isExperimentSelection ||
             },
             requires: "bots > 5, plasma torch, nano-scale, pilot wave, not mass-energy equivalence, CPT",
             effect() {
@@ -2167,7 +2167,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return ((mech.fieldUpgrades[mech.fieldMode].name === "nano-scale manufacturing" && !(tech.isSporeField || tech.isMissileField || tech.isIceField)) || tech.haveGunCheck("drones") || tech.haveGunCheck("super balls") || tech.haveGunCheck("shotgun")) && !tech.isNailShot
+                return ((m.fieldUpgrades[m.fieldMode].name === "nano-scale manufacturing" && !(tech.isSporeField || tech.isMissileField || tech.isIceField)) || tech.haveGunCheck("drones") || tech.haveGunCheck("super balls") || tech.haveGunCheck("shotgun")) && !tech.isNailShot
             },
             requires: "drones, super balls, shotgun",
             effect() {
@@ -2235,7 +2235,7 @@ const tech = {
             maxCount: 3,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "nano-scale manufacturing" || tech.haveGunCheck("spores") || tech.haveGunCheck("drones") || tech.haveGunCheck("missiles") || tech.haveGunCheck("foam") || tech.haveGunCheck("wave beam") || tech.isNeutronBomb
+                return m.fieldUpgrades[m.fieldMode].name === "nano-scale manufacturing" || tech.haveGunCheck("spores") || tech.haveGunCheck("drones") || tech.haveGunCheck("missiles") || tech.haveGunCheck("foam") || tech.haveGunCheck("wave beam") || tech.isNeutronBomb
             },
             requires: "drones, spores, missiles, foam<br>wave beam, neutron bomb",
             effect() {
@@ -2982,7 +2982,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return tech.haveGunCheck("drones") || (mech.fieldUpgrades[mech.fieldMode].name === "nano-scale manufacturing" && !(tech.isSporeField || tech.isMissileField || tech.isIceField))
+                return tech.haveGunCheck("drones") || (m.fieldUpgrades[m.fieldMode].name === "nano-scale manufacturing" && !(tech.isSporeField || tech.isMissileField || tech.isIceField))
             },
             requires: "drones",
             effect() {
@@ -2999,7 +2999,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return !tech.isArmorFromPowerUps && (tech.haveGunCheck("drones") || (mech.fieldUpgrades[mech.fieldMode].name === "nano-scale manufacturing" && !(tech.isSporeField || tech.isMissileField || tech.isIceField)))
+                return !tech.isArmorFromPowerUps && (tech.haveGunCheck("drones") || (m.fieldUpgrades[m.fieldMode].name === "nano-scale manufacturing" && !(tech.isSporeField || tech.isMissileField || tech.isIceField)))
             },
             requires: "drones",
             effect() {
@@ -3377,11 +3377,11 @@ const tech = {
             maxCount: 9,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "standing wave harmonics"
+                return m.fieldUpgrades[m.fieldMode].name === "standing wave harmonics"
             },
             requires: "standing wave harmonics",
             effect() {
-                tech.blockDmg += 0.75 //if you change this value also update the for loop in the electricity graphics in mech.pushMass
+                tech.blockDmg += 0.75 //if you change this value also update the for loop in the electricity graphics in m.pushMass
             },
             remove() {
                 tech.blockDmg = 0;
@@ -3394,16 +3394,16 @@ const tech = {
             maxCount: 9,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "standing wave harmonics"
+                return m.fieldUpgrades[m.fieldMode].name === "standing wave harmonics"
             },
             requires: "standing wave harmonics",
             effect() {
-                mech.fieldRange += 175 * 0.2
-                mech.fieldShieldingScale *= 0.55
+                m.fieldRange += 175 * 0.2
+                m.fieldShieldingScale *= 0.55
             },
             remove() {
-                mech.fieldRange = 175;
-                mech.fieldShieldingScale = 1;
+                m.fieldRange = 175;
+                m.fieldShieldingScale = 1;
             }
         },
         {
@@ -3413,7 +3413,7 @@ const tech = {
             maxCount: 9,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "perfect diamagnetism"
+                return m.fieldUpgrades[m.fieldMode].name === "perfect diamagnetism"
             },
             requires: "perfect diamagnetism",
             effect() {
@@ -3430,7 +3430,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "perfect diamagnetism"
+                return m.fieldUpgrades[m.fieldMode].name === "perfect diamagnetism"
             },
             requires: "perfect diamagnetism",
             effect() {
@@ -3464,12 +3464,12 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "nano-scale manufacturing" || mech.fieldUpgrades[mech.fieldMode].name === "pilot wave"
+                return m.fieldUpgrades[m.fieldMode].name === "nano-scale manufacturing" || m.fieldUpgrades[m.fieldMode].name === "pilot wave"
             },
             requires: "nano-scale manufacturing",
             effect: () => {
-                tech.isMassEnergy = true // used in mech.grabPowerUp
-                mech.energy += 3
+                tech.isMassEnergy = true // used in m.grabPowerUp
+                m.energy += 3
             },
             remove() {
                 tech.isMassEnergy = false;
@@ -3484,11 +3484,11 @@ const tech = {
             isNonRefundable: true,
             isCustomHide: true,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "nano-scale manufacturing"
+                return m.fieldUpgrades[m.fieldMode].name === "nano-scale manufacturing"
             },
             requires: "nano-scale manufacturing",
             effect: () => {
-                mech.energy = 0.01;
+                m.energy = 0.01;
                 b.randomBot()
                 b.randomBot()
                 b.randomBot()
@@ -3504,11 +3504,11 @@ const tech = {
             isNonRefundable: true,
             isCustomHide: true,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "nano-scale manufacturing" && !(tech.isNailBotUpgrade && tech.isFoamBotUpgrade && tech.isBoomBotUpgrade && tech.isLaserBotUpgrade && tech.isOrbitBotUpgrade)
+                return m.fieldUpgrades[m.fieldMode].name === "nano-scale manufacturing" && !(tech.isNailBotUpgrade && tech.isFoamBotUpgrade && tech.isBoomBotUpgrade && tech.isLaserBotUpgrade && tech.isOrbitBotUpgrade)
             },
             requires: "nano-scale manufacturing",
             effect: () => {
-                mech.energy = 0.01;
+                m.energy = 0.01;
                 //fill array of available bots
                 const notUpgradedBots = []
                 if (!tech.isNailBotUpgrade) notUpgradedBots.push(() => {
@@ -3563,7 +3563,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.maxEnergy > 0.99 && mech.fieldUpgrades[mech.fieldMode].name === "nano-scale manufacturing" && !(tech.isMissileField || tech.isIceField || tech.isFastDrones || tech.isDroneGrab)
+                return m.maxEnergy > 0.99 && m.fieldUpgrades[m.fieldMode].name === "nano-scale manufacturing" && !(tech.isMissileField || tech.isIceField || tech.isFastDrones || tech.isDroneGrab)
             },
             requires: "nano-scale manufacturing",
             effect() {
@@ -3580,7 +3580,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.maxEnergy > 0.5 && mech.fieldUpgrades[mech.fieldMode].name === "nano-scale manufacturing" && !(tech.isSporeField || tech.isIceField || tech.isFastDrones || tech.isDroneGrab)
+                return m.maxEnergy > 0.5 && m.fieldUpgrades[m.fieldMode].name === "nano-scale manufacturing" && !(tech.isSporeField || tech.isIceField || tech.isFastDrones || tech.isDroneGrab)
             },
             requires: "nano-scale manufacturing",
             effect() {
@@ -3597,7 +3597,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "nano-scale manufacturing" && !(tech.isSporeField || tech.isMissileField || tech.isFastDrones || tech.isDroneGrab)
+                return m.fieldUpgrades[m.fieldMode].name === "nano-scale manufacturing" && !(tech.isSporeField || tech.isMissileField || tech.isFastDrones || tech.isDroneGrab)
             },
             requires: "nano-scale manufacturing",
             effect() {
@@ -3631,7 +3631,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "negative mass field"
+                return m.fieldUpgrades[m.fieldMode].name === "negative mass field"
             },
             requires: "negative mass field",
             effect() {
@@ -3648,7 +3648,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "negative mass field" || mech.fieldUpgrades[mech.fieldMode].name === "pilot wave"
+                return m.fieldUpgrades[m.fieldMode].name === "negative mass field" || m.fieldUpgrades[m.fieldMode].name === "pilot wave"
             },
             requires: "negative mass field",
             effect() {
@@ -3665,7 +3665,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "pilot wave" || mech.fieldUpgrades[mech.fieldMode].name === "negative mass field" || mech.fieldUpgrades[mech.fieldMode].name === "time dilation field"
+                return m.fieldUpgrades[m.fieldMode].name === "pilot wave" || m.fieldUpgrades[m.fieldMode].name === "negative mass field" || m.fieldUpgrades[m.fieldMode].name === "time dilation field"
             },
             requires: "pilot wave, negative mass field, time dilation field",
             effect() {
@@ -3682,7 +3682,7 @@ const tech = {
         //     maxCount: 1,
         //     count: 0,
         //     allowed() {
-        //         return mech.fieldUpgrades[mech.fieldMode].name === "plasma torch" && !tech.isEnergyHealth
+        //         return m.fieldUpgrades[m.fieldMode].name === "plasma torch" && !tech.isEnergyHealth
         //     },
         //     requires: "plasma torch, not mass-energy equivalence",
         //     effect() {
@@ -3699,7 +3699,7 @@ const tech = {
             maxCount: 9,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "plasma torch"
+                return m.fieldUpgrades[m.fieldMode].name === "plasma torch"
             },
             requires: "plasma torch",
             effect() {
@@ -3716,7 +3716,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "plasma torch"
+                return m.fieldUpgrades[m.fieldMode].name === "plasma torch"
             },
             requires: "plasma torch",
             effect() {
@@ -3734,7 +3734,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "plasma torch"
+                return m.fieldUpgrades[m.fieldMode].name === "plasma torch"
             },
             requires: "plasma torch",
             effect() {
@@ -3751,7 +3751,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "time dilation field"
+                return m.fieldUpgrades[m.fieldMode].name === "time dilation field"
             },
             requires: "time dilation field",
             effect() {
@@ -3770,19 +3770,19 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "time dilation field" || mech.fieldUpgrades[mech.fieldMode].name === "pilot wave"
+                return m.fieldUpgrades[m.fieldMode].name === "time dilation field" || m.fieldUpgrades[m.fieldMode].name === "pilot wave"
             },
             requires: "time dilation field",
             effect() {
                 tech.fastTime = 1.40;
                 tech.fastTimeJump = 1.11;
-                mech.setMovement();
+                m.setMovement();
                 b.setFireCD();
             },
             remove() {
                 tech.fastTime = 1;
                 tech.fastTimeJump = 1;
-                mech.setMovement();
+                m.setMovement();
                 b.setFireCD();
             }
         },
@@ -3793,16 +3793,16 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return (mech.fieldUpgrades[mech.fieldMode].name === "time dilation field" || mech.fieldUpgrades[mech.fieldMode].name === "pilot wave") && tech.energyRegen !== 0;
+                return (m.fieldUpgrades[m.fieldMode].name === "time dilation field" || m.fieldUpgrades[m.fieldMode].name === "pilot wave") && tech.energyRegen !== 0;
             },
             requires: "time dilation field",
             effect: () => {
                 tech.energyRegen = 0.004;
-                mech.fieldRegen = tech.energyRegen;
+                m.fieldRegen = tech.energyRegen;
             },
             remove() {
                 tech.energyRegen = 0.001;
-                mech.fieldRegen = tech.energyRegen;
+                m.fieldRegen = tech.energyRegen;
             }
         },
         {
@@ -3812,7 +3812,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "metamaterial cloaking"
+                return m.fieldUpgrades[m.fieldMode].name === "metamaterial cloaking"
             },
             requires: "metamaterial cloaking",
             effect() {
@@ -3829,7 +3829,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "metamaterial cloaking"
+                return m.fieldUpgrades[m.fieldMode].name === "metamaterial cloaking"
             },
             requires: "metamaterial cloaking",
             effect() {
@@ -3846,7 +3846,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "metamaterial cloaking" || mech.fieldUpgrades[mech.fieldMode].name === "pilot wave"
+                return m.fieldUpgrades[m.fieldMode].name === "metamaterial cloaking" || m.fieldUpgrades[m.fieldMode].name === "pilot wave"
             },
             requires: "metamaterial cloaking",
             effect() {
@@ -3865,7 +3865,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "wormhole"
+                return m.fieldUpgrades[m.fieldMode].name === "wormhole"
             },
             requires: "wormhole",
             effect() {
@@ -3882,7 +3882,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "wormhole"
+                return m.fieldUpgrades[m.fieldMode].name === "wormhole"
             },
             requires: "wormhole",
             effect() {
@@ -3899,7 +3899,7 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "wormhole"
+                return m.fieldUpgrades[m.fieldMode].name === "wormhole"
             },
             requires: "wormhole",
             effect() {
@@ -3916,13 +3916,13 @@ const tech = {
             maxCount: 1,
             count: 0,
             allowed() {
-                return mech.fieldUpgrades[mech.fieldMode].name === "wormhole"
+                return m.fieldUpgrades[m.fieldMode].name === "wormhole"
             },
             requires: "wormhole",
             effect() {
                 tech.isWormBullets = true
-                powerUps.spawn(mech.pos.x, mech.pos.y, "gun");
-                powerUps.spawn(mech.pos.x, mech.pos.y, "ammo");
+                powerUps.spawn(m.pos.x, m.pos.y, "gun");
+                powerUps.spawn(m.pos.x, m.pos.y, "ammo");
             },
             remove() {
                 tech.isWormBullets = false
@@ -3945,7 +3945,7 @@ const tech = {
             requires: "",
             effect() {
                 for (let i = 0; i < 6; i++) {
-                    powerUps.spawn(mech.pos.x, mech.pos.y, "heal");
+                    powerUps.spawn(m.pos.x, m.pos.y, "heal");
                 }
                 this.count--
             },
@@ -3964,7 +3964,7 @@ const tech = {
             requires: "not exciton lattice",
             effect() {
                 for (let i = 0; i < 6; i++) {
-                    powerUps.spawn(mech.pos.x, mech.pos.y, "ammo");
+                    powerUps.spawn(m.pos.x, m.pos.y, "ammo");
                 }
                 this.count--
             },
@@ -3983,7 +3983,7 @@ const tech = {
             requires: "not superdeterminism",
             effect() {
                 for (let i = 0; i < 4; i++) {
-                    powerUps.spawn(mech.pos.x, mech.pos.y, "research");
+                    powerUps.spawn(m.pos.x, m.pos.y, "research");
                 }
                 this.count--
             },
@@ -4001,7 +4001,7 @@ const tech = {
             },
             requires: "not superdeterminism",
             effect() {
-                powerUps.spawn(mech.pos.x, mech.pos.y, "gun");
+                powerUps.spawn(m.pos.x, m.pos.y, "gun");
                 this.count--
             },
             remove() {}
@@ -4018,7 +4018,7 @@ const tech = {
             },
             requires: "not superdeterminism",
             effect() {
-                powerUps.spawn(mech.pos.x, mech.pos.y, "field");
+                powerUps.spawn(m.pos.x, m.pos.y, "field");
                 this.count--
             },
             remove() {}
diff --git a/todo.txt b/todo.txt
index 2fc07c5..f860b0c 100644
--- a/todo.txt
+++ b/todo.txt
@@ -1,14 +1,7 @@
 ******************************************************** NEXT PATCH ********************************************************
 
-duplication bug fix
-
-renaming custom mode -> experimental mode
-  experimental mode is available again even without completing lore
-
-mob: sneaker is a bit faster and stronger
-  (the invisible one that attacks from stealth)
-
-tech: unified field theory - switching guns uses a reroll to cycle your field
+to continue playing after the final boss you need to use testing mode:  "T" -> "U"
+renamed mech -> m
 
 ******************************************************** BUGS ********************************************************
 
@@ -30,6 +23,10 @@ tech: unified field theory - switching guns uses a reroll to cycle your field
 
 ******************************************************** TODO ********************************************************
 
+rename ?
+  health -> integrity, unity
+  heal -> also integrity, unity
+
 mechanic: use gun swap as an active ability
   this effect is spammable, so it needs a cost or a cooldown
   tech:
@@ -52,7 +49,7 @@ tech: double your rerolls
   might want to use a single variable for all duplication
 
 bot that follows the players history
-  could have the same shape as the mech circle head
+  could have the same shape as the m circle head
   1st bot is at 5s, 2nd is at 4.5s, ...
   bots don't get too close to player
     run smoothing on position update, don't update if close to player, based on ordering
@@ -68,13 +65,9 @@ tech: dodge chance for cloaking, harmonic fields, also pilot wave
   set to 100% harm reduction randomly
     if (Math.random() < 0.2)  damage *= 0;
 
-rename ?
-  health -> integrity, unity
-  heal -> also integrity, unity
-
 in game console
   set highlighting rules
-    mech, tech, level are all highlighted
+    m, tech, level are all highlighted
     maybe the first term in each variable should get a highlight
 
 tech: time dilation - when you exit time dilation rewind to the state you entered
@@ -89,14 +82,14 @@ mechanic: technological dead end - add tech to the tech pool with a dumb effect
   don't show up in custom?
   negative effect (one time effects are better to avoid code clutter)
     make the player rainbow colors
-      mech.color = {
+      m.color = {
         hue: 0,
         sat: 100,
         light: 50
       }
       setInterval(function(){
-          mech.color.hue++
-          mech.setFillColors()
+          m.color.hue++
+          m.setFillColors()
       }, 10);
     remove all your energy
     eject all your rerolls (not bad with dup)
@@ -200,7 +193,7 @@ tech "Solar Power": Energy regeneration is doubled while standing still
 mechanic - remove a random tech as a condition for picking up a really good mod
 
 mechanic - do something for 2 seconds after firing
-  if (mech.fireCDcycle + 120)
+  if (m.fireCDcycle + 120)
 
 tech- do 50% more damage in close, but 50% less at a distance
   code it like techisFarAwayDmg
@@ -243,7 +236,7 @@ mouse event e.which is deprecated
 
 add some more computer / AI stuff to the level lore text
 
-mechanic - shrink mech.baseHealth in a tech or field
+mechanic - shrink m.baseHealth in a tech or field
 
 standing wave harmonics tech- push things away
   push scales with mass up to about 4
@@ -290,7 +283,7 @@ atmosphere levels
   change the pace, give the user a rest between combat
   low or no combat, but more graphics
   explore lore
-    find power ups in "wrecked" mechs representing previous simulations
+    find power ups in "wrecked" m representing previous simulations
       how you could leave something in one simulation that effects a different simulation
         Maybe some strange quantum physics principle.
     add text for player thoughts?
@@ -371,7 +364,7 @@ cool names for tech
 lore - a robot (the player) gains self awareness
   each tech gun/field is a new tech
     all the technology leads to the singularity
-  each game run is actually the mech simulating a possible escape
+  each game run is actually the m simulating a possible escape
     this is why the graphics are so bad, its just a simulation
     final tech is "this is just a simulation"
       you get immortality and Infinity damage