From a6ad4826867497dfb13772dc5f1d2655f50f8a19 Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Sun, 10 Mar 2024 15:26:35 -0500
Subject: [PATCH 01/19] Add files via upload

---
 mods/modM.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 mods/modM.js

diff --git a/mods/modM.js b/mods/modM.js
new file mode 100644
index 00000000..aeb826cc
--- /dev/null
+++ b/mods/modM.js
@@ -0,0 +1,19 @@
+console.log("run mod")
+elements.turbine = { color: "#524945",
+    behavior: behaviors.WALL
+    category: "solids",
+	state: "solid",
+    density: 720,
+};
+elements.coolant = { color: "#16c1db",
+    behavior: behaviors.WALL
+    category: "liquids",
+	state: "liquid",
+    density: 720,
+	tempHigh: 1000,
+};
+elements.unstable_coolant = { color: "#16c1db",
+ behavior: behaviors.DGAS,
+ category: "gases",
+	state: "gas",
+};
\ No newline at end of file

From b83e410c627c793ce3b066006ae91ae1b77dcdbe Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Sun, 10 Mar 2024 15:51:49 -0500
Subject: [PATCH 02/19] modM.js

---
 mods/modM.js | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/mods/modM.js b/mods/modM.js
index aeb826cc..53601f84 100644
--- a/mods/modM.js
+++ b/mods/modM.js
@@ -16,4 +16,17 @@ elements.unstable_coolant = { color: "#16c1db",
  behavior: behaviors.DGAS,
  category: "gases",
 	state: "gas",
-};
\ No newline at end of file
+};
+elements.hello_world = {
+	color: "#ff0000",
+	behavior: behaviors.WALL,
+	category: "land",
+	state: "solid",
+};
+
+elements.hello_world = {
+	color: "#ff0000",
+	behavior: behaviors.WALL,
+	category: "land",
+	state: "solid",
+};

From 11b6a4cede4534d35aad8cf501b14d7de7897d4c Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Mon, 11 Mar 2024 15:52:40 -0500
Subject: [PATCH 03/19] Update modM.js

---
 mods/modM.js | 172 ++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 149 insertions(+), 23 deletions(-)

diff --git a/mods/modM.js b/mods/modM.js
index 53601f84..f9d4cf7f 100644
--- a/mods/modM.js
+++ b/mods/modM.js
@@ -1,32 +1,158 @@
-console.log("run mod")
-elements.turbine = { color: "#524945",
-    behavior: behaviors.WALL
-    category: "solids",
-	state: "solid",
-    density: 720,
-};
-elements.coolant = { color: "#16c1db",
-    behavior: behaviors.WALL
-    category: "liquids",
-	state: "liquid",
-    density: 720,
-	tempHigh: 1000,
-};
-elements.unstable_coolant = { color: "#16c1db",
- behavior: behaviors.DGAS,
- category: "gases",
-	state: "gas",
-};
-elements.hello_world = {
+elements.heatSensor = {
 	color: "#ff0000",
-	behavior: behaviors.WALL,
+    conduct: 1,
+    category:"machines",
+	tick: function(pixel) {
+        if (pixel.temp > 430 ) {
+              pixel.charge = 5;
+        }
+    },
+	conduct: 1,
+};
+let itemA = "steam";
+elements.turbine = {
+  behavior: behaviors.WALL,
+  behavior: behaviors.DELETE,
+      color: "#826c6e",
+          tick: function(pixel) {
+        if(pixel.start == pixelTicks){
+          pixel.clone = itemA;
+        }
+
+          for (var i = 0; i < adjacentCoords.length; i++) {
+              var coords = adjacentCoords[i];
+              var x = pixel.x + coords[0];
+              var y = pixel.y + coords[1];
+              if (!isEmpty(x,y,true)) {
+                  var sensed = pixelMap[x][y];
+                  if (sensed.element == pixel.clone) {
+                      pixel.charge = 5;
+                      break;
+                  }
+              }
+          }
+          doDefaults(pixel);
+      },
+      conduct: 1,
+      movable: false,
+      category:"machines",
+      darkText: true,
+  hardness: 1,
+
+  };
+
+
+elements.coal  = {
+	color: "#3d3c39",
+	behavior: behaviors.POWDER,
 	category: "land",
 	state: "solid",
+	
+	tick: function(pixel) {
+        if (pixel.temp > 900 && !pixel.burning) {
+            pixel.burning = true;
+            pixel.burnStart = pixelTicks;
+        }
+    },
+	
+	tempHigh:2500,
+    stateHigh: "fire",
+    hardness: 0.85,
+    burn: 100,
+    burnTime: 3500,
 };
 
-elements.hello_world = {
-	color: "#ff0000",
+elements.solid_coal = {
+	color: "#3d3c39",
 	behavior: behaviors.WALL,
 	category: "land",
 	state: "solid",
+	breakInto: "coal_dust"
+	
+	tick: function(pixel) {
+        if (pixel.temp > 900 && !pixel.burning) {
+            pixel.burning = true;
+            pixel.burnStart = pixelTicks;
+        }
+    },
+	
+	tempHigh:3000,
+    stateHigh: "fire",
+    hardness: 0.85,
+    burn: 100,
+    burnTime: 3500,
 };
+
+ elements.coal_dust = {
+	color: "#3d3c39",
+	behavior: behaviors.POWDER,
+	category: "land",
+	state: "solid",
+	
+	tick: function(pixel) {
+        if (pixel.temp > 900 && !pixel.burning) {
+            pixel.burning = true;
+            pixel.burnStart = pixelTicks;
+        }
+    },
+	
+	tempHigh:2000,
+    stateHigh: "fire",
+    hardness: 0.85,
+    burn: 100,
+    burnTime: 3500,
+};
+
+
+elements.gas = {
+    color: "#c9c5b1",
+    behavior: behaviors.LIQUID,
+    tick: function(pixel) {
+        if (pixel.temp > 430 && !pixel.burning) {
+            pixel.burning = true;
+            pixel.burnStart = pixelTicks;
+        }
+    },
+	tempHigh:3000,
+    stateHigh: "fire",
+    viscosity: 0.56,
+    burn: 100,
+    burnTime: 10000,
+    fireColor: "#c9c5b1",
+    category: "liquids",
+    state: "liquid",
+    density: 792,
+    stain: -0.25,
+}
+
+let itemB = "light";
+elements.solar_panel = {
+  behavior: behaviors.WALL,
+ behavior: behaviors.DELETE,
+      color: "#bebfa3",
+          tick: function(pixel) {
+        if(pixel.start == pixelTicks){
+          pixel.clone = itemB;
+        }
+
+          for (var i = 0; i < adjacentCoords.length; i++) {
+              var coords = adjacentCoords[i];
+              var x = pixel.x + coords[0];
+              var y = pixel.y + coords[1];
+              if (!isEmpty(x,y,true)) {
+                  var sensed = pixelMap[x][y];
+                  if (sensed.element == pixel.clone) {
+                      pixel.charge = 5;
+                      break;
+                  }
+              }
+          }
+          doDefaults(pixel);
+      },
+      conduct: 1,
+      movable: false,
+      category:"machines",
+      darkText: true,
+  hardness: 1,
+
+  };

From 871d4c8f014d950d533e579a7ea3ee132b780917 Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Mon, 11 Mar 2024 16:16:11 -0500
Subject: [PATCH 04/19] Update modM.js

---
 mods/modM.js | 43 +++++++++++++++++++++++--------------------
 1 file changed, 23 insertions(+), 20 deletions(-)

diff --git a/mods/modM.js b/mods/modM.js
index f9d4cf7f..d5576a1d 100644
--- a/mods/modM.js
+++ b/mods/modM.js
@@ -62,26 +62,6 @@ elements.coal  = {
     burnTime: 3500,
 };
 
-elements.solid_coal = {
-	color: "#3d3c39",
-	behavior: behaviors.WALL,
-	category: "land",
-	state: "solid",
-	breakInto: "coal_dust"
-	
-	tick: function(pixel) {
-        if (pixel.temp > 900 && !pixel.burning) {
-            pixel.burning = true;
-            pixel.burnStart = pixelTicks;
-        }
-    },
-	
-	tempHigh:3000,
-    stateHigh: "fire",
-    hardness: 0.85,
-    burn: 100,
-    burnTime: 3500,
-};
 
  elements.coal_dust = {
 	color: "#3d3c39",
@@ -156,3 +136,26 @@ elements.solar_panel = {
   hardness: 1,
 
   };
+
+elements.titanium = {
+	conduct: 1,
+	color: "#a1ada5",
+	tempHigh:3000,
+    stateHigh: "molten_titanium",
+    category: "solids",
+    state: "soild",
+	 hardness: 1,
+    density: 792,
+	behavior: behaviors.WALL,
+};
+
+elements.molten_titanium = {
+	conduct: 1,
+	color: "#d16e04",
+	tempLow:2999,
+    stateLow: "titanium",
+    category: "solids",
+    state: "soild",
+    density: 792,
+	behavior: behaviors.MOLTEN,
+};

From 590d64c4fe4b141389d88578335b3bad736ccdb7 Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Mon, 11 Mar 2024 19:09:24 -0500
Subject: [PATCH 05/19] Update and rename mods/modM.js to ExtraMachines.js

---
 mods/modM.js => ExtraMachines.js | 42 +++++++++++++++++++++++++++-----
 1 file changed, 36 insertions(+), 6 deletions(-)
 rename mods/modM.js => ExtraMachines.js (80%)

diff --git a/mods/modM.js b/ExtraMachines.js
similarity index 80%
rename from mods/modM.js
rename to ExtraMachines.js
index d5576a1d..056eaf69 100644
--- a/mods/modM.js
+++ b/ExtraMachines.js
@@ -12,7 +12,7 @@ elements.heatSensor = {
 let itemA = "steam";
 elements.turbine = {
   behavior: behaviors.WALL,
-  behavior: behaviors.DELETE,
+  
       color: "#826c6e",
           tick: function(pixel) {
         if(pixel.start == pixelTicks){
@@ -26,6 +26,7 @@ elements.turbine = {
               if (!isEmpty(x,y,true)) {
                   var sensed = pixelMap[x][y];
                   if (sensed.element == pixel.clone) {
+					  deletePixel(x,y);
                       pixel.charge = 5;
                       break;
                   }
@@ -45,8 +46,10 @@ elements.turbine = {
 elements.coal  = {
 	color: "#3d3c39",
 	behavior: behaviors.POWDER,
-	category: "land",
+	category: "powders",
 	state: "solid",
+	density: 208,
+    conduct: 0.001
 	
 	tick: function(pixel) {
         if (pixel.temp > 900 && !pixel.burning) {
@@ -68,6 +71,9 @@ elements.coal  = {
 	behavior: behaviors.POWDER,
 	category: "land",
 	state: "solid",
+	stain: 1,
+	density: 190,
+    conduct: 0.001
 	
 	tick: function(pixel) {
         if (pixel.temp > 900 && !pixel.burning) {
@@ -78,7 +84,7 @@ elements.coal  = {
 	
 	tempHigh:2000,
     stateHigh: "fire",
-    hardness: 0.85,
+    hardness: 0.3,
     burn: 100,
     burnTime: 3500,
 };
@@ -122,6 +128,7 @@ elements.solar_panel = {
               if (!isEmpty(x,y,true)) {
                   var sensed = pixelMap[x][y];
                   if (sensed.element == pixel.clone) {
+					  deletePixel(x,y);
                       pixel.charge = 5;
                       break;
                   }
@@ -138,7 +145,7 @@ elements.solar_panel = {
   };
 
 elements.titanium = {
-	conduct: 1,
+	conduct: 0,
 	color: "#a1ada5",
 	tempHigh:3000,
     stateHigh: "molten_titanium",
@@ -150,12 +157,35 @@ elements.titanium = {
 };
 
 elements.molten_titanium = {
-	conduct: 1,
+	conduct: 0,
 	color: "#d16e04",
 	tempLow:2999,
     stateLow: "titanium",
-    category: "solids",
+    category: "states",
     state: "soild",
     density: 792,
 	behavior: behaviors.MOLTEN,
 };
+
+elements.solid_coal = {
+	color: "#3d3c39",
+	behavior: behaviors.WALL,
+	category: "land",
+	state: "solid",
+	breakInto: "coal_dust",
+	density: 380,
+    conduct: 0.001
+	
+	tick: function(pixel) {
+        if (pixel.temp > 900 && !pixel.burning) {
+            pixel.burning = true;
+            pixel.burnStart = pixelTicks;
+        }
+    },
+	
+	tempHigh:3000,
+    stateHigh: "fire",
+    hardness: 0.85,
+    burn: 100,
+    burnTime: 3500,
+};

From 47841aef14e6913a07852e207724e58f340cc028 Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Mon, 11 Mar 2024 19:41:02 -0500
Subject: [PATCH 06/19] Update ExtraMachines.js

---
 ExtraMachines.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ExtraMachines.js b/ExtraMachines.js
index 056eaf69..7cf06243 100644
--- a/ExtraMachines.js
+++ b/ExtraMachines.js
@@ -49,7 +49,7 @@ elements.coal  = {
 	category: "powders",
 	state: "solid",
 	density: 208,
-    conduct: 0.001
+    conduct: 0.001,
 	
 	tick: function(pixel) {
         if (pixel.temp > 900 && !pixel.burning) {
@@ -73,7 +73,7 @@ elements.coal  = {
 	state: "solid",
 	stain: 1,
 	density: 190,
-    conduct: 0.001
+    conduct: 0.001,
 	
 	tick: function(pixel) {
         if (pixel.temp > 900 && !pixel.burning) {
@@ -174,7 +174,7 @@ elements.solid_coal = {
 	state: "solid",
 	breakInto: "coal_dust",
 	density: 380,
-    conduct: 0.001
+    conduct: 0.001,
 	
 	tick: function(pixel) {
         if (pixel.temp > 900 && !pixel.burning) {

From f6241a18bc124011fc48093025539a874459641c Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Mon, 11 Mar 2024 19:43:55 -0500
Subject: [PATCH 07/19] Update ExtraMachines.js

---
 ExtraMachines.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/ExtraMachines.js b/ExtraMachines.js
index 7cf06243..14d2951e 100644
--- a/ExtraMachines.js
+++ b/ExtraMachines.js
@@ -114,7 +114,6 @@ elements.gas = {
 let itemB = "light";
 elements.solar_panel = {
   behavior: behaviors.WALL,
- behavior: behaviors.DELETE,
       color: "#bebfa3",
           tick: function(pixel) {
         if(pixel.start == pixelTicks){

From f5f75e067da8a3752c740edf0a20539d370c53aa Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Mon, 11 Mar 2024 20:21:00 -0500
Subject: [PATCH 08/19] Add files via upload

all the current elements
---
 sandboxels-screenshot (1).png | Bin 0 -> 17105 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 sandboxels-screenshot (1).png

diff --git a/sandboxels-screenshot (1).png b/sandboxels-screenshot (1).png
new file mode 100644
index 0000000000000000000000000000000000000000..1dc044631119e1a997fb4783c9e871f3ae1f3e33
GIT binary patch
literal 17105
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
G@qYj|EPpis

literal 0
HcmV?d00001


From 1b993bd720e394e28578aec8b92efff75fe1e64a Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Mon, 11 Mar 2024 20:23:13 -0500
Subject: [PATCH 09/19] Update ExtraMachines.js

---
 ExtraMachines.js | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/ExtraMachines.js b/ExtraMachines.js
index 14d2951e..ee52974e 100644
--- a/ExtraMachines.js
+++ b/ExtraMachines.js
@@ -46,7 +46,7 @@ elements.turbine = {
 elements.coal  = {
 	color: "#3d3c39",
 	behavior: behaviors.POWDER,
-	category: "powders",
+	category: "energy",
 	state: "solid",
 	density: 208,
     conduct: 0.001,
@@ -69,7 +69,7 @@ elements.coal  = {
  elements.coal_dust = {
 	color: "#3d3c39",
 	behavior: behaviors.POWDER,
-	category: "land",
+	category: "powders",
 	state: "solid",
 	stain: 1,
 	density: 190,
@@ -145,7 +145,7 @@ elements.solar_panel = {
 
 elements.titanium = {
 	conduct: 0,
-	color: "#a1ada5",
+	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
 	tempHigh:3000,
     stateHigh: "molten_titanium",
     category: "solids",
@@ -169,7 +169,7 @@ elements.molten_titanium = {
 elements.solid_coal = {
 	color: "#3d3c39",
 	behavior: behaviors.WALL,
-	category: "land",
+	category: "energy",
 	state: "solid",
 	breakInto: "coal_dust",
 	density: 380,
@@ -188,3 +188,13 @@ elements.solid_coal = {
     burn: 100,
     burnTime: 3500,
 };
+
+elements.rubber = {
+	color: "#ffc0cb",
+	 hardness: 0.5,
+	 tempHigh:180,
+	 state: "solid",
+	 behavior: behaviors.WALL,
+	 conduct: 0,
+	 category: "solids",
+};

From 76f13837cd4fabd73f1fc4fa541a1496afe42b6d Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Tue, 12 Mar 2024 16:30:39 -0500
Subject: [PATCH 10/19] Update ExtraMachines.js

---
 ExtraMachines.js | 230 ++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 227 insertions(+), 3 deletions(-)

diff --git a/ExtraMachines.js b/ExtraMachines.js
index ee52974e..b34bf458 100644
--- a/ExtraMachines.js
+++ b/ExtraMachines.js
@@ -1,10 +1,11 @@
 elements.heatSensor = {
 	color: "#ff0000",
     conduct: 1,
-    category:"machines",
+    category:"test",
+	behavior: behaviors.WALL,
 	tick: function(pixel) {
         if (pixel.temp > 430 ) {
-              pixel.charge = 5;
+              pixel.charge = 1;
         }
     },
 	conduct: 1,
@@ -90,7 +91,7 @@ elements.coal  = {
 };
 
 
-elements.gas = {
+elements.gasoline = {
     color: "#c9c5b1",
     behavior: behaviors.LIQUID,
     tick: function(pixel) {
@@ -198,3 +199,226 @@ elements.rubber = {
 	 conduct: 0,
 	 category: "solids",
 };
+
+elements.coolant = {
+	color: "#71ded3",
+	 state: "liquid",
+	  behavior: behaviors.LIQUID,
+	 behavior: [
+        "XX|CO:2|XX",
+        "CO:2|XX|CO:2",
+        "XX|CO:2|XX",
+    ],
+	 conduct: 0.5,
+	 category: "test",
+	 
+};
+
+elements.e_cooler = {
+	color: elements.cooler.color,
+	 hardness: 0.5,
+	 state: "solid",
+	 behavior: behaviors.WALL,
+	 conduct: 1,
+	 category: "machines",
+	 behaviorOn: [
+        "XX|CO:2|XX",
+        "CO:2|XX|CO:2",
+        "XX|CO:2|XX",
+    ],
+	name: "E-Cooler",
+};
+
+elements.e_Freezer = {
+	color: elements.cooler.color,
+	 hardness: 0.5,
+	 state: "solid",
+	 behavior: behaviors.WALL,
+	 conduct: 1,
+	 category: "machines",
+	 behaviorOn: [
+        "XX|CO:10|XX",
+        "CO:10|XX|CO:10",
+        "XX|CO:10|XX",
+    ],
+	name: "E-Freezer",
+};
+
+elements.e_heater = {
+	 hardness: 0.5,
+	 state: "solid",
+	 behavior: behaviors.WALL,
+	 conduct: 1,
+	 category: "machines",
+	  color: "#881111",
+    behaviorOn: [
+        "XX|HT:4|XX",
+        "HT:4|XX|HT:4",
+        "XX|HT:4|XX",
+    ],
+	name: "E-Heater",
+};
+
+elements.e_SuperHeater = {
+	 hardness: 0.5,
+	 state: "solid",
+	 behavior: behaviors.WALL,
+	 conduct: 1,
+	 category: "machines",
+	  color: "#881111",
+    behaviorOn: [
+        "XX|HT:12|XX",
+        "HT:12|XX|HT:12",
+        "XX|HT:12|XX",
+    ],
+	name: "E-SuperHeater",
+};
+
+elements.slow_Ecloner = {
+	 color: "#888800",
+	 behavior: behaviors.WALL,
+    behaviorOn: [
+        "XX|CF%10|XX",
+        "CF%10|XX|CF%10",
+        "XX|CF%10|XX",
+    ],
+    ignore: ["cloner","ecloner","clone_powder","floating_cloner","wall","ewall","turbine","solar_panel"],
+    category:"machines",
+    insulate:true,
+    hardness: 1,
+	conduct: 1,
+	name: "E-SlowCloner",
+};
+
+elements.Android = {
+	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
+    category: "life",
+	color: ["#f3e7db","#f7ead0","#eadaba","#d7bd96","#a07e56","#825c43","#604134","#3a312a"],
+    category: "life",
+    properties: {
+        dead: false,
+        dir: 1,
+        panic: 0
+    },
+    tick: function(pixel) {
+        if (isEmpty(pixel.x, pixel.y+1)) {
+            createPixel("AndroidBody", pixel.x, pixel.y+1);
+            pixel.element = "AndroidHead";
+        }
+        else if (isEmpty(pixel.x, pixel.y-1)) {
+            createPixel("AndroidHead", pixel.x, pixel.y-1);
+            pixelMap[pixel.x][pixel.y-1].color = pixel.color;
+            pixel.element = "AndroidBody";
+            pixel.color = pixelColorPick(pixel)
+        }
+        else {
+            deletePixel(pixel.x, pixel.y);
+        }
+    },
+    related: ["AndroidBody","AndroidHead"],
+    cooldown: defaultCooldown
+};
+
+
+elements.AndroidBody = {
+	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
+    category: "life",
+	 breakInto: ["oil","metal_scrap","explosion"],
+	 properties: {
+        dead: false,
+        dir: 1,
+        panic: 0
+    },
+    tick: function(pixel) {
+        if (tryMove(pixel, pixel.x, pixel.y+1)) { // Fall
+            if (!isEmpty(pixel.x, pixel.y-2, true)) { // Drag head down
+                var headpixel = pixelMap[pixel.x][pixel.y-2];
+                if (headpixel.element == "AndroidHead") {
+                    if (isEmpty(pixel.x, pixel.y-1)) {
+                        movePixel(pixelMap[pixel.x][pixel.y-2], pixel.x, pixel.y-1);
+                    }
+                    else {
+                        swapPixels(pixelMap[pixel.x][pixel.y-2], pixelMap[pixel.x][pixel.y-1]);
+                    }
+                }
+            }
+        }
+        doHeat(pixel);
+        doBurning(pixel);
+        doElectricity(pixel);
+        if (pixel.dead) {
+            // Turn into rotten_meat if pixelTicks-dead > 500
+            if (pixelTicks-pixel.dead > 200 && Math.random() < 0.1) {
+                changePixel(pixel,"rotten_meat");
+            }
+            return
+        }
+
+        // Find the head
+        if (!isEmpty(pixel.x, pixel.y-1, true) && pixelMap[pixel.x][pixel.y-1].element == "AndroidHead") {
+            var head = pixelMap[pixel.x][pixel.y-1];
+            if (head.dead) { // If head is dead, kill body
+                pixel.dead = head.dead;
+            }
+        }
+        else { var head = null }
+        if (pixel.burning) {
+            pixel.panic += 0.1;
+            if (head && pixelTicks-pixel.burnStart > 240) {
+                pixel.color = head.color;
+            }
+        }
+        else if (pixel.panic > 0) {
+            pixel.panic -= 0.1;
+        }
+
+        if (isEmpty(pixel.x, pixel.y-1)) {
+            // create blood if decapitated 10% chance
+            if (Math.random() < 0.1 && !pixel.charge) {
+                createPixel("oil", pixel.x, pixel.y-1);
+                // set dead to true 15% chance
+                if (Math.random() < 0.15) {
+                    pixel.dead = pixelTicks;
+                }
+            }
+        }
+        else if (head == null) { return }
+        else if (Math.random() < 0.1*(isEmpty(pixel.x, pixel.y+1) ? 1 : pixel.panic+1)) { // Move 10% chance
+            var movesToTry = [
+                [1*pixel.dir,0],
+                [1*pixel.dir,-1],
+            ];
+            // While movesToTry is not empty, tryMove(pixel, x, y) with a random move, then remove it. if tryMove returns true, break.
+            while (movesToTry.length > 0) {
+                var move = movesToTry.splice(Math.floor(Math.random() * movesToTry.length), 1)[0];
+                if (isEmpty(pixel.x+move[0], pixel.y+move[1]-1)) {
+                    var origx = pixel.x+move[0];
+                    var origy = pixel.y+move[1];
+                    if (tryMove(pixel, pixel.x+move[0], pixel.y+move[1]) && pixel.x===origx && pixel.y===origy) {
+                        movePixel(head, head.x+move[0], head.y+move[1]);
+                        break;
+                    }
+                }
+            }
+            // 15% chance to change direction
+            if (Math.random() < 0.15) {
+                pixel.dir *= -1;
+            }
+            // homeostasis
+            if (pixel.temp > 37) { pixel.temp -= 1; }
+            else if (pixel.temp < 37) { pixel.temp += 1; }
+        }
+
+    }
+};
+
+elements.AndroidHead = {
+	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
+    category: "life",
+	density: 1080,
+    state: "solid",
+    conduct: .05,
+    temp: 69,
+    breakInto: ["oil","metal_scrap","explosion"],
+};
+

From a11d6837fda1f1b2465fc1e0071e9ad16383fddb Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Sun, 17 Mar 2024 14:57:10 -0500
Subject: [PATCH 11/19] Update ExtraMachines.js

---
 ExtraMachines.js | 832 ++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 820 insertions(+), 12 deletions(-)

diff --git a/ExtraMachines.js b/ExtraMachines.js
index b34bf458..20137987 100644
--- a/ExtraMachines.js
+++ b/ExtraMachines.js
@@ -1,19 +1,37 @@
+// this is a epic mod
+
+let heatSen = 0;
 elements.heatSensor = {
+    
 	color: "#ff0000",
     conduct: 1,
     category:"test",
 	behavior: behaviors.WALL,
+	
+	onSelect: function(pixel){
+    setTemp = parseInt(prompt("Enter the temperature you want it to sense. zero will not work", (heatSen || undefined)));
+	        
+  },
+  
+	
 	tick: function(pixel) {
-        if (pixel.temp > 430 ) {
+        if((pixel.start == pixelTicks) && !(heatSen == 0)){
+            pixel.clone.temp = heatSen
+          }
+	
+	 if (pixel.temp > pixel.clone ) {
               pixel.charge = 1;
         }
-    },
-	conduct: 1,
+
+		
+  },
+        
 };
+
 let itemA = "steam";
-elements.turbine = {
+elements.SteamTurbine = {
   behavior: behaviors.WALL,
-  
+    desc: "When steam touches it, it conducts electricity and the steam pixel is deleted",
       color: "#826c6e",
           tick: function(pixel) {
         if(pixel.start == pixelTicks){
@@ -45,6 +63,7 @@ elements.turbine = {
 
 
 elements.coal  = {
+    desc: "A black powder that burns",
 	color: "#3d3c39",
 	behavior: behaviors.POWDER,
 	category: "energy",
@@ -68,6 +87,7 @@ elements.coal  = {
 
 
  elements.coal_dust = {
+    desc: "A byproduct of smashed solid coal that burns like coal but for a shorter time",
 	color: "#3d3c39",
 	behavior: behaviors.POWDER,
 	category: "powders",
@@ -93,6 +113,7 @@ elements.coal  = {
 
 elements.gasoline = {
     color: "#c9c5b1",
+    desc: "A liquid that burns and is used to power most cars",
     behavior: behaviors.LIQUID,
     tick: function(pixel) {
         if (pixel.temp > 430 && !pixel.burning) {
@@ -115,6 +136,7 @@ elements.gasoline = {
 let itemB = "light";
 elements.solar_panel = {
   behavior: behaviors.WALL,
+  desc: "When light touches it, it conducts electricity and the light pixel is deleted",
       color: "#bebfa3",
           tick: function(pixel) {
         if(pixel.start == pixelTicks){
@@ -145,6 +167,7 @@ elements.solar_panel = {
   };
 
 elements.titanium = {
+    desc: "Another metal that does not erode nor conduct electricity",
 	conduct: 0,
 	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
 	tempHigh:3000,
@@ -157,6 +180,8 @@ elements.titanium = {
 };
 
 elements.molten_titanium = {
+    desc: "Melted version of titanium",
+    temp : 3000,
 	conduct: 0,
 	color: "#d16e04",
 	tempLow:2999,
@@ -168,6 +193,7 @@ elements.molten_titanium = {
 };
 
 elements.solid_coal = {
+    desc: "A solid version of coal",
 	color: "#3d3c39",
 	behavior: behaviors.WALL,
 	category: "energy",
@@ -191,6 +217,7 @@ elements.solid_coal = {
 };
 
 elements.rubber = {
+    desc: "Not finnished",
 	color: "#ffc0cb",
 	 hardness: 0.5,
 	 tempHigh:180,
@@ -201,20 +228,36 @@ elements.rubber = {
 };
 
 elements.coolant = {
+    desc: "Cools down pixels that touch it and is a liquid",
 	color: "#71ded3",
 	 state: "liquid",
+     insulate: true,
 	  behavior: behaviors.LIQUID,
-	 behavior: [
-        "XX|CO:2|XX",
-        "CO:2|XX|CO:2",
-        "XX|CO:2|XX",
-    ],
+      tick: function(pixel) {
+       
+
+          for (var i = 0; i < adjacentCoords.length; i++) {
+              var coords = adjacentCoords[i];
+              var x = pixel.x + coords[0];
+              var y = pixel.y + coords[1];
+              if (!isEmpty(x,y,true)) {
+                  var sensed = pixelMap[x][y];
+                  if (sensed.element && sensed.temp > 21 ) {
+					 
+                     sensed.temp -= 1;
+                      break;
+                  }
+              }
+          }
+          doDefaults(pixel);
+      },
 	 conduct: 0.5,
 	 category: "test",
 	 
 };
 
 elements.e_cooler = {
+    desc: "Works like the cooler but needs power to work",
 	color: elements.cooler.color,
 	 hardness: 0.5,
 	 state: "solid",
@@ -230,6 +273,7 @@ elements.e_cooler = {
 };
 
 elements.e_Freezer = {
+    desc: "Works like the freezer but needs power to work",
 	color: elements.cooler.color,
 	 hardness: 0.5,
 	 state: "solid",
@@ -245,6 +289,7 @@ elements.e_Freezer = {
 };
 
 elements.e_heater = {
+    desc: "Works like the heater but needs power to work",
 	 hardness: 0.5,
 	 state: "solid",
 	 behavior: behaviors.WALL,
@@ -260,6 +305,7 @@ elements.e_heater = {
 };
 
 elements.e_SuperHeater = {
+    desc: "Works like the Super Heater but needs power to work",
 	 hardness: 0.5,
 	 state: "solid",
 	 behavior: behaviors.WALL,
@@ -275,6 +321,7 @@ elements.e_SuperHeater = {
 };
 
 elements.slow_Ecloner = {
+    desc: "Works like the Slow Cloner but needs power to work",
 	 color: "#888800",
 	 behavior: behaviors.WALL,
     behaviorOn: [
@@ -282,7 +329,7 @@ elements.slow_Ecloner = {
         "CF%10|XX|CF%10",
         "XX|CF%10|XX",
     ],
-    ignore: ["cloner","ecloner","clone_powder","floating_cloner","wall","ewall","turbine","solar_panel"],
+    ignore: ["cloner","ecloner","clone_powder","floating_cloner","wall","ewall","SteamTurbine","solar_panel"],
     category:"machines",
     insulate:true,
     hardness: 1,
@@ -291,7 +338,8 @@ elements.slow_Ecloner = {
 };
 
 elements.Android = {
-	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
+    desc: "A robot",
+	color: "#a1ada5",
     category: "life",
 	color: ["#f3e7db","#f7ead0","#eadaba","#d7bd96","#a07e56","#825c43","#604134","#3a312a"],
     category: "life",
@@ -422,3 +470,763 @@ elements.AndroidHead = {
     breakInto: ["oil","metal_scrap","explosion"],
 };
 
+listPipes = "pipe"
+
+
+//thx to morechem.js for the idea
+
+let setTemp = "";
+elements.ajustableHeater = {
+    desc: "Works like a heater but it can be set to a specific temp and needs power to work",
+	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
+    category: "machines",
+	density: 1080,
+    state: "solid",
+    conduct: 1,
+	movable: false,
+	name: "Ajustable-E-Heater",
+	 onSelect: function(pixel){
+    setTemp = parseInt(prompt("Enter the temperature you want it set to.", (setTemp || undefined)));
+	        
+  },
+	tick: function(pixel) {
+        for (var i = 0; i < adjacentCoords.length; i++) {
+            var coords = adjacentCoords[i];
+            var x = pixel.x + coords[0];
+            var y = pixel.y + coords[1];
+            if (!isEmpty(x,y,true)) {
+                var sensed = pixelMap[x][y];
+                if (sensed.con || elements[sensed.element].movable && pixel.charge > 0) {
+                    sensed.temp += setTemp/6;
+					
+                    break;
+                }
+            }
+        }
+        doDefaults(pixel);
+    },
+	 insulate:true
+};
+
+//old grinder
+// elements.grinder = {
+	// color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
+    // category: "machines",
+	// density: 1080,
+    // state: "solid",
+    // conduct: 1,
+	// movable: false,
+	
+	// ignore: "grinder",
+	
+		// tick: function(pixel) {
+        // for (var i = 0; i < adjacentCoords.length; i++) {
+            // var coords = adjacentCoords[i];
+            // var x = pixel.x + coords[0];
+            // var y = pixel.y + coords[1];
+            // if (!isEmpty(x,y,true)) {
+                // var sensed = pixelMap[x][y];
+                // if (sensed.con || elements[sensed.element].movable && pixel.charge > 0) {
+                    // breakPixel(sensed);
+                // }
+            // }
+        // }
+        // doDefaults(pixel);
+    // },
+	 // insulate:true
+     
+	
+	
+// };
+
+
+
+elements.dead_plant.conduct = 1;
+// let compact = "dead_plant";
+// elements.compacter = {
+	// behavior: behaviors.WALL,
+      // color: "#bebfa3",
+          // tick: function(pixel) {
+        // if(pixel.start == pixelTicks){
+          // pixel.clone = compact;
+        // }
+		
+
+          // for (var i = 0; i < adjacentCoords.length; i++) {
+              // var coords = adjacentCoords[i];
+              // var x = pixel.x + coords[0];
+              // var y = pixel.y + coords[1];
+              // if (!isEmpty(x,y,true)) {
+                  // var sensed = pixelMap[x][y];
+                  // if (sensed.element == pixel.clone && pixel.charge > 0) {
+					 // sensed.element = "coal"
+					 // sensed.color = elements.coal.color
+                      // break;
+                  // }
+              // }
+          // }
+          // doDefaults(pixel);
+      // },
+      // conduct: 1,
+      // movable: false,
+      // category:"machines",
+      // darkText: true,
+  // hardness: 1,
+// }
+compactPi = "dead_plant";
+compactPi2 = "coal";
+elements.compacter = {
+    color: "#4e524f",
+    desc: "Turns dead plants into coal and needs power",
+    tick: function(pixel) {
+		if (pixel.start === pixelTicks) {
+			pixel.CompactEl = compactPi
+			pixel.CompactEl2 = compactPi2
+		}
+        if (1 === 2) {
+           for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+//                    createPixel("brick",x,y);
+//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
+                }
+            }
+ //           pixel.stage = 1;
+        }
+        else if (1 === 2) { //uninitialized
+            for (var i = 0; i < adjacentCoords.length; i++) {
+                var coord = adjacentCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (isEmpty(x,y)) {
+ //                   pixel.stage = 2; //blue
+ //                   pixel.color = pixelColorPick(pixel,"#000036");
+                    break;
+                }
+            }
+        }
+        else if (1 === 1) { //initialized
+            for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                    var newPixel = pixelMap[x][y];
+                    if (newPixel.stage === 1) {
+                        var newColor;
+                        switch (pixel.stage) {
+//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
+ //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
+//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
+                        }
+ //                       newPixel.color = pixelColorPick(newPixel,newColor);
+                    }
+                }
+            }
+            var moved = false;
+            shuffleArray(squareCoordsShuffle);
+            for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                var coord = squareCoordsShuffle[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+                    var newPixel = pixelMap[x][y];
+                    if (listPipes.includes(newPixel.element)) {
+                        var nextStage;
+                        switch (pixel.stage) {
+ //                           case 2: nextStage = 4; break; //green
+//                            case 3: nextStage = 2; break; //red
+ //                           case 4: nextStage = 3; break; //blue
+                        }
+                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            moved = true;
+                            break;
+                        }
+                    }
+                    else if (!pixel.con ) { //suck up pixel
+					if  ((newPixel.element == pixel.CompactEl) || (newPixel.element == pixel.CompactEl2) && pixel.charge > 0  ) {
+						
+                        pixel.con = newPixel;
+						changePixel(newPixel, "coal")
+						newPixel.color = elements.coal.color
+                        deletePixel(newPixel.x,newPixel.y);
+                        pixel.con.x = pixel.x;
+                        pixel.con.y = pixel.y;
+                        pixel.con.del;
+                        moved = true;
+                        break;
+						}
+                    }
+                }
+            }
+            if (pixel.con && !moved) { // move to same stage if none other
+                for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                    var coord = squareCoordsShuffle[i];
+                    var x = pixel.x+coord[0];
+                    var y = pixel.y+coord[1];
+                    if (isEmpty(x,y)) {
+                        delete pixel.con.del;
+                        pixel.con.x = x;
+                        pixel.con.y = y;
+                        pixelMap[x][y] = pixel.con;
+                        currentPixels.push(pixel.con);
+                        pixel.con = null;
+                        break;
+                    }
+                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                        var newPixel = pixelMap[x][y];
+                        if (pixel.con && !newPixel.con) {
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        doDefaults(pixel);
+    },
+    category: "machines",
+    movable: false,
+    canContain: true,
+	noMix: true,
+    insulate: true,
+}
+
+// thx to nousersthings mod for the filter
+// only adding this bc my freind told me so 
+// im not good at javascript and coding so yeah
+
+filterTypeVar = 0;
+elements.filter = {
+    color: "#599fc2",
+    desc: "A filter made by nouser",
+    onSelect: function() {
+        var answer4 = prompt("Please input the desired element of this filter. It is case senstive.",(filterTypeVar||undefined));
+        if (!answer4) { return }
+		filterTypeVar = answer4;
+    },
+    tick: function(pixel) {
+		if (pixel.start === pixelTicks) {
+			pixel.filterType = filterTypeVar
+		}
+        if (1 === 2) {
+           for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+//                    createPixel("brick",x,y);
+//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
+                }
+            }
+ //           pixel.stage = 1;
+        }
+        else if (1 === 2) { //uninitialized
+            for (var i = 0; i < adjacentCoords.length; i++) {
+                var coord = adjacentCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (isEmpty(x,y)) {
+ //                   pixel.stage = 2; //blue
+ //                   pixel.color = pixelColorPick(pixel,"#000036");
+                    break;
+                }
+            }
+        }
+        else if (1 === 1) { //initialized
+            for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                    var newPixel = pixelMap[x][y];
+                    if (newPixel.stage === 1) {
+                        var newColor;
+                        switch (pixel.stage) {
+//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
+ //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
+//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
+                        }
+ //                       newPixel.color = pixelColorPick(newPixel,newColor);
+                    }
+                }
+            }
+            var moved = false;
+            shuffleArray(squareCoordsShuffle);
+            for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                var coord = squareCoordsShuffle[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+                    var newPixel = pixelMap[x][y];
+                    if (listPipes.includes(newPixel.element)) {
+                        var nextStage;
+                        switch (pixel.stage) {
+ //                           case 2: nextStage = 4; break; //green
+//                            case 3: nextStage = 2; break; //red
+ //                           case 4: nextStage = 3; break; //blue
+                        }
+                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            moved = true;
+                            break;
+                        }
+                    }
+                    else if (!pixel.con ) { //suck up pixel
+					if  (newPixel.element == pixel.filterType ) {
+						
+                        pixel.con = newPixel;
+		
+                        deletePixel(newPixel.x,newPixel.y);
+                        pixel.con.x = pixel.x;
+                        pixel.con.y = pixel.y;
+                        pixel.con.del;
+                        moved = true;
+                        break;
+						}
+                    }
+                }
+            }
+            if (pixel.con && !moved) { // move to same stage if none other
+                for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                    var coord = squareCoordsShuffle[i];
+                    var x = pixel.x+coord[0];
+                    var y = pixel.y+coord[1];
+                    if (isEmpty(x,y)) {
+                        delete pixel.con.del;
+                        pixel.con.x = x;
+                        pixel.con.y = y;
+                        pixelMap[x][y] = pixel.con;
+                        currentPixels.push(pixel.con);
+                        pixel.con = null;
+                        break;
+                    }
+                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                        var newPixel = pixelMap[x][y];
+                        if (pixel.con && !newPixel.con) {
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        doDefaults(pixel);
+    },
+    category: "machines",
+    movable: false,
+    canContain: true,
+	noMix: true,
+    insulate: true,
+}
+
+filterTypeVar2 = 0;
+elements.Destructive_Filter = {
+    color: "#3c6c85",
+    desc: "A filter that destroys anything that isn't allowed to get through",
+    onSelect: function() {
+        var answer4 = prompt("Please input the desired element of this filter. It is case senstive.",(filterTypeVar||undefined));
+        if (!answer4) { return }
+		filterTypeVar2 = answer4;
+    },
+    tick: function(pixel) {
+		if (pixel.start === pixelTicks) {
+			pixel.filterType = filterTypeVar2
+		}
+        if (1 === 2) {
+           for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+//                    createPixel("brick",x,y);
+//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
+                }
+            }
+ //           pixel.stage = 1;
+        }
+        else if (1 === 2) { //uninitialized
+            for (var i = 0; i < adjacentCoords.length; i++) {
+                var coord = adjacentCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (isEmpty(x,y)) {
+ //                   pixel.stage = 2; //blue
+ //                   pixel.color = pixelColorPick(pixel,"#000036");
+                    break;
+                }
+            }
+        }
+        else if (1 === 1) { //initialized
+            for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                    var newPixel = pixelMap[x][y];
+                    if (newPixel.stage === 1) {
+                        var newColor;
+                        switch (pixel.stage) {
+//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
+ //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
+//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
+                        }
+ //                       newPixel.color = pixelColorPick(newPixel,newColor);
+                    }
+                }
+            }
+            var moved = false;
+            shuffleArray(squareCoordsShuffle);
+            for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                var coord = squareCoordsShuffle[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+                    var newPixel = pixelMap[x][y];
+                    if (listPipes.includes(newPixel.element)) {
+                        var nextStage;
+                        switch (pixel.stage) {
+ //                           case 2: nextStage = 4; break; //green
+//                            case 3: nextStage = 2; break; //red
+ //                           case 4: nextStage = 3; break; //blue
+                        }
+                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            moved = true;
+                            break;
+                        }
+                    }
+                    else if (!pixel.con ) { //suck up pixel
+					if  (newPixel.element == pixel.filterType) {
+						
+                        pixel.con = newPixel;
+		
+                        deletePixel(newPixel.x,newPixel.y);
+                        pixel.con.x = pixel.x;
+                        pixel.con.y = pixel.y;
+                        pixel.con.del;
+                        moved = true;
+                        break;
+						}
+						else if(!(newPixel.element == "filter") && !(newPixel.element == "Destructive_Filter") && !doNotEF.includes(newPixel.element) ) {
+							deletePixel(newPixel.x, newPixel.y);
+							break;
+							
+						}
+                    }
+                }
+            }
+            if (pixel.con && !moved) { // move to same stage if none other
+                for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                    var coord = squareCoordsShuffle[i];
+                    var x = pixel.x+coord[0];
+                    var y = pixel.y+coord[1];
+                    if (isEmpty(x,y)) {
+                        delete pixel.con.del;
+                        pixel.con.x = x;
+                        pixel.con.y = y;
+                        pixelMap[x][y] = pixel.con;
+                        currentPixels.push(pixel.con);
+                        pixel.con = null;
+                        break;
+                    }
+                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                        var newPixel = pixelMap[x][y];
+                        if (pixel.con && !newPixel.con) {
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        doDefaults(pixel);
+    },
+    category: "machines",
+    movable: false,
+    canContain: true,
+	noMix: true,
+    insulate: true,
+}
+
+
+
+// going to fix the sucking up solids problem soon!!
+doNotEF = ["e_grinder","grinder","filter", "battery", "wire", "cloner", "sensor", "heater","cooler", "Ajustable-E-Heater", "E-Cooler", "E-Freezer", "E-Heater", "E-SuperHeater", "E-SlowCloner", "ewall", "titanium", "tungsten", "steel", "insulation","SteamTurbine","solar_panel"];
+
+elements.grinder = {
+    color: "#55565c",
+	ignore: ["e_grinder","grinder"],
+    desc: "Grinds things",
+    tick: function(pixel) {
+		
+        if (1 === 2) {
+           for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+//                    createPixel("brick",x,y);
+//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
+                }
+            }
+ //           pixel.stage = 1;
+        }
+        else if (1 === 2) { //uninitialized
+            for (var i = 0; i < adjacentCoords.length; i++) {
+                var coord = adjacentCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (isEmpty(x,y)) {
+ //                   pixel.stage = 2; //blue
+ //                   pixel.color = pixelColorPick(pixel,"#000036");
+                    break;
+                }
+            }
+        }
+        else if (1 === 1) { //initialized
+            for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                    var newPixel = pixelMap[x][y];
+                    if (newPixel.stage === 1) {
+                        var newColor;
+                        switch (pixel.stage) {
+//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
+ //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
+//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
+                        }
+ //                       newPixel.color = pixelColorPick(newPixel,newColor);
+                    }
+                }
+            }
+            var moved = false;
+            shuffleArray(squareCoordsShuffle);
+            for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                var coord = squareCoordsShuffle[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+                    var newPixel = pixelMap[x][y];
+                    if (listPipes.includes(newPixel.element)) {
+                        var nextStage;
+                        switch (pixel.stage) {
+ //                           case 2: nextStage = 4; break; //green
+//                            case 3: nextStage = 2; break; //red
+ //                           case 4: nextStage = 3; break; //blue
+                        }
+                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            moved = true;
+                            break;
+                        }
+                    }
+                    else if (!pixel.con  && !doNotEF.includes(newPixel.element) ) { //suck up pixel
+				// (!pixel.con && !(newPixel.element === "e_grinder") && pixel.charge > 0 && !(newPixel.element.movable))
+				// (!pixel.con && !(newPixel.element === "grinder") && !(newPixel.element === "e_grinder") && !(newPixel.element === "filter") && (newPixel.element.movable))	
+				//!(newPixel.element === "grinder") && !(newPixel.element === "e_grinder")
+                        pixel.con = newPixel;
+						breakPixel(pixel.con);
+                        deletePixel(newPixel.x,newPixel.y);
+                        pixel.con.x = pixel.x;
+                        pixel.con.y = pixel.y;
+                        pixel.con.del;
+                        moved = true;
+                        break;
+						
+                    }
+                }
+            }
+            if (pixel.con && !moved) { // move to same stage if none other
+                for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                    var coord = squareCoordsShuffle[i];
+                    var x = pixel.x+coord[0];
+                    var y = pixel.y+coord[1];
+                    if (isEmpty(x,y)) {
+                        delete pixel.con.del;
+                        pixel.con.x = x;
+                        pixel.con.y = y;
+                        pixelMap[x][y] = pixel.con;
+                        currentPixels.push(pixel.con);
+                        pixel.con = null;
+                        break;
+                    }
+                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                        var newPixel = pixelMap[x][y];
+                        if (pixel.con && !newPixel.con) {
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        doDefaults(pixel);
+    },
+    category: "machines",
+    movable: false,
+    canContain: true,
+	noMix: true,
+    insulate: true,
+}
+
+//elements.battery.movable: false
+
+elements.e_grinder = {
+    color: "#55565c",	
+	ignore: ["e_grinder","grinder"],
+    conduct: 1,
+    desc: "Grinds things,needs power to work",
+    tick: function(pixel) {
+		
+        if (1 === 2) {
+           for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+//                    createPixel("brick",x,y);
+//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
+                }
+            }
+ //           pixel.stage = 1;
+        }
+        else if (1 === 2) { //uninitialized
+            for (var i = 0; i < adjacentCoords.length; i++) {
+                var coord = adjacentCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (isEmpty(x,y)) {
+ //                   pixel.stage = 2; //blue
+ //                   pixel.color = pixelColorPick(pixel,"#000036");
+                    break;
+                }
+            }
+        }
+        else if (1 === 1) { //initialized
+            for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                    var newPixel = pixelMap[x][y];
+                    if (newPixel.stage === 1) {
+                        var newColor;
+                        switch (pixel.stage) {
+//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
+ //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
+//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
+                        }
+ //                       newPixel.color = pixelColorPick(newPixel,newColor);
+                    }
+                }
+            }
+            var moved = false;
+            shuffleArray(squareCoordsShuffle);
+            for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                var coord = squareCoordsShuffle[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+                    var newPixel = pixelMap[x][y];
+                    if (listPipes.includes(newPixel.element)) {
+                        var nextStage;
+                        switch (pixel.stage) {
+ //                           case 2: nextStage = 4; break; //green
+//                            case 3: nextStage = 2; break; //red
+ //                           case 4: nextStage = 3; break; //blue
+                        }
+                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            moved = true;
+                            break;
+                        }
+                    }
+                    else if (!pixel.con  && !doNotEF.includes(newPixel.element) && pixel.charge > 0 ) { //suck up pixel
+				
+						
+                        pixel.con = newPixel;
+						breakPixel(pixel.con);
+                        deletePixel(newPixel.x,newPixel.y);
+                        pixel.con.x = pixel.x;
+                        pixel.con.y = pixel.y;
+                        pixel.con.del;
+                        moved = true;
+                        break;
+						
+                    }
+                }
+            }
+            if (pixel.con && !moved) { // move to same stage if none other
+                for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                    var coord = squareCoordsShuffle[i];
+                    var x = pixel.x+coord[0];
+                    var y = pixel.y+coord[1];
+                    if (isEmpty(x,y)) {
+                        delete pixel.con.del;
+                        pixel.con.x = x;
+                        pixel.con.y = y;
+                        pixelMap[x][y] = pixel.con;
+                        currentPixels.push(pixel.con);
+                        pixel.con = null;
+                        break;
+                    }
+                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                        var newPixel = pixelMap[x][y];
+                        if (pixel.con && !newPixel.con) {
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        doDefaults(pixel);
+    },
+    category: "machines",
+    movable: false,
+    canContain: true,
+	noMix: true,
+    insulate: true,
+}
+
+
+
+// elements.cementMix = {
+	
+// }

From d9f15d5469b05c1ce1222072cf06f8a6f05121a7 Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Sun, 17 Mar 2024 15:05:22 -0500
Subject: [PATCH 12/19] Delete sandboxels-screenshot (1).png

---
 sandboxels-screenshot (1).png | Bin 17105 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 sandboxels-screenshot (1).png

diff --git a/sandboxels-screenshot (1).png b/sandboxels-screenshot (1).png
deleted file mode 100644
index 1dc044631119e1a997fb4783c9e871f3ae1f3e33..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 17105
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
G@qYj|EPpis


From 0a657031842350367181dd84f58212c5ae9d0479 Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Sun, 17 Mar 2024 15:10:45 -0500
Subject: [PATCH 13/19] Update ExtraMachines.js


From 4b639b1b8f86e7f8d3ef3e7eb5f799c950382550 Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Sun, 17 Mar 2024 15:12:25 -0500
Subject: [PATCH 14/19] Add files via upload

---
 mods/ExtraMachines.js | 1232 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1232 insertions(+)
 create mode 100644 mods/ExtraMachines.js

diff --git a/mods/ExtraMachines.js b/mods/ExtraMachines.js
new file mode 100644
index 00000000..538028b9
--- /dev/null
+++ b/mods/ExtraMachines.js
@@ -0,0 +1,1232 @@
+// this is a epic mod
+
+let heatSen = 0;
+elements.heatSensor = {
+    
+	color: "#ff0000",
+    conduct: 1,
+    category:"test",
+	behavior: behaviors.WALL,
+	
+	onSelect: function(pixel){
+    setTemp = parseInt(prompt("Enter the temperature you want it to sense. zero will not work", (heatSen || undefined)));
+	        
+  },
+  
+	
+	tick: function(pixel) {
+        if((pixel.start == pixelTicks) && !(heatSen == 0)){
+            pixel.clone.temp = heatSen
+          }
+	
+	 if (pixel.temp > pixel.clone ) {
+              pixel.charge = 1;
+        }
+
+		
+  },
+        
+};
+
+let itemA = "steam";
+elements.SteamTurbine = {
+  behavior: behaviors.WALL,
+    desc: "When steam touches it, it conducts electricity and the steam pixel is deleted",
+      color: "#826c6e",
+          tick: function(pixel) {
+        if(pixel.start == pixelTicks){
+          pixel.clone = itemA;
+        }
+
+          for (var i = 0; i < adjacentCoords.length; i++) {
+              var coords = adjacentCoords[i];
+              var x = pixel.x + coords[0];
+              var y = pixel.y + coords[1];
+              if (!isEmpty(x,y,true)) {
+                  var sensed = pixelMap[x][y];
+                  if (sensed.element == pixel.clone) {
+					  deletePixel(x,y);
+                      pixel.charge = 5;
+                      break;
+                  }
+              }
+          }
+          doDefaults(pixel);
+      },
+      conduct: 1,
+      movable: false,
+      category:"machines",
+      darkText: true,
+  hardness: 1,
+
+  };
+
+
+elements.coal  = {
+    desc: "A black powder that burns",
+	color: "#3d3c39",
+	behavior: behaviors.POWDER,
+	category: "energy",
+	state: "solid",
+	density: 208,
+    conduct: 0.001,
+	
+	tick: function(pixel) {
+        if (pixel.temp > 900 && !pixel.burning) {
+            pixel.burning = true;
+            pixel.burnStart = pixelTicks;
+        }
+    },
+	
+	tempHigh:2500,
+    stateHigh: "fire",
+    hardness: 0.85,
+    burn: 100,
+    burnTime: 3500,
+};
+
+
+ elements.coal_dust = {
+    desc: "A byproduct of smashed solid coal that burns like coal but for a shorter time",
+	color: "#3d3c39",
+	behavior: behaviors.POWDER,
+	category: "powders",
+	state: "solid",
+	stain: 1,
+	density: 190,
+    conduct: 0.001,
+	
+	tick: function(pixel) {
+        if (pixel.temp > 900 && !pixel.burning) {
+            pixel.burning = true;
+            pixel.burnStart = pixelTicks;
+        }
+    },
+	
+	tempHigh:2000,
+    stateHigh: "fire",
+    hardness: 0.3,
+    burn: 100,
+    burnTime: 3500,
+};
+
+
+elements.gasoline = {
+    color: "#c9c5b1",
+    desc: "A liquid that burns and is used to power most cars",
+    behavior: behaviors.LIQUID,
+    tick: function(pixel) {
+        if (pixel.temp > 430 && !pixel.burning) {
+            pixel.burning = true;
+            pixel.burnStart = pixelTicks;
+        }
+    },
+	tempHigh:3000,
+    stateHigh: "fire",
+    viscosity: 0.56,
+    burn: 100,
+    burnTime: 10000,
+    fireColor: "#c9c5b1",
+    category: "liquids",
+    state: "liquid",
+    density: 792,
+    stain: -0.25,
+}
+
+let itemB = "light";
+elements.solar_panel = {
+  behavior: behaviors.WALL,
+  desc: "When light touches it, it conducts electricity and the light pixel is deleted",
+      color: "#bebfa3",
+          tick: function(pixel) {
+        if(pixel.start == pixelTicks){
+          pixel.clone = itemB;
+        }
+
+          for (var i = 0; i < adjacentCoords.length; i++) {
+              var coords = adjacentCoords[i];
+              var x = pixel.x + coords[0];
+              var y = pixel.y + coords[1];
+              if (!isEmpty(x,y,true)) {
+                  var sensed = pixelMap[x][y];
+                  if (sensed.element == pixel.clone) {
+					  deletePixel(x,y);
+                      pixel.charge = 5;
+                      break;
+                  }
+              }
+          }
+          doDefaults(pixel);
+      },
+      conduct: 1,
+      movable: false,
+      category:"machines",
+      darkText: true,
+  hardness: 1,
+
+  };
+
+elements.titanium = {
+    desc: "Another metal that does not erode nor conduct electricity",
+	conduct: 0,
+	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
+	tempHigh:3000,
+    stateHigh: "molten_titanium",
+    category: "solids",
+    state: "soild",
+	 hardness: 1,
+    density: 792,
+	behavior: behaviors.WALL,
+};
+
+elements.molten_titanium = {
+    desc: "Melted version of titanium",
+    temp : 3000,
+	conduct: 0,
+	color: "#d16e04",
+	tempLow:2999,
+    stateLow: "titanium",
+    category: "states",
+    state: "soild",
+    density: 792,
+	behavior: behaviors.MOLTEN,
+};
+
+elements.solid_coal = {
+    desc: "A solid version of coal",
+	color: "#3d3c39",
+	behavior: behaviors.WALL,
+	category: "energy",
+	state: "solid",
+	breakInto: "coal_dust",
+	density: 380,
+    conduct: 0.001,
+	
+	tick: function(pixel) {
+        if (pixel.temp > 900 && !pixel.burning) {
+            pixel.burning = true;
+            pixel.burnStart = pixelTicks;
+        }
+    },
+	
+	tempHigh:3000,
+    stateHigh: "fire",
+    hardness: 0.85,
+    burn: 100,
+    burnTime: 3500,
+};
+
+elements.rubber = {
+    desc: "Not finnished",
+	color: "#ffc0cb",
+	 hardness: 0.5,
+	 tempHigh:180,
+	 state: "solid",
+	 behavior: behaviors.WALL,
+	 conduct: 0,
+	 category: "solids",
+};
+
+elements.coolant = {
+    desc: "Cools down pixels that touch it and is a liquid",
+	color: "#71ded3",
+	 state: "liquid",
+     insulate: true,
+	  behavior: behaviors.LIQUID,
+      tick: function(pixel) {
+       
+
+          for (var i = 0; i < adjacentCoords.length; i++) {
+              var coords = adjacentCoords[i];
+              var x = pixel.x + coords[0];
+              var y = pixel.y + coords[1];
+              if (!isEmpty(x,y,true)) {
+                  var sensed = pixelMap[x][y];
+                  if (sensed.element && sensed.temp > 21 ) {
+					 
+                     sensed.temp -= 1;
+                      break;
+                  }
+              }
+          }
+          doDefaults(pixel);
+      },
+	 conduct: 0.5,
+	 category: "test",
+	 
+};
+
+elements.e_cooler = {
+    desc: "Works like the cooler but needs power to work",
+	color: elements.cooler.color,
+	 hardness: 0.5,
+	 state: "solid",
+	 behavior: behaviors.WALL,
+	 conduct: 1,
+	 category: "machines",
+	 behaviorOn: [
+        "XX|CO:2|XX",
+        "CO:2|XX|CO:2",
+        "XX|CO:2|XX",
+    ],
+	name: "E-Cooler",
+};
+
+elements.e_Freezer = {
+    desc: "Works like the freezer but needs power to work",
+	color: elements.cooler.color,
+	 hardness: 0.5,
+	 state: "solid",
+	 behavior: behaviors.WALL,
+	 conduct: 1,
+	 category: "machines",
+	 behaviorOn: [
+        "XX|CO:10|XX",
+        "CO:10|XX|CO:10",
+        "XX|CO:10|XX",
+    ],
+	name: "E-Freezer",
+};
+
+elements.e_heater = {
+    desc: "Works like the heater but needs power to work",
+	 hardness: 0.5,
+	 state: "solid",
+	 behavior: behaviors.WALL,
+	 conduct: 1,
+	 category: "machines",
+	  color: "#881111",
+    behaviorOn: [
+        "XX|HT:4|XX",
+        "HT:4|XX|HT:4",
+        "XX|HT:4|XX",
+    ],
+	name: "E-Heater",
+};
+
+elements.e_SuperHeater = {
+    desc: "Works like the Super Heater but needs power to work",
+	 hardness: 0.5,
+	 state: "solid",
+	 behavior: behaviors.WALL,
+	 conduct: 1,
+	 category: "machines",
+	  color: "#881111",
+    behaviorOn: [
+        "XX|HT:12|XX",
+        "HT:12|XX|HT:12",
+        "XX|HT:12|XX",
+    ],
+	name: "E-SuperHeater",
+};
+
+elements.slow_Ecloner = {
+    desc: "Works like the Slow Cloner but needs power to work",
+	 color: "#888800",
+	 behavior: behaviors.WALL,
+    behaviorOn: [
+        "XX|CF%10|XX",
+        "CF%10|XX|CF%10",
+        "XX|CF%10|XX",
+    ],
+    ignore: ["cloner","ecloner","clone_powder","floating_cloner","wall","ewall","SteamTurbine","solar_panel"],
+    category:"machines",
+    insulate:true,
+    hardness: 1,
+	conduct: 1,
+	name: "E-SlowCloner",
+};
+
+elements.Android = {
+    desc: "A robot",
+	color: "#a1ada5",
+    category: "life",
+	color: ["#f3e7db","#f7ead0","#eadaba","#d7bd96","#a07e56","#825c43","#604134","#3a312a"],
+    category: "life",
+    properties: {
+        dead: false,
+        dir: 1,
+        panic: 0
+    },
+    tick: function(pixel) {
+        if (isEmpty(pixel.x, pixel.y+1)) {
+            createPixel("AndroidBody", pixel.x, pixel.y+1);
+            pixel.element = "AndroidHead";
+        }
+        else if (isEmpty(pixel.x, pixel.y-1)) {
+            createPixel("AndroidHead", pixel.x, pixel.y-1);
+            pixelMap[pixel.x][pixel.y-1].color = pixel.color;
+            pixel.element = "AndroidBody";
+            pixel.color = pixelColorPick(pixel)
+        }
+        else {
+            deletePixel(pixel.x, pixel.y);
+        }
+    },
+    related: ["AndroidBody","AndroidHead"],
+    cooldown: defaultCooldown
+};
+
+
+elements.AndroidBody = {
+	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
+    category: "life",
+	 breakInto: ["oil","metal_scrap","explosion"],
+	 properties: {
+        dead: false,
+        dir: 1,
+        panic: 0
+    },
+    tick: function(pixel) {
+        if (tryMove(pixel, pixel.x, pixel.y+1)) { // Fall
+            if (!isEmpty(pixel.x, pixel.y-2, true)) { // Drag head down
+                var headpixel = pixelMap[pixel.x][pixel.y-2];
+                if (headpixel.element == "AndroidHead") {
+                    if (isEmpty(pixel.x, pixel.y-1)) {
+                        movePixel(pixelMap[pixel.x][pixel.y-2], pixel.x, pixel.y-1);
+                    }
+                    else {
+                        swapPixels(pixelMap[pixel.x][pixel.y-2], pixelMap[pixel.x][pixel.y-1]);
+                    }
+                }
+            }
+        }
+        doHeat(pixel);
+        doBurning(pixel);
+        doElectricity(pixel);
+        if (pixel.dead) {
+            // Turn into rotten_meat if pixelTicks-dead > 500
+            if (pixelTicks-pixel.dead > 200 && Math.random() < 0.1) {
+                changePixel(pixel,"rotten_meat");
+            }
+            return
+        }
+
+        // Find the head
+        if (!isEmpty(pixel.x, pixel.y-1, true) && pixelMap[pixel.x][pixel.y-1].element == "AndroidHead") {
+            var head = pixelMap[pixel.x][pixel.y-1];
+            if (head.dead) { // If head is dead, kill body
+                pixel.dead = head.dead;
+            }
+        }
+        else { var head = null }
+        if (pixel.burning) {
+            pixel.panic += 0.1;
+            if (head && pixelTicks-pixel.burnStart > 240) {
+                pixel.color = head.color;
+            }
+        }
+        else if (pixel.panic > 0) {
+            pixel.panic -= 0.1;
+        }
+
+        if (isEmpty(pixel.x, pixel.y-1)) {
+            // create blood if decapitated 10% chance
+            if (Math.random() < 0.1 && !pixel.charge) {
+                createPixel("oil", pixel.x, pixel.y-1);
+                // set dead to true 15% chance
+                if (Math.random() < 0.15) {
+                    pixel.dead = pixelTicks;
+                }
+            }
+        }
+        else if (head == null) { return }
+        else if (Math.random() < 0.1*(isEmpty(pixel.x, pixel.y+1) ? 1 : pixel.panic+1)) { // Move 10% chance
+            var movesToTry = [
+                [1*pixel.dir,0],
+                [1*pixel.dir,-1],
+            ];
+            // While movesToTry is not empty, tryMove(pixel, x, y) with a random move, then remove it. if tryMove returns true, break.
+            while (movesToTry.length > 0) {
+                var move = movesToTry.splice(Math.floor(Math.random() * movesToTry.length), 1)[0];
+                if (isEmpty(pixel.x+move[0], pixel.y+move[1]-1)) {
+                    var origx = pixel.x+move[0];
+                    var origy = pixel.y+move[1];
+                    if (tryMove(pixel, pixel.x+move[0], pixel.y+move[1]) && pixel.x===origx && pixel.y===origy) {
+                        movePixel(head, head.x+move[0], head.y+move[1]);
+                        break;
+                    }
+                }
+            }
+            // 15% chance to change direction
+            if (Math.random() < 0.15) {
+                pixel.dir *= -1;
+            }
+            // homeostasis
+            if (pixel.temp > 37) { pixel.temp -= 1; }
+            else if (pixel.temp < 37) { pixel.temp += 1; }
+        }
+
+    }
+};
+
+elements.AndroidHead = {
+	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
+    category: "life",
+	density: 1080,
+    state: "solid",
+    conduct: .05,
+    temp: 69,
+    breakInto: ["oil","metal_scrap","explosion"],
+};
+
+listPipes = "pipe"
+
+
+//thx to morechem.js for the idea
+
+let setTemp = "";
+elements.ajustableHeater = {
+    desc: "Works like a heater but it can be set to a specific temp and needs power to work",
+	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
+    category: "machines",
+	density: 1080,
+    state: "solid",
+    conduct: 1,
+	movable: false,
+	name: "Ajustable-E-Heater",
+	 onSelect: function(pixel){
+    setTemp = parseInt(prompt("Enter the temperature you want it set to.", (setTemp || undefined)));
+	        
+  },
+	tick: function(pixel) {
+        for (var i = 0; i < adjacentCoords.length; i++) {
+            var coords = adjacentCoords[i];
+            var x = pixel.x + coords[0];
+            var y = pixel.y + coords[1];
+            if (!isEmpty(x,y,true)) {
+                var sensed = pixelMap[x][y];
+                if (sensed.con || elements[sensed.element].movable && pixel.charge > 0) {
+                    sensed.temp += setTemp/6;
+					
+                    break;
+                }
+            }
+        }
+        doDefaults(pixel);
+    },
+	 insulate:true
+};
+
+//old grinder
+// elements.grinder = {
+	// color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
+    // category: "machines",
+	// density: 1080,
+    // state: "solid",
+    // conduct: 1,
+	// movable: false,
+	
+	// ignore: "grinder",
+	
+		// tick: function(pixel) {
+        // for (var i = 0; i < adjacentCoords.length; i++) {
+            // var coords = adjacentCoords[i];
+            // var x = pixel.x + coords[0];
+            // var y = pixel.y + coords[1];
+            // if (!isEmpty(x,y,true)) {
+                // var sensed = pixelMap[x][y];
+                // if (sensed.con || elements[sensed.element].movable && pixel.charge > 0) {
+                    // breakPixel(sensed);
+                // }
+            // }
+        // }
+        // doDefaults(pixel);
+    // },
+	 // insulate:true
+     
+	
+	
+// };
+
+
+
+elements.dead_plant.conduct = 1;
+// let compact = "dead_plant";
+// elements.compacter = {
+	// behavior: behaviors.WALL,
+      // color: "#bebfa3",
+          // tick: function(pixel) {
+        // if(pixel.start == pixelTicks){
+          // pixel.clone = compact;
+        // }
+		
+
+          // for (var i = 0; i < adjacentCoords.length; i++) {
+              // var coords = adjacentCoords[i];
+              // var x = pixel.x + coords[0];
+              // var y = pixel.y + coords[1];
+              // if (!isEmpty(x,y,true)) {
+                  // var sensed = pixelMap[x][y];
+                  // if (sensed.element == pixel.clone && pixel.charge > 0) {
+					 // sensed.element = "coal"
+					 // sensed.color = elements.coal.color
+                      // break;
+                  // }
+              // }
+          // }
+          // doDefaults(pixel);
+      // },
+      // conduct: 1,
+      // movable: false,
+      // category:"machines",
+      // darkText: true,
+  // hardness: 1,
+// }
+compactPi = "dead_plant";
+compactPi2 = "coal";
+elements.compacter = {
+    color: "#4e524f",
+    desc: "Turns dead plants into coal and needs power",
+    tick: function(pixel) {
+		if (pixel.start === pixelTicks) {
+			pixel.CompactEl = compactPi
+			pixel.CompactEl2 = compactPi2
+		}
+        if (1 === 2) {
+           for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+//                    createPixel("brick",x,y);
+//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
+                }
+            }
+ //           pixel.stage = 1;
+        }
+        else if (1 === 2) { //uninitialized
+            for (var i = 0; i < adjacentCoords.length; i++) {
+                var coord = adjacentCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (isEmpty(x,y)) {
+ //                   pixel.stage = 2; //blue
+ //                   pixel.color = pixelColorPick(pixel,"#000036");
+                    break;
+                }
+            }
+        }
+        else if (1 === 1) { //initialized
+            for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                    var newPixel = pixelMap[x][y];
+                    if (newPixel.stage === 1) {
+                        var newColor;
+                        switch (pixel.stage) {
+//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
+ //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
+//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
+                        }
+ //                       newPixel.color = pixelColorPick(newPixel,newColor);
+                    }
+                }
+            }
+            var moved = false;
+            shuffleArray(squareCoordsShuffle);
+            for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                var coord = squareCoordsShuffle[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+                    var newPixel = pixelMap[x][y];
+                    if (listPipes.includes(newPixel.element)) {
+                        var nextStage;
+                        switch (pixel.stage) {
+ //                           case 2: nextStage = 4; break; //green
+//                            case 3: nextStage = 2; break; //red
+ //                           case 4: nextStage = 3; break; //blue
+                        }
+                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            moved = true;
+                            break;
+                        }
+                    }
+                    else if (!pixel.con ) { //suck up pixel
+					if  ((newPixel.element == pixel.CompactEl) || (newPixel.element == pixel.CompactEl2) && pixel.charge > 0  ) {
+						
+                        pixel.con = newPixel;
+						changePixel(newPixel, "coal")
+						newPixel.color = elements.coal.color
+                        deletePixel(newPixel.x,newPixel.y);
+                        pixel.con.x = pixel.x;
+                        pixel.con.y = pixel.y;
+                        pixel.con.del;
+                        moved = true;
+                        break;
+						}
+                    }
+                }
+            }
+            if (pixel.con && !moved) { // move to same stage if none other
+                for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                    var coord = squareCoordsShuffle[i];
+                    var x = pixel.x+coord[0];
+                    var y = pixel.y+coord[1];
+                    if (isEmpty(x,y)) {
+                        delete pixel.con.del;
+                        pixel.con.x = x;
+                        pixel.con.y = y;
+                        pixelMap[x][y] = pixel.con;
+                        currentPixels.push(pixel.con);
+                        pixel.con = null;
+                        break;
+                    }
+                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                        var newPixel = pixelMap[x][y];
+                        if (pixel.con && !newPixel.con) {
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        doDefaults(pixel);
+    },
+    category: "machines",
+    movable: false,
+    canContain: true,
+	noMix: true,
+    insulate: true,
+}
+
+// thx to nousersthings mod for the filter
+// only adding this bc my freind told me so 
+// im not good at javascript and coding so yeah
+
+filterTypeVar = 0;
+elements.filter = {
+    color: "#599fc2",
+    desc: "A filter made by nouser",
+    onSelect: function() {
+        var answer4 = prompt("Please input the desired element of this filter. It is case senstive.",(filterTypeVar||undefined));
+        if (!answer4) { return }
+		filterTypeVar = answer4;
+    },
+    tick: function(pixel) {
+		if (pixel.start === pixelTicks) {
+			pixel.filterType = filterTypeVar
+		}
+        if (1 === 2) {
+           for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+//                    createPixel("brick",x,y);
+//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
+                }
+            }
+ //           pixel.stage = 1;
+        }
+        else if (1 === 2) { //uninitialized
+            for (var i = 0; i < adjacentCoords.length; i++) {
+                var coord = adjacentCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (isEmpty(x,y)) {
+ //                   pixel.stage = 2; //blue
+ //                   pixel.color = pixelColorPick(pixel,"#000036");
+                    break;
+                }
+            }
+        }
+        else if (1 === 1) { //initialized
+            for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                    var newPixel = pixelMap[x][y];
+                    if (newPixel.stage === 1) {
+                        var newColor;
+                        switch (pixel.stage) {
+//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
+ //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
+//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
+                        }
+ //                       newPixel.color = pixelColorPick(newPixel,newColor);
+                    }
+                }
+            }
+            var moved = false;
+            shuffleArray(squareCoordsShuffle);
+            for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                var coord = squareCoordsShuffle[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+                    var newPixel = pixelMap[x][y];
+                    if (listPipes.includes(newPixel.element)) {
+                        var nextStage;
+                        switch (pixel.stage) {
+ //                           case 2: nextStage = 4; break; //green
+//                            case 3: nextStage = 2; break; //red
+ //                           case 4: nextStage = 3; break; //blue
+                        }
+                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            moved = true;
+                            break;
+                        }
+                    }
+                    else if (!pixel.con ) { //suck up pixel
+					if  (newPixel.element == pixel.filterType ) {
+						
+                        pixel.con = newPixel;
+		
+                        deletePixel(newPixel.x,newPixel.y);
+                        pixel.con.x = pixel.x;
+                        pixel.con.y = pixel.y;
+                        pixel.con.del;
+                        moved = true;
+                        break;
+						}
+                    }
+                }
+            }
+            if (pixel.con && !moved) { // move to same stage if none other
+                for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                    var coord = squareCoordsShuffle[i];
+                    var x = pixel.x+coord[0];
+                    var y = pixel.y+coord[1];
+                    if (isEmpty(x,y)) {
+                        delete pixel.con.del;
+                        pixel.con.x = x;
+                        pixel.con.y = y;
+                        pixelMap[x][y] = pixel.con;
+                        currentPixels.push(pixel.con);
+                        pixel.con = null;
+                        break;
+                    }
+                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                        var newPixel = pixelMap[x][y];
+                        if (pixel.con && !newPixel.con) {
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        doDefaults(pixel);
+    },
+    category: "machines",
+    movable: false,
+    canContain: true,
+	noMix: true,
+    insulate: true,
+}
+
+filterTypeVar2 = 0;
+elements.Destructive_Filter = {
+    color: "#3c6c85",
+    desc: "A filter that destroys anything that isn't allowed to get through",
+    onSelect: function() {
+        var answer4 = prompt("Please input the desired element of this filter. It is case senstive.",(filterTypeVar||undefined));
+        if (!answer4) { return }
+		filterTypeVar2 = answer4;
+    },
+    tick: function(pixel) {
+		if (pixel.start === pixelTicks) {
+			pixel.filterType = filterTypeVar2
+		}
+        if (1 === 2) {
+           for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+//                    createPixel("brick",x,y);
+//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
+                }
+            }
+ //           pixel.stage = 1;
+        }
+        else if (1 === 2) { //uninitialized
+            for (var i = 0; i < adjacentCoords.length; i++) {
+                var coord = adjacentCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (isEmpty(x,y)) {
+ //                   pixel.stage = 2; //blue
+ //                   pixel.color = pixelColorPick(pixel,"#000036");
+                    break;
+                }
+            }
+        }
+        else if (1 === 1) { //initialized
+            for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                    var newPixel = pixelMap[x][y];
+                    if (newPixel.stage === 1) {
+                        var newColor;
+                        switch (pixel.stage) {
+//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
+ //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
+//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
+                        }
+ //                       newPixel.color = pixelColorPick(newPixel,newColor);
+                    }
+                }
+            }
+            var moved = false;
+            shuffleArray(squareCoordsShuffle);
+            for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                var coord = squareCoordsShuffle[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+                    var newPixel = pixelMap[x][y];
+                    if (listPipes.includes(newPixel.element)) {
+                        var nextStage;
+                        switch (pixel.stage) {
+ //                           case 2: nextStage = 4; break; //green
+//                            case 3: nextStage = 2; break; //red
+ //                           case 4: nextStage = 3; break; //blue
+                        }
+                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            moved = true;
+                            break;
+                        }
+                    }
+                    else if (!pixel.con ) { //suck up pixel
+					if  (newPixel.element == pixel.filterType) {
+						
+                        pixel.con = newPixel;
+		
+                        deletePixel(newPixel.x,newPixel.y);
+                        pixel.con.x = pixel.x;
+                        pixel.con.y = pixel.y;
+                        pixel.con.del;
+                        moved = true;
+                        break;
+						}
+						else if(!(newPixel.element == "filter") && !(newPixel.element == "Destructive_Filter") && !doNotEF.includes(newPixel.element) ) {
+							deletePixel(newPixel.x, newPixel.y);
+							break;
+							
+						}
+                    }
+                }
+            }
+            if (pixel.con && !moved) { // move to same stage if none other
+                for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                    var coord = squareCoordsShuffle[i];
+                    var x = pixel.x+coord[0];
+                    var y = pixel.y+coord[1];
+                    if (isEmpty(x,y)) {
+                        delete pixel.con.del;
+                        pixel.con.x = x;
+                        pixel.con.y = y;
+                        pixelMap[x][y] = pixel.con;
+                        currentPixels.push(pixel.con);
+                        pixel.con = null;
+                        break;
+                    }
+                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                        var newPixel = pixelMap[x][y];
+                        if (pixel.con && !newPixel.con) {
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        doDefaults(pixel);
+    },
+    category: "machines",
+    movable: false,
+    canContain: true,
+	noMix: true,
+    insulate: true,
+}
+
+
+
+// going to fix the sucking up solids problem soon!!
+doNotEF = ["e_grinder","grinder","filter", "battery", "wire", "cloner", "sensor", "heater","cooler", "Ajustable-E-Heater", "E-Cooler", "E-Freezer", "E-Heater", "E-SuperHeater", "E-SlowCloner", "ewall", "titanium", "tungsten", "steel", "insulation","SteamTurbine","solar_panel"];
+
+elements.grinder = {
+    color: "#55565c",
+	ignore: ["e_grinder","grinder"],
+    desc: "Grinds things",
+    tick: function(pixel) {
+		
+        if (1 === 2) {
+           for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+//                    createPixel("brick",x,y);
+//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
+                }
+            }
+ //           pixel.stage = 1;
+        }
+        else if (1 === 2) { //uninitialized
+            for (var i = 0; i < adjacentCoords.length; i++) {
+                var coord = adjacentCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (isEmpty(x,y)) {
+ //                   pixel.stage = 2; //blue
+ //                   pixel.color = pixelColorPick(pixel,"#000036");
+                    break;
+                }
+            }
+        }
+        else if (1 === 1) { //initialized
+            for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                    var newPixel = pixelMap[x][y];
+                    if (newPixel.stage === 1) {
+                        var newColor;
+                        switch (pixel.stage) {
+//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
+ //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
+//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
+                        }
+ //                       newPixel.color = pixelColorPick(newPixel,newColor);
+                    }
+                }
+            }
+            var moved = false;
+            shuffleArray(squareCoordsShuffle);
+            for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                var coord = squareCoordsShuffle[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+                    var newPixel = pixelMap[x][y];
+                    if (listPipes.includes(newPixel.element)) {
+                        var nextStage;
+                        switch (pixel.stage) {
+ //                           case 2: nextStage = 4; break; //green
+//                            case 3: nextStage = 2; break; //red
+ //                           case 4: nextStage = 3; break; //blue
+                        }
+                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            moved = true;
+                            break;
+                        }
+                    }
+                    else if (!pixel.con  && !doNotEF.includes(newPixel.element) ) { //suck up pixel
+				// (!pixel.con && !(newPixel.element === "e_grinder") && pixel.charge > 0 && !(newPixel.element.movable))
+				// (!pixel.con && !(newPixel.element === "grinder") && !(newPixel.element === "e_grinder") && !(newPixel.element === "filter") && (newPixel.element.movable))	
+				//!(newPixel.element === "grinder") && !(newPixel.element === "e_grinder")
+                        pixel.con = newPixel;
+						breakPixel(pixel.con);
+                        deletePixel(newPixel.x,newPixel.y);
+                        pixel.con.x = pixel.x;
+                        pixel.con.y = pixel.y;
+                        pixel.con.del;
+                        moved = true;
+                        break;
+						
+                    }
+                }
+            }
+            if (pixel.con && !moved) { // move to same stage if none other
+                for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                    var coord = squareCoordsShuffle[i];
+                    var x = pixel.x+coord[0];
+                    var y = pixel.y+coord[1];
+                    if (isEmpty(x,y)) {
+                        delete pixel.con.del;
+                        pixel.con.x = x;
+                        pixel.con.y = y;
+                        pixelMap[x][y] = pixel.con;
+                        currentPixels.push(pixel.con);
+                        pixel.con = null;
+                        break;
+                    }
+                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                        var newPixel = pixelMap[x][y];
+                        if (pixel.con && !newPixel.con) {
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        doDefaults(pixel);
+    },
+    category: "machines",
+    movable: false,
+    canContain: true,
+	noMix: true,
+    insulate: true,
+}
+
+//elements.battery.movable: false
+
+elements.e_grinder = {
+    color: "#55565c",	
+	ignore: ["e_grinder","grinder"],
+    conduct: 1,
+    desc: "Grinds things,needs power to work",
+    tick: function(pixel) {
+		
+        if (1 === 2) {
+           for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+//                    createPixel("brick",x,y);
+//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
+                }
+            }
+ //           pixel.stage = 1;
+        }
+        else if (1 === 2) { //uninitialized
+            for (var i = 0; i < adjacentCoords.length; i++) {
+                var coord = adjacentCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (isEmpty(x,y)) {
+ //                   pixel.stage = 2; //blue
+ //                   pixel.color = pixelColorPick(pixel,"#000036");
+                    break;
+                }
+            }
+        }
+        else if (1 === 1) { //initialized
+            for (var i = 0; i < squareCoords.length; i++) {
+                var coord = squareCoords[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                    var newPixel = pixelMap[x][y];
+                    if (newPixel.stage === 1) {
+                        var newColor;
+                        switch (pixel.stage) {
+//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
+ //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
+//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
+                        }
+ //                       newPixel.color = pixelColorPick(newPixel,newColor);
+                    }
+                }
+            }
+            var moved = false;
+            shuffleArray(squareCoordsShuffle);
+            for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                var coord = squareCoordsShuffle[i];
+                var x = pixel.x+coord[0];
+                var y = pixel.y+coord[1];
+                if (!isEmpty(x,y,true)) {
+                    var newPixel = pixelMap[x][y];
+                    if (listPipes.includes(newPixel.element)) {
+                        var nextStage;
+                        switch (pixel.stage) {
+ //                           case 2: nextStage = 4; break; //green
+//                            case 3: nextStage = 2; break; //red
+ //                           case 4: nextStage = 3; break; //blue
+                        }
+                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            moved = true;
+                            break;
+                        }
+                    }
+                    else if (!pixel.con  && !doNotEF.includes(newPixel.element) && pixel.charge > 0 ) { //suck up pixel
+				
+						
+                        pixel.con = newPixel;
+						breakPixel(pixel.con);
+                        deletePixel(newPixel.x,newPixel.y);
+                        pixel.con.x = pixel.x;
+                        pixel.con.y = pixel.y;
+                        pixel.con.del;
+                        moved = true;
+                        break;
+						
+                    }
+                }
+            }
+            if (pixel.con && !moved) { // move to same stage if none other
+                for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                    var coord = squareCoordsShuffle[i];
+                    var x = pixel.x+coord[0];
+                    var y = pixel.y+coord[1];
+                    if (isEmpty(x,y)) {
+                        delete pixel.con.del;
+                        pixel.con.x = x;
+                        pixel.con.y = y;
+                        pixelMap[x][y] = pixel.con;
+                        currentPixels.push(pixel.con);
+                        pixel.con = null;
+                        break;
+                    }
+                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
+                        var newPixel = pixelMap[x][y];
+                        if (pixel.con && !newPixel.con) {
+                            newPixel.con = pixel.con;
+                            newPixel.con.x = newPixel.x;
+                            newPixel.con.y = newPixel.y;
+                            pixel.con = null;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        doDefaults(pixel);
+    },
+    category: "machines",
+    movable: false,
+    canContain: true,
+	noMix: true,
+    insulate: true,
+}
+
+
+
+// elements.cementMix = {
+	
+// }
\ No newline at end of file

From e249837812d4f5e76ed1129667886547e584b570 Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Sun, 17 Mar 2024 15:12:43 -0500
Subject: [PATCH 15/19] Delete ExtraMachines.js

---
 ExtraMachines.js | 1232 ----------------------------------------------
 1 file changed, 1232 deletions(-)
 delete mode 100644 ExtraMachines.js

diff --git a/ExtraMachines.js b/ExtraMachines.js
deleted file mode 100644
index 20137987..00000000
--- a/ExtraMachines.js
+++ /dev/null
@@ -1,1232 +0,0 @@
-// this is a epic mod
-
-let heatSen = 0;
-elements.heatSensor = {
-    
-	color: "#ff0000",
-    conduct: 1,
-    category:"test",
-	behavior: behaviors.WALL,
-	
-	onSelect: function(pixel){
-    setTemp = parseInt(prompt("Enter the temperature you want it to sense. zero will not work", (heatSen || undefined)));
-	        
-  },
-  
-	
-	tick: function(pixel) {
-        if((pixel.start == pixelTicks) && !(heatSen == 0)){
-            pixel.clone.temp = heatSen
-          }
-	
-	 if (pixel.temp > pixel.clone ) {
-              pixel.charge = 1;
-        }
-
-		
-  },
-        
-};
-
-let itemA = "steam";
-elements.SteamTurbine = {
-  behavior: behaviors.WALL,
-    desc: "When steam touches it, it conducts electricity and the steam pixel is deleted",
-      color: "#826c6e",
-          tick: function(pixel) {
-        if(pixel.start == pixelTicks){
-          pixel.clone = itemA;
-        }
-
-          for (var i = 0; i < adjacentCoords.length; i++) {
-              var coords = adjacentCoords[i];
-              var x = pixel.x + coords[0];
-              var y = pixel.y + coords[1];
-              if (!isEmpty(x,y,true)) {
-                  var sensed = pixelMap[x][y];
-                  if (sensed.element == pixel.clone) {
-					  deletePixel(x,y);
-                      pixel.charge = 5;
-                      break;
-                  }
-              }
-          }
-          doDefaults(pixel);
-      },
-      conduct: 1,
-      movable: false,
-      category:"machines",
-      darkText: true,
-  hardness: 1,
-
-  };
-
-
-elements.coal  = {
-    desc: "A black powder that burns",
-	color: "#3d3c39",
-	behavior: behaviors.POWDER,
-	category: "energy",
-	state: "solid",
-	density: 208,
-    conduct: 0.001,
-	
-	tick: function(pixel) {
-        if (pixel.temp > 900 && !pixel.burning) {
-            pixel.burning = true;
-            pixel.burnStart = pixelTicks;
-        }
-    },
-	
-	tempHigh:2500,
-    stateHigh: "fire",
-    hardness: 0.85,
-    burn: 100,
-    burnTime: 3500,
-};
-
-
- elements.coal_dust = {
-    desc: "A byproduct of smashed solid coal that burns like coal but for a shorter time",
-	color: "#3d3c39",
-	behavior: behaviors.POWDER,
-	category: "powders",
-	state: "solid",
-	stain: 1,
-	density: 190,
-    conduct: 0.001,
-	
-	tick: function(pixel) {
-        if (pixel.temp > 900 && !pixel.burning) {
-            pixel.burning = true;
-            pixel.burnStart = pixelTicks;
-        }
-    },
-	
-	tempHigh:2000,
-    stateHigh: "fire",
-    hardness: 0.3,
-    burn: 100,
-    burnTime: 3500,
-};
-
-
-elements.gasoline = {
-    color: "#c9c5b1",
-    desc: "A liquid that burns and is used to power most cars",
-    behavior: behaviors.LIQUID,
-    tick: function(pixel) {
-        if (pixel.temp > 430 && !pixel.burning) {
-            pixel.burning = true;
-            pixel.burnStart = pixelTicks;
-        }
-    },
-	tempHigh:3000,
-    stateHigh: "fire",
-    viscosity: 0.56,
-    burn: 100,
-    burnTime: 10000,
-    fireColor: "#c9c5b1",
-    category: "liquids",
-    state: "liquid",
-    density: 792,
-    stain: -0.25,
-}
-
-let itemB = "light";
-elements.solar_panel = {
-  behavior: behaviors.WALL,
-  desc: "When light touches it, it conducts electricity and the light pixel is deleted",
-      color: "#bebfa3",
-          tick: function(pixel) {
-        if(pixel.start == pixelTicks){
-          pixel.clone = itemB;
-        }
-
-          for (var i = 0; i < adjacentCoords.length; i++) {
-              var coords = adjacentCoords[i];
-              var x = pixel.x + coords[0];
-              var y = pixel.y + coords[1];
-              if (!isEmpty(x,y,true)) {
-                  var sensed = pixelMap[x][y];
-                  if (sensed.element == pixel.clone) {
-					  deletePixel(x,y);
-                      pixel.charge = 5;
-                      break;
-                  }
-              }
-          }
-          doDefaults(pixel);
-      },
-      conduct: 1,
-      movable: false,
-      category:"machines",
-      darkText: true,
-  hardness: 1,
-
-  };
-
-elements.titanium = {
-    desc: "Another metal that does not erode nor conduct electricity",
-	conduct: 0,
-	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
-	tempHigh:3000,
-    stateHigh: "molten_titanium",
-    category: "solids",
-    state: "soild",
-	 hardness: 1,
-    density: 792,
-	behavior: behaviors.WALL,
-};
-
-elements.molten_titanium = {
-    desc: "Melted version of titanium",
-    temp : 3000,
-	conduct: 0,
-	color: "#d16e04",
-	tempLow:2999,
-    stateLow: "titanium",
-    category: "states",
-    state: "soild",
-    density: 792,
-	behavior: behaviors.MOLTEN,
-};
-
-elements.solid_coal = {
-    desc: "A solid version of coal",
-	color: "#3d3c39",
-	behavior: behaviors.WALL,
-	category: "energy",
-	state: "solid",
-	breakInto: "coal_dust",
-	density: 380,
-    conduct: 0.001,
-	
-	tick: function(pixel) {
-        if (pixel.temp > 900 && !pixel.burning) {
-            pixel.burning = true;
-            pixel.burnStart = pixelTicks;
-        }
-    },
-	
-	tempHigh:3000,
-    stateHigh: "fire",
-    hardness: 0.85,
-    burn: 100,
-    burnTime: 3500,
-};
-
-elements.rubber = {
-    desc: "Not finnished",
-	color: "#ffc0cb",
-	 hardness: 0.5,
-	 tempHigh:180,
-	 state: "solid",
-	 behavior: behaviors.WALL,
-	 conduct: 0,
-	 category: "solids",
-};
-
-elements.coolant = {
-    desc: "Cools down pixels that touch it and is a liquid",
-	color: "#71ded3",
-	 state: "liquid",
-     insulate: true,
-	  behavior: behaviors.LIQUID,
-      tick: function(pixel) {
-       
-
-          for (var i = 0; i < adjacentCoords.length; i++) {
-              var coords = adjacentCoords[i];
-              var x = pixel.x + coords[0];
-              var y = pixel.y + coords[1];
-              if (!isEmpty(x,y,true)) {
-                  var sensed = pixelMap[x][y];
-                  if (sensed.element && sensed.temp > 21 ) {
-					 
-                     sensed.temp -= 1;
-                      break;
-                  }
-              }
-          }
-          doDefaults(pixel);
-      },
-	 conduct: 0.5,
-	 category: "test",
-	 
-};
-
-elements.e_cooler = {
-    desc: "Works like the cooler but needs power to work",
-	color: elements.cooler.color,
-	 hardness: 0.5,
-	 state: "solid",
-	 behavior: behaviors.WALL,
-	 conduct: 1,
-	 category: "machines",
-	 behaviorOn: [
-        "XX|CO:2|XX",
-        "CO:2|XX|CO:2",
-        "XX|CO:2|XX",
-    ],
-	name: "E-Cooler",
-};
-
-elements.e_Freezer = {
-    desc: "Works like the freezer but needs power to work",
-	color: elements.cooler.color,
-	 hardness: 0.5,
-	 state: "solid",
-	 behavior: behaviors.WALL,
-	 conduct: 1,
-	 category: "machines",
-	 behaviorOn: [
-        "XX|CO:10|XX",
-        "CO:10|XX|CO:10",
-        "XX|CO:10|XX",
-    ],
-	name: "E-Freezer",
-};
-
-elements.e_heater = {
-    desc: "Works like the heater but needs power to work",
-	 hardness: 0.5,
-	 state: "solid",
-	 behavior: behaviors.WALL,
-	 conduct: 1,
-	 category: "machines",
-	  color: "#881111",
-    behaviorOn: [
-        "XX|HT:4|XX",
-        "HT:4|XX|HT:4",
-        "XX|HT:4|XX",
-    ],
-	name: "E-Heater",
-};
-
-elements.e_SuperHeater = {
-    desc: "Works like the Super Heater but needs power to work",
-	 hardness: 0.5,
-	 state: "solid",
-	 behavior: behaviors.WALL,
-	 conduct: 1,
-	 category: "machines",
-	  color: "#881111",
-    behaviorOn: [
-        "XX|HT:12|XX",
-        "HT:12|XX|HT:12",
-        "XX|HT:12|XX",
-    ],
-	name: "E-SuperHeater",
-};
-
-elements.slow_Ecloner = {
-    desc: "Works like the Slow Cloner but needs power to work",
-	 color: "#888800",
-	 behavior: behaviors.WALL,
-    behaviorOn: [
-        "XX|CF%10|XX",
-        "CF%10|XX|CF%10",
-        "XX|CF%10|XX",
-    ],
-    ignore: ["cloner","ecloner","clone_powder","floating_cloner","wall","ewall","SteamTurbine","solar_panel"],
-    category:"machines",
-    insulate:true,
-    hardness: 1,
-	conduct: 1,
-	name: "E-SlowCloner",
-};
-
-elements.Android = {
-    desc: "A robot",
-	color: "#a1ada5",
-    category: "life",
-	color: ["#f3e7db","#f7ead0","#eadaba","#d7bd96","#a07e56","#825c43","#604134","#3a312a"],
-    category: "life",
-    properties: {
-        dead: false,
-        dir: 1,
-        panic: 0
-    },
-    tick: function(pixel) {
-        if (isEmpty(pixel.x, pixel.y+1)) {
-            createPixel("AndroidBody", pixel.x, pixel.y+1);
-            pixel.element = "AndroidHead";
-        }
-        else if (isEmpty(pixel.x, pixel.y-1)) {
-            createPixel("AndroidHead", pixel.x, pixel.y-1);
-            pixelMap[pixel.x][pixel.y-1].color = pixel.color;
-            pixel.element = "AndroidBody";
-            pixel.color = pixelColorPick(pixel)
-        }
-        else {
-            deletePixel(pixel.x, pixel.y);
-        }
-    },
-    related: ["AndroidBody","AndroidHead"],
-    cooldown: defaultCooldown
-};
-
-
-elements.AndroidBody = {
-	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
-    category: "life",
-	 breakInto: ["oil","metal_scrap","explosion"],
-	 properties: {
-        dead: false,
-        dir: 1,
-        panic: 0
-    },
-    tick: function(pixel) {
-        if (tryMove(pixel, pixel.x, pixel.y+1)) { // Fall
-            if (!isEmpty(pixel.x, pixel.y-2, true)) { // Drag head down
-                var headpixel = pixelMap[pixel.x][pixel.y-2];
-                if (headpixel.element == "AndroidHead") {
-                    if (isEmpty(pixel.x, pixel.y-1)) {
-                        movePixel(pixelMap[pixel.x][pixel.y-2], pixel.x, pixel.y-1);
-                    }
-                    else {
-                        swapPixels(pixelMap[pixel.x][pixel.y-2], pixelMap[pixel.x][pixel.y-1]);
-                    }
-                }
-            }
-        }
-        doHeat(pixel);
-        doBurning(pixel);
-        doElectricity(pixel);
-        if (pixel.dead) {
-            // Turn into rotten_meat if pixelTicks-dead > 500
-            if (pixelTicks-pixel.dead > 200 && Math.random() < 0.1) {
-                changePixel(pixel,"rotten_meat");
-            }
-            return
-        }
-
-        // Find the head
-        if (!isEmpty(pixel.x, pixel.y-1, true) && pixelMap[pixel.x][pixel.y-1].element == "AndroidHead") {
-            var head = pixelMap[pixel.x][pixel.y-1];
-            if (head.dead) { // If head is dead, kill body
-                pixel.dead = head.dead;
-            }
-        }
-        else { var head = null }
-        if (pixel.burning) {
-            pixel.panic += 0.1;
-            if (head && pixelTicks-pixel.burnStart > 240) {
-                pixel.color = head.color;
-            }
-        }
-        else if (pixel.panic > 0) {
-            pixel.panic -= 0.1;
-        }
-
-        if (isEmpty(pixel.x, pixel.y-1)) {
-            // create blood if decapitated 10% chance
-            if (Math.random() < 0.1 && !pixel.charge) {
-                createPixel("oil", pixel.x, pixel.y-1);
-                // set dead to true 15% chance
-                if (Math.random() < 0.15) {
-                    pixel.dead = pixelTicks;
-                }
-            }
-        }
-        else if (head == null) { return }
-        else if (Math.random() < 0.1*(isEmpty(pixel.x, pixel.y+1) ? 1 : pixel.panic+1)) { // Move 10% chance
-            var movesToTry = [
-                [1*pixel.dir,0],
-                [1*pixel.dir,-1],
-            ];
-            // While movesToTry is not empty, tryMove(pixel, x, y) with a random move, then remove it. if tryMove returns true, break.
-            while (movesToTry.length > 0) {
-                var move = movesToTry.splice(Math.floor(Math.random() * movesToTry.length), 1)[0];
-                if (isEmpty(pixel.x+move[0], pixel.y+move[1]-1)) {
-                    var origx = pixel.x+move[0];
-                    var origy = pixel.y+move[1];
-                    if (tryMove(pixel, pixel.x+move[0], pixel.y+move[1]) && pixel.x===origx && pixel.y===origy) {
-                        movePixel(head, head.x+move[0], head.y+move[1]);
-                        break;
-                    }
-                }
-            }
-            // 15% chance to change direction
-            if (Math.random() < 0.15) {
-                pixel.dir *= -1;
-            }
-            // homeostasis
-            if (pixel.temp > 37) { pixel.temp -= 1; }
-            else if (pixel.temp < 37) { pixel.temp += 1; }
-        }
-
-    }
-};
-
-elements.AndroidHead = {
-	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
-    category: "life",
-	density: 1080,
-    state: "solid",
-    conduct: .05,
-    temp: 69,
-    breakInto: ["oil","metal_scrap","explosion"],
-};
-
-listPipes = "pipe"
-
-
-//thx to morechem.js for the idea
-
-let setTemp = "";
-elements.ajustableHeater = {
-    desc: "Works like a heater but it can be set to a specific temp and needs power to work",
-	color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
-    category: "machines",
-	density: 1080,
-    state: "solid",
-    conduct: 1,
-	movable: false,
-	name: "Ajustable-E-Heater",
-	 onSelect: function(pixel){
-    setTemp = parseInt(prompt("Enter the temperature you want it set to.", (setTemp || undefined)));
-	        
-  },
-	tick: function(pixel) {
-        for (var i = 0; i < adjacentCoords.length; i++) {
-            var coords = adjacentCoords[i];
-            var x = pixel.x + coords[0];
-            var y = pixel.y + coords[1];
-            if (!isEmpty(x,y,true)) {
-                var sensed = pixelMap[x][y];
-                if (sensed.con || elements[sensed.element].movable && pixel.charge > 0) {
-                    sensed.temp += setTemp/6;
-					
-                    break;
-                }
-            }
-        }
-        doDefaults(pixel);
-    },
-	 insulate:true
-};
-
-//old grinder
-// elements.grinder = {
-	// color: ["#a1ada5","#ebf5ee","#bac2bc","#848a86","#505251"],
-    // category: "machines",
-	// density: 1080,
-    // state: "solid",
-    // conduct: 1,
-	// movable: false,
-	
-	// ignore: "grinder",
-	
-		// tick: function(pixel) {
-        // for (var i = 0; i < adjacentCoords.length; i++) {
-            // var coords = adjacentCoords[i];
-            // var x = pixel.x + coords[0];
-            // var y = pixel.y + coords[1];
-            // if (!isEmpty(x,y,true)) {
-                // var sensed = pixelMap[x][y];
-                // if (sensed.con || elements[sensed.element].movable && pixel.charge > 0) {
-                    // breakPixel(sensed);
-                // }
-            // }
-        // }
-        // doDefaults(pixel);
-    // },
-	 // insulate:true
-     
-	
-	
-// };
-
-
-
-elements.dead_plant.conduct = 1;
-// let compact = "dead_plant";
-// elements.compacter = {
-	// behavior: behaviors.WALL,
-      // color: "#bebfa3",
-          // tick: function(pixel) {
-        // if(pixel.start == pixelTicks){
-          // pixel.clone = compact;
-        // }
-		
-
-          // for (var i = 0; i < adjacentCoords.length; i++) {
-              // var coords = adjacentCoords[i];
-              // var x = pixel.x + coords[0];
-              // var y = pixel.y + coords[1];
-              // if (!isEmpty(x,y,true)) {
-                  // var sensed = pixelMap[x][y];
-                  // if (sensed.element == pixel.clone && pixel.charge > 0) {
-					 // sensed.element = "coal"
-					 // sensed.color = elements.coal.color
-                      // break;
-                  // }
-              // }
-          // }
-          // doDefaults(pixel);
-      // },
-      // conduct: 1,
-      // movable: false,
-      // category:"machines",
-      // darkText: true,
-  // hardness: 1,
-// }
-compactPi = "dead_plant";
-compactPi2 = "coal";
-elements.compacter = {
-    color: "#4e524f",
-    desc: "Turns dead plants into coal and needs power",
-    tick: function(pixel) {
-		if (pixel.start === pixelTicks) {
-			pixel.CompactEl = compactPi
-			pixel.CompactEl2 = compactPi2
-		}
-        if (1 === 2) {
-           for (var i = 0; i < squareCoords.length; i++) {
-                var coord = squareCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true)) {
-//                    createPixel("brick",x,y);
-//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
-                }
-            }
- //           pixel.stage = 1;
-        }
-        else if (1 === 2) { //uninitialized
-            for (var i = 0; i < adjacentCoords.length; i++) {
-                var coord = adjacentCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (isEmpty(x,y)) {
- //                   pixel.stage = 2; //blue
- //                   pixel.color = pixelColorPick(pixel,"#000036");
-                    break;
-                }
-            }
-        }
-        else if (1 === 1) { //initialized
-            for (var i = 0; i < squareCoords.length; i++) {
-                var coord = squareCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
-                    var newPixel = pixelMap[x][y];
-                    if (newPixel.stage === 1) {
-                        var newColor;
-                        switch (pixel.stage) {
-//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
- //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
-//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
-                        }
- //                       newPixel.color = pixelColorPick(newPixel,newColor);
-                    }
-                }
-            }
-            var moved = false;
-            shuffleArray(squareCoordsShuffle);
-            for (var i = 0; i < squareCoordsShuffle.length; i++) {
-                var coord = squareCoordsShuffle[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true)) {
-                    var newPixel = pixelMap[x][y];
-                    if (listPipes.includes(newPixel.element)) {
-                        var nextStage;
-                        switch (pixel.stage) {
- //                           case 2: nextStage = 4; break; //green
-//                            case 3: nextStage = 2; break; //red
- //                           case 4: nextStage = 3; break; //blue
-                        }
-                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
-                            newPixel.con = pixel.con;
-                            newPixel.con.x = newPixel.x;
-                            newPixel.con.y = newPixel.y;
-                            pixel.con = null;
-                            moved = true;
-                            break;
-                        }
-                    }
-                    else if (!pixel.con ) { //suck up pixel
-					if  ((newPixel.element == pixel.CompactEl) || (newPixel.element == pixel.CompactEl2) && pixel.charge > 0  ) {
-						
-                        pixel.con = newPixel;
-						changePixel(newPixel, "coal")
-						newPixel.color = elements.coal.color
-                        deletePixel(newPixel.x,newPixel.y);
-                        pixel.con.x = pixel.x;
-                        pixel.con.y = pixel.y;
-                        pixel.con.del;
-                        moved = true;
-                        break;
-						}
-                    }
-                }
-            }
-            if (pixel.con && !moved) { // move to same stage if none other
-                for (var i = 0; i < squareCoordsShuffle.length; i++) {
-                    var coord = squareCoordsShuffle[i];
-                    var x = pixel.x+coord[0];
-                    var y = pixel.y+coord[1];
-                    if (isEmpty(x,y)) {
-                        delete pixel.con.del;
-                        pixel.con.x = x;
-                        pixel.con.y = y;
-                        pixelMap[x][y] = pixel.con;
-                        currentPixels.push(pixel.con);
-                        pixel.con = null;
-                        break;
-                    }
-                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
-                        var newPixel = pixelMap[x][y];
-                        if (pixel.con && !newPixel.con) {
-                            newPixel.con = pixel.con;
-                            newPixel.con.x = newPixel.x;
-                            newPixel.con.y = newPixel.y;
-                            pixel.con = null;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        doDefaults(pixel);
-    },
-    category: "machines",
-    movable: false,
-    canContain: true,
-	noMix: true,
-    insulate: true,
-}
-
-// thx to nousersthings mod for the filter
-// only adding this bc my freind told me so 
-// im not good at javascript and coding so yeah
-
-filterTypeVar = 0;
-elements.filter = {
-    color: "#599fc2",
-    desc: "A filter made by nouser",
-    onSelect: function() {
-        var answer4 = prompt("Please input the desired element of this filter. It is case senstive.",(filterTypeVar||undefined));
-        if (!answer4) { return }
-		filterTypeVar = answer4;
-    },
-    tick: function(pixel) {
-		if (pixel.start === pixelTicks) {
-			pixel.filterType = filterTypeVar
-		}
-        if (1 === 2) {
-           for (var i = 0; i < squareCoords.length; i++) {
-                var coord = squareCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true)) {
-//                    createPixel("brick",x,y);
-//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
-                }
-            }
- //           pixel.stage = 1;
-        }
-        else if (1 === 2) { //uninitialized
-            for (var i = 0; i < adjacentCoords.length; i++) {
-                var coord = adjacentCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (isEmpty(x,y)) {
- //                   pixel.stage = 2; //blue
- //                   pixel.color = pixelColorPick(pixel,"#000036");
-                    break;
-                }
-            }
-        }
-        else if (1 === 1) { //initialized
-            for (var i = 0; i < squareCoords.length; i++) {
-                var coord = squareCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
-                    var newPixel = pixelMap[x][y];
-                    if (newPixel.stage === 1) {
-                        var newColor;
-                        switch (pixel.stage) {
-//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
- //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
-//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
-                        }
- //                       newPixel.color = pixelColorPick(newPixel,newColor);
-                    }
-                }
-            }
-            var moved = false;
-            shuffleArray(squareCoordsShuffle);
-            for (var i = 0; i < squareCoordsShuffle.length; i++) {
-                var coord = squareCoordsShuffle[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true)) {
-                    var newPixel = pixelMap[x][y];
-                    if (listPipes.includes(newPixel.element)) {
-                        var nextStage;
-                        switch (pixel.stage) {
- //                           case 2: nextStage = 4; break; //green
-//                            case 3: nextStage = 2; break; //red
- //                           case 4: nextStage = 3; break; //blue
-                        }
-                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
-                            newPixel.con = pixel.con;
-                            newPixel.con.x = newPixel.x;
-                            newPixel.con.y = newPixel.y;
-                            pixel.con = null;
-                            moved = true;
-                            break;
-                        }
-                    }
-                    else if (!pixel.con ) { //suck up pixel
-					if  (newPixel.element == pixel.filterType ) {
-						
-                        pixel.con = newPixel;
-		
-                        deletePixel(newPixel.x,newPixel.y);
-                        pixel.con.x = pixel.x;
-                        pixel.con.y = pixel.y;
-                        pixel.con.del;
-                        moved = true;
-                        break;
-						}
-                    }
-                }
-            }
-            if (pixel.con && !moved) { // move to same stage if none other
-                for (var i = 0; i < squareCoordsShuffle.length; i++) {
-                    var coord = squareCoordsShuffle[i];
-                    var x = pixel.x+coord[0];
-                    var y = pixel.y+coord[1];
-                    if (isEmpty(x,y)) {
-                        delete pixel.con.del;
-                        pixel.con.x = x;
-                        pixel.con.y = y;
-                        pixelMap[x][y] = pixel.con;
-                        currentPixels.push(pixel.con);
-                        pixel.con = null;
-                        break;
-                    }
-                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
-                        var newPixel = pixelMap[x][y];
-                        if (pixel.con && !newPixel.con) {
-                            newPixel.con = pixel.con;
-                            newPixel.con.x = newPixel.x;
-                            newPixel.con.y = newPixel.y;
-                            pixel.con = null;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        doDefaults(pixel);
-    },
-    category: "machines",
-    movable: false,
-    canContain: true,
-	noMix: true,
-    insulate: true,
-}
-
-filterTypeVar2 = 0;
-elements.Destructive_Filter = {
-    color: "#3c6c85",
-    desc: "A filter that destroys anything that isn't allowed to get through",
-    onSelect: function() {
-        var answer4 = prompt("Please input the desired element of this filter. It is case senstive.",(filterTypeVar||undefined));
-        if (!answer4) { return }
-		filterTypeVar2 = answer4;
-    },
-    tick: function(pixel) {
-		if (pixel.start === pixelTicks) {
-			pixel.filterType = filterTypeVar2
-		}
-        if (1 === 2) {
-           for (var i = 0; i < squareCoords.length; i++) {
-                var coord = squareCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true)) {
-//                    createPixel("brick",x,y);
-//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
-                }
-            }
- //           pixel.stage = 1;
-        }
-        else if (1 === 2) { //uninitialized
-            for (var i = 0; i < adjacentCoords.length; i++) {
-                var coord = adjacentCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (isEmpty(x,y)) {
- //                   pixel.stage = 2; //blue
- //                   pixel.color = pixelColorPick(pixel,"#000036");
-                    break;
-                }
-            }
-        }
-        else if (1 === 1) { //initialized
-            for (var i = 0; i < squareCoords.length; i++) {
-                var coord = squareCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
-                    var newPixel = pixelMap[x][y];
-                    if (newPixel.stage === 1) {
-                        var newColor;
-                        switch (pixel.stage) {
-//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
- //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
-//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
-                        }
- //                       newPixel.color = pixelColorPick(newPixel,newColor);
-                    }
-                }
-            }
-            var moved = false;
-            shuffleArray(squareCoordsShuffle);
-            for (var i = 0; i < squareCoordsShuffle.length; i++) {
-                var coord = squareCoordsShuffle[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true)) {
-                    var newPixel = pixelMap[x][y];
-                    if (listPipes.includes(newPixel.element)) {
-                        var nextStage;
-                        switch (pixel.stage) {
- //                           case 2: nextStage = 4; break; //green
-//                            case 3: nextStage = 2; break; //red
- //                           case 4: nextStage = 3; break; //blue
-                        }
-                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
-                            newPixel.con = pixel.con;
-                            newPixel.con.x = newPixel.x;
-                            newPixel.con.y = newPixel.y;
-                            pixel.con = null;
-                            moved = true;
-                            break;
-                        }
-                    }
-                    else if (!pixel.con ) { //suck up pixel
-					if  (newPixel.element == pixel.filterType) {
-						
-                        pixel.con = newPixel;
-		
-                        deletePixel(newPixel.x,newPixel.y);
-                        pixel.con.x = pixel.x;
-                        pixel.con.y = pixel.y;
-                        pixel.con.del;
-                        moved = true;
-                        break;
-						}
-						else if(!(newPixel.element == "filter") && !(newPixel.element == "Destructive_Filter") && !doNotEF.includes(newPixel.element) ) {
-							deletePixel(newPixel.x, newPixel.y);
-							break;
-							
-						}
-                    }
-                }
-            }
-            if (pixel.con && !moved) { // move to same stage if none other
-                for (var i = 0; i < squareCoordsShuffle.length; i++) {
-                    var coord = squareCoordsShuffle[i];
-                    var x = pixel.x+coord[0];
-                    var y = pixel.y+coord[1];
-                    if (isEmpty(x,y)) {
-                        delete pixel.con.del;
-                        pixel.con.x = x;
-                        pixel.con.y = y;
-                        pixelMap[x][y] = pixel.con;
-                        currentPixels.push(pixel.con);
-                        pixel.con = null;
-                        break;
-                    }
-                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
-                        var newPixel = pixelMap[x][y];
-                        if (pixel.con && !newPixel.con) {
-                            newPixel.con = pixel.con;
-                            newPixel.con.x = newPixel.x;
-                            newPixel.con.y = newPixel.y;
-                            pixel.con = null;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        doDefaults(pixel);
-    },
-    category: "machines",
-    movable: false,
-    canContain: true,
-	noMix: true,
-    insulate: true,
-}
-
-
-
-// going to fix the sucking up solids problem soon!!
-doNotEF = ["e_grinder","grinder","filter", "battery", "wire", "cloner", "sensor", "heater","cooler", "Ajustable-E-Heater", "E-Cooler", "E-Freezer", "E-Heater", "E-SuperHeater", "E-SlowCloner", "ewall", "titanium", "tungsten", "steel", "insulation","SteamTurbine","solar_panel"];
-
-elements.grinder = {
-    color: "#55565c",
-	ignore: ["e_grinder","grinder"],
-    desc: "Grinds things",
-    tick: function(pixel) {
-		
-        if (1 === 2) {
-           for (var i = 0; i < squareCoords.length; i++) {
-                var coord = squareCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true)) {
-//                    createPixel("brick",x,y);
-//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
-                }
-            }
- //           pixel.stage = 1;
-        }
-        else if (1 === 2) { //uninitialized
-            for (var i = 0; i < adjacentCoords.length; i++) {
-                var coord = adjacentCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (isEmpty(x,y)) {
- //                   pixel.stage = 2; //blue
- //                   pixel.color = pixelColorPick(pixel,"#000036");
-                    break;
-                }
-            }
-        }
-        else if (1 === 1) { //initialized
-            for (var i = 0; i < squareCoords.length; i++) {
-                var coord = squareCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
-                    var newPixel = pixelMap[x][y];
-                    if (newPixel.stage === 1) {
-                        var newColor;
-                        switch (pixel.stage) {
-//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
- //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
-//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
-                        }
- //                       newPixel.color = pixelColorPick(newPixel,newColor);
-                    }
-                }
-            }
-            var moved = false;
-            shuffleArray(squareCoordsShuffle);
-            for (var i = 0; i < squareCoordsShuffle.length; i++) {
-                var coord = squareCoordsShuffle[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true)) {
-                    var newPixel = pixelMap[x][y];
-                    if (listPipes.includes(newPixel.element)) {
-                        var nextStage;
-                        switch (pixel.stage) {
- //                           case 2: nextStage = 4; break; //green
-//                            case 3: nextStage = 2; break; //red
- //                           case 4: nextStage = 3; break; //blue
-                        }
-                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
-                            newPixel.con = pixel.con;
-                            newPixel.con.x = newPixel.x;
-                            newPixel.con.y = newPixel.y;
-                            pixel.con = null;
-                            moved = true;
-                            break;
-                        }
-                    }
-                    else if (!pixel.con  && !doNotEF.includes(newPixel.element) ) { //suck up pixel
-				// (!pixel.con && !(newPixel.element === "e_grinder") && pixel.charge > 0 && !(newPixel.element.movable))
-				// (!pixel.con && !(newPixel.element === "grinder") && !(newPixel.element === "e_grinder") && !(newPixel.element === "filter") && (newPixel.element.movable))	
-				//!(newPixel.element === "grinder") && !(newPixel.element === "e_grinder")
-                        pixel.con = newPixel;
-						breakPixel(pixel.con);
-                        deletePixel(newPixel.x,newPixel.y);
-                        pixel.con.x = pixel.x;
-                        pixel.con.y = pixel.y;
-                        pixel.con.del;
-                        moved = true;
-                        break;
-						
-                    }
-                }
-            }
-            if (pixel.con && !moved) { // move to same stage if none other
-                for (var i = 0; i < squareCoordsShuffle.length; i++) {
-                    var coord = squareCoordsShuffle[i];
-                    var x = pixel.x+coord[0];
-                    var y = pixel.y+coord[1];
-                    if (isEmpty(x,y)) {
-                        delete pixel.con.del;
-                        pixel.con.x = x;
-                        pixel.con.y = y;
-                        pixelMap[x][y] = pixel.con;
-                        currentPixels.push(pixel.con);
-                        pixel.con = null;
-                        break;
-                    }
-                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
-                        var newPixel = pixelMap[x][y];
-                        if (pixel.con && !newPixel.con) {
-                            newPixel.con = pixel.con;
-                            newPixel.con.x = newPixel.x;
-                            newPixel.con.y = newPixel.y;
-                            pixel.con = null;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        doDefaults(pixel);
-    },
-    category: "machines",
-    movable: false,
-    canContain: true,
-	noMix: true,
-    insulate: true,
-}
-
-//elements.battery.movable: false
-
-elements.e_grinder = {
-    color: "#55565c",	
-	ignore: ["e_grinder","grinder"],
-    conduct: 1,
-    desc: "Grinds things,needs power to work",
-    tick: function(pixel) {
-		
-        if (1 === 2) {
-           for (var i = 0; i < squareCoords.length; i++) {
-                var coord = squareCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true)) {
-//                    createPixel("brick",x,y);
-//                    pixelMap[x][y].color = pixelColorPick(pixel,"#808080");
-                }
-            }
- //           pixel.stage = 1;
-        }
-        else if (1 === 2) { //uninitialized
-            for (var i = 0; i < adjacentCoords.length; i++) {
-                var coord = adjacentCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (isEmpty(x,y)) {
- //                   pixel.stage = 2; //blue
- //                   pixel.color = pixelColorPick(pixel,"#000036");
-                    break;
-                }
-            }
-        }
-        else if (1 === 1) { //initialized
-            for (var i = 0; i < squareCoords.length; i++) {
-                var coord = squareCoords[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
-                    var newPixel = pixelMap[x][y];
-                    if (newPixel.stage === 1) {
-                        var newColor;
-                        switch (pixel.stage) {
-//                            case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
- //                           case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
-//                            case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
-                        }
- //                       newPixel.color = pixelColorPick(newPixel,newColor);
-                    }
-                }
-            }
-            var moved = false;
-            shuffleArray(squareCoordsShuffle);
-            for (var i = 0; i < squareCoordsShuffle.length; i++) {
-                var coord = squareCoordsShuffle[i];
-                var x = pixel.x+coord[0];
-                var y = pixel.y+coord[1];
-                if (!isEmpty(x,y,true)) {
-                    var newPixel = pixelMap[x][y];
-                    if (listPipes.includes(newPixel.element)) {
-                        var nextStage;
-                        switch (pixel.stage) {
- //                           case 2: nextStage = 4; break; //green
-//                            case 3: nextStage = 2; break; //red
- //                           case 4: nextStage = 3; break; //blue
-                        }
-                        if (pixel.con && !newPixel.con) { //transfer to adjacent pipe
-                            newPixel.con = pixel.con;
-                            newPixel.con.x = newPixel.x;
-                            newPixel.con.y = newPixel.y;
-                            pixel.con = null;
-                            moved = true;
-                            break;
-                        }
-                    }
-                    else if (!pixel.con  && !doNotEF.includes(newPixel.element) && pixel.charge > 0 ) { //suck up pixel
-				
-						
-                        pixel.con = newPixel;
-						breakPixel(pixel.con);
-                        deletePixel(newPixel.x,newPixel.y);
-                        pixel.con.x = pixel.x;
-                        pixel.con.y = pixel.y;
-                        pixel.con.del;
-                        moved = true;
-                        break;
-						
-                    }
-                }
-            }
-            if (pixel.con && !moved) { // move to same stage if none other
-                for (var i = 0; i < squareCoordsShuffle.length; i++) {
-                    var coord = squareCoordsShuffle[i];
-                    var x = pixel.x+coord[0];
-                    var y = pixel.y+coord[1];
-                    if (isEmpty(x,y)) {
-                        delete pixel.con.del;
-                        pixel.con.x = x;
-                        pixel.con.y = y;
-                        pixelMap[x][y] = pixel.con;
-                        currentPixels.push(pixel.con);
-                        pixel.con = null;
-                        break;
-                    }
-                    if (!isEmpty(x,y,true) && listPipes.includes(pixelMap[x][y].element)) {
-                        var newPixel = pixelMap[x][y];
-                        if (pixel.con && !newPixel.con) {
-                            newPixel.con = pixel.con;
-                            newPixel.con.x = newPixel.x;
-                            newPixel.con.y = newPixel.y;
-                            pixel.con = null;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        doDefaults(pixel);
-    },
-    category: "machines",
-    movable: false,
-    canContain: true,
-	noMix: true,
-    insulate: true,
-}
-
-
-
-// elements.cementMix = {
-	
-// }

From 18ff6466d303eb95b5ec12b3cbc64286aa74f7cd Mon Sep 17 00:00:00 2001
From: Mecoolnotcool <106288499+Mecoolnotcool@users.noreply.github.com>
Date: Sun, 17 Mar 2024 15:31:39 -0500
Subject: [PATCH 16/19] Update ExtraMachines.js

---
 mods/ExtraMachines.js | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/mods/ExtraMachines.js b/mods/ExtraMachines.js
index 538028b9..2ea54034 100644
--- a/mods/ExtraMachines.js
+++ b/mods/ExtraMachines.js
@@ -1225,8 +1225,11 @@ elements.e_grinder = {
     insulate: true,
 }
 
-
-
-// elements.cementMix = {
-	
-// }
\ No newline at end of file
+elements.quickSand = {
+	color: elements.sand.color,
+    category: "land",
+    state: "liquid",
+    behavior : behaviors.POWDER, //did this as a joke to see if it works lol
+    density: 500,
+    conduct: 0.02,
+}

From 6bc22bb75b309a93d0e148778e5227f8e4116010 Mon Sep 17 00:00:00 2001
From: HACKERPRO908 <130792075+HACKERPRO908@users.noreply.github.com>
Date: Sun, 17 Mar 2024 20:55:18 +0000
Subject: [PATCH 17/19] Update fantasy_elements.js - 1.5

Signed-off-by: HACKERPRO908 <130792075+HACKERPRO908@users.noreply.github.com>
---
 mods/fantasy_elements.js | 64 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 62 insertions(+), 2 deletions(-)

diff --git a/mods/fantasy_elements.js b/mods/fantasy_elements.js
index 09f3c813..4ca0481d 100644
--- a/mods/fantasy_elements.js
+++ b/mods/fantasy_elements.js
@@ -1,4 +1,37 @@
+// 1.0 update
+// adds dragon breath
+// adds frostbite
+// adds pulsium
+// adds pulsium bar
+// adds goblins delight
+// adds pheonix
+// adds pheonix ash
+// adds baby pheonix
+// adds ice pheonix
+
+// 1.1 update
+// adds dragon scale
+// adds mystic runes
+// adds enchanted wood
+// adds quartzium
+// adds quartz
+// adds moonite
+
+// 1.2 update
+// fixed visibility bug and some errors
+// adds faustium
+// adds nebulaflare
+// adds flaro
+// adds aurorium
+// adds glimmerium
+// adds ozmoz
+// adds goblin
+// adds fenzium
+// adds sceptrium
+// adds sceptrium dust
+
 // 1.3.2 fantasy_elements.js mod
+// added changelog
 // adds plode a bomb
 
 // 1.4 the golem mod
@@ -12,6 +45,11 @@
 // iced pheonix at 700 degrees becomes pheonix
 // added blood golem
 
+// 1.5 update
+// corrected the 'phoenix' wrong spelling mistake to pheonix
+// added grethe
+// added grothea
+
 elements.dragon_breath = {
     color: "#f94e4e",
     behavior: behaviors.GAS,
@@ -110,7 +148,7 @@ elements.pheonix = {
     baby: "baby_pheonix",
 };
 
-elements.phoenix_ash = {
+elements.pheonix_ash = {
     color: "#a8a8a5",
     behavior: behaviors.POWDER,
     category: "fantasy",
@@ -134,7 +172,7 @@ elements.baby_pheonix = {
     burnTime:19,
     state: "solid",
 	stateLow: "iced_pheonix",
-    breakInto: "phoenix_ash",
+    breakInto: "pheonix_ash",
     density: 850,
     conduct: 1,
 };
@@ -738,3 +776,25 @@ elements.blood_golem= {
     "category":"fantasy",
     "temp": 10,
 };
+
+elements.grethe = {
+	color: "#51f542",
+	"behavior": [
+        "XX|XX|DL",
+        "SA|XX|M2",
+        "XX|M1|XX",
+    ],
+	category: "fantasy",
+	state: "solid",
+};
+
+elements.grothea = {
+	color: ["#d742f5","#c246db","#772987"],
+	"behavior": [
+        "M2|XX|XX",
+        "SA|M1|XX",
+        "XX|XX|DL",
+    ],
+	category: "fantasy",
+	state: "solid",
+};

From edb3d7d8598c4e28350a6227f026f055a0795091 Mon Sep 17 00:00:00 2001
From: An Orbit <68935009+orbit-loona@users.noreply.github.com>
Date: Sun, 17 Mar 2024 17:05:46 -0400
Subject: [PATCH 18/19] bug fixes

---
 mods/a_mod_by_alice.js | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/mods/a_mod_by_alice.js b/mods/a_mod_by_alice.js
index 873f89a3..0b5bda76 100644
--- a/mods/a_mod_by_alice.js
+++ b/mods/a_mod_by_alice.js
@@ -14,6 +14,13 @@ try {
 
 	//ESSENTIAL COMMON FUNCTIONS (CODE LIBRARY) ##
 
+		//DEBUGGING
+		
+			function logAndReturn(thing) {
+				console.log(thing);
+				return thing
+			};
+
 		//URL
 
 			urlParams = new URLSearchParams(window.location.search);
@@ -493,7 +500,7 @@ try {
 				if(!color.startsWith("hsl(") || !color.endsWith(")")) {
 					throw new Error(`The color ${color} is not a valid hsl() color`)
 				};
-				var colorTempArray = color.split(",")
+				var colorTempArray = color.split(",").map(x => x.trim())
 				if(colorTempArray.length !== 3) {
 					throw new Error(`The color ${color} is not a valid hsl() color`)
 				};
@@ -2101,6 +2108,8 @@ try {
 				if(pixelIndex !== -1) {
 					currentPixels.splice(pixelIndex,1)
 					if (pixelMap[x][y]) { delete pixelMap[x][y] };
+				} else {
+					return false
 				};
 				//if (pixelMap[x][y]) {pixelMap[x][y].del = true}
 				//if (pixelMap[x][y]) { delete pixelMap[x][y] };
@@ -21260,10 +21269,13 @@ Pixel size (rendering only): <input id="pixelSize"> (Use if the save looks cut o
 							tempLow: Math.min(rockInfo.tempHigh - 100,800),
 							stateLow: rockName,
 							density: rockInfo.density * 0.9,
-							hardness: rockInfo.density * 0.85,
 							//breakInto: newName + "_gravel",
 							_data: [rockData[0], rockData[1], hotData2Switch(rockData[2])],
 						};
+						
+						if(rockInfo.hardness) {
+							elements[newName].hardness = rockInfo.hardness * 0.85
+						};
 
 						//console.log([elements[rockName].tempHigh,elements[rockName].stateHigh]);
 						//console.log([elements[newName].tempLow,elements[newName].stateLow])
@@ -45937,14 +45949,15 @@ maxPixels (default 1000): Maximum amount of pixels/changes (if xSpacing and ySpa
 	//SPECIFY CURRENT ELEMENT ON LOAD ##
 	
 	window.addEventListener("load",function() {
-		//console.log(currentElement);
 		currentElement = urlParams.get("currentElement") ?? "sand";
-		//console.log(currentElement);
 		if(!elementExists(currentElement)) {
-			//console.log(false);
 			currentElement = "sand"
-		}// else { console.log(true) };
-		//console.log(currentElement);
+		}
+		var size = urlParams.get("mouseSize") ?? 5;
+		if(isNaN(size)) {
+			size = 5;
+		};
+		mouseSize = size
 	});
 	
 	//MISCELLANEOUS CHANGES ##

From 4e946c1f8f2282fcf17d26512a39736885efd8ba Mon Sep 17 00:00:00 2001
From: Jayd-Rubies <155784127+Jayd-Rubies@users.noreply.github.com>
Date: Mon, 18 Mar 2024 12:36:30 -0400
Subject: [PATCH 19/19] Add files via upload

---
 mods/jaydsfunctions.js | 111 +++++++++++++++++++++++++++++++++++++++++
 mods/weapons.js        |  85 ++++++++++++++++++++++++++++++-
 2 files changed, 195 insertions(+), 1 deletion(-)
 create mode 100644 mods/jaydsfunctions.js

diff --git a/mods/jaydsfunctions.js b/mods/jaydsfunctions.js
new file mode 100644
index 00000000..724ace4b
--- /dev/null
+++ b/mods/jaydsfunctions.js
@@ -0,0 +1,111 @@
+//jaydsfunctions
+erase1Var = 0;
+elements.selective_eraser = {
+    color: ["#ffff00","#ffff00","#ffff00","#555555","#555555","#555555"],
+    category: "tools",
+    tool: function(pixel) {
+        if (pixel.element === erase1Var) {
+            deletePixel(pixel.x, pixel.y);
+        }
+    },
+        onSelect: function() {
+        var answer1 = prompt("Please input what element should be erased.",(erase1Var||undefined));
+        if (!answer1) { return }
+		erase1Var = answer1;
+    }
+},
+explode1Var = 0;
+elements.selective_exploder = {
+    color: ["#ff0000","#ff0000","#ff0000","#555555","#555555","#555555"],
+    category: "tools",
+    tool: function(pixel) {
+        if (pixel.element === explode1Var) {
+			changePixel(pixel, "explosion")
+        }
+    },
+        onSelect: function() {
+        var answer2 = prompt("Please input what element to explode.",(explode1Var||undefined));
+        if (!answer2) { return }
+		explode1Var = answer2;
+    }
+},
+convert11Var = 0;
+convert22Var = 0;
+elements.converter_tool = {
+    color: ["#ffffff","#ffffff","#ffffff","#555555","#555555","#555555"],
+    darkText: true,
+    category: "tools",
+    tool: function(pixel) {
+        if (pixel.element === convert11Var) {
+			changePixel(pixel, convert22Var)
+        }
+    },
+        onSelect: function() {
+        var answer3 = prompt("Please input what should element be converted.",(convert11Var||undefined));
+        if (!answer3) { return }
+		convert11Var = answer3;
+        var answer4 = prompt("Please input what element to convert into.",(convert22Var||undefined));
+        if (!answer4) { return }
+		convert22Var = answer4;
+    }
+},
+elements.fast_bomb = {
+    color: "#524c41",
+    category: "weapons",
+    state: "solid",
+    behavior: [
+        "XX|EX:10>explosion|XX",
+        "XX|XX|XX",
+        "M2|M1 AND EX:10>explosion|M2",
+        ],
+    tick: function(pixel) {
+        for (var i=0; i<3; i++) {
+            if (!tryMove(pixel, pixel.x, pixel.y+1)) {
+                if (!isEmpty(pixel.x, pixel.y+1,true)) {
+                    var newPixel = pixelMap[pixel.x][pixel.y+1];
+                    if (newPixel.element === "fast_bomb") { break; }
+                    }
+                }
+            }
+        },
+    density: 1300,
+    excludeRandom: true,
+    cooldown: defaultCooldown
+},
+exclude1Var = 0;
+elements.exclusive_eraser = {
+    color: ["#ff5a00","#ff5a00","#ff5a00","#555555","#555555","#555555"],
+    category: "tools",
+    tool: function(pixel) {
+        if (pixel.element !== exclude1Var) {
+            deletePixel(pixel.x, pixel.y);
+        }
+    },
+        onSelect: function() {
+        var answer5 = prompt("Please input what element shouldn't be erased.",(exclude1Var||undefined));
+        if (!answer5) { return }
+		exclude1Var = answer5;
+    }
+},
+elements.tenth_heater = {
+    category: "special",
+    color: "#ff0000",
+    behavior: [
+        "XX|HT:0.1|XX",
+        "HT:0.1|XX|HT:0.1",
+        "XX|HT:0.1|XX",
+        ],
+    ignore: "tenth_heater"
+},
+elements.e_tenth_heater = {
+    category: "special",
+    color: "#ff0000",
+    behavior: behaviors.WALL,
+    behaviorOn: [
+        "XX|HT:0.1|XX",
+        "HT:0.1|XX|HT:0.1",
+        "XX|HT:0.1|XX",
+        ],
+    ignore: "tenth_heater",
+    conduct: 1
+}
\ No newline at end of file
diff --git a/mods/weapons.js b/mods/weapons.js
index 3eef74c2..6c8181a3 100644
--- a/mods/weapons.js
+++ b/mods/weapons.js
@@ -509,4 +509,87 @@ tick: function(pixel) {
             }}},
     category: "aircrafts",
     breakInto: "metal_scrap"
- }
\ No newline at end of file
+ },
+elements.machine_for_throwing_bombs_at_you_left = {
+    color: "#524c41",
+    behavior: behaviors.WALL,
+    behaviorOn: [
+        "XX|XX|XX",
+        "CR:bombs_for_throwing_at_you_left|XX|XX",
+        "XXXX|XX",
+    ],
+    category: "weapons",
+    conduct: 1
+},
+elements.bombs_for_throwing_at_you_left = {
+    color: "#524c41",
+    category: "ammunition",
+    behavior: [
+        "XX|EX:10>bomb|XX",
+        "XX|XX|XX",
+        "M1|M1%10 AND EX:10>bomb|XX",
+    ],
+}
+elements.machine_for_throwing_bombs_at_right = {
+    color: "#524c41",
+    behavior: behaviors.WALL,
+    behaviorOn: [
+        "XX|XX|XX",
+        "XX|XX|CR:bombs_for_throwing_at_you_right",
+        "XXXX|XX",
+    ],
+    category: "weapons",
+    conduct: 1
+},
+elements.bombs_for_throwing_at_you_right = {
+    color: "#524c41",
+    category: "ammunition",
+    behavior: [
+        "XX|EX:10>bomb|XX",
+        "XX|XX|XX",
+        "XX|M1%10 AND EX:10>bomb|M1",
+    ],
+},
+elements.energized_orb_left = {
+    color: ["#e0e000","#f3f300"],
+    category: "energy",
+    behavior: [
+        "XX|EX:50>electric|XX",
+        "M1 AND EX:50>electric|XX|EX:50>electric",
+        "XX|EX:50>electric|XX"
+    ],
+    state: "gas",
+},
+elements.energized_orb_right = {
+    color: ["#e0e000","#f3f300"],
+    category: "energy",
+    behavior: [
+        "XX|EX:50>electric|XX",
+        "EX:50>electric|XX|M1 AND EX:50>electric",
+        "XX|EX:50>electric|XX"
+    ],
+    state: "gas",
+},
+elements.fast_bomb = {
+    color: "#524c41",
+    category: "weapons",
+    state: "solid",
+    behavior: [
+        "XX|EX:10>explosion|XX",
+        "XX|XX|XX",
+        "M2|M1 AND EX:10>explosion|M2",
+        ],
+    tick: function(pixel) {
+        for (var i=0; i<3; i++) {
+            if (!tryMove(pixel, pixel.x, pixel.y+1)) {
+                if (!isEmpty(pixel.x, pixel.y+1,true)) {
+                    var newPixel = pixelMap[pixel.x][pixel.y+1];
+                    if (newPixel.element === "fast_bomb") { break; }
+                    }
+                }
+            }
+        },
+    density: 1300,
+    excludeRandom: true,
+    cooldown: defaultCooldown
+}
\ No newline at end of file