From b9717b28027ab5d4d923845dfd3982b7e0d15c09 Mon Sep 17 00:00:00 2001
From: slweeb <91897291+slweeb@users.noreply.github.com>
Date: Sat, 5 Oct 2024 11:53:31 -0400
Subject: [PATCH] Version 1.10.1 - October 5, 2024 - Creepy Crawlies

[Version 1.10.1 - October 5, 2024 - Creepy Crawlies]
   [Crawly]
    + Spider, will climb and create Webs
    + Web (Hidden), will trap bugs
    + Ants can climb walls
   [Creepy]
    + Soul (Hidden), from Humans
    + Ectoplasm (Hidden)
    + Tombstone, spawns Souls
    ~ Note: Soul features will move to the souls.js mod after October
    + Candy is candy corn-colored
    + Humans will wear orange shirts on Halloween
   [Changes]
    + Fire can heat existing pixels when placed over them
    + Wet Sand and Mud release Steam when heated
    + Smashing Clouds can release their Water
    + Water will create Bubbles before boiling
    + Dirty Water can be purified before boiling
    + Panicking humans will cause others to panic
    + Rice can be fermented
    + Rats can eat Vines
    + Bleach kills Algae
    + Salt slowly dissolves in Bleach
    + Bleach destroys Ink and Dye
    + Bleach stains Porcelain Shards brown
    + Caramel dissolves in Vinegar
    + Image tool set to Paint will recolor pixels
    + Midas Touch converts hot liquids to Molten Gold
    ~ Thermite can no longer form Slag
    ~ Milk boils more realistically
    ~ Increased minimum temperature for Meat to make Grease
    ~ Blaster explodes into less Plasma
    ~ Moved Hive to after Bee when unhidden
    + Rust alias 'Iron Oxide'
   [Bug Fixes]
    ~ Fixed: Mix with Replace Mode deletes pixels
    ~ Fixed: Cannot Erase lines on mobile
    ~ Fixed: Heat glow appears in inappropriate views
    ~ Fixed: Void can be dragged
    ~ Fixed: Oxidized Copper can't sink in liquids
    ~ Fixed: Pressure Plate doesn't conduct Heat or sink
    ~ Fixed: Fire created by molten pixels isn't hot enough
    ~ Fixed: Mods added with backslash can't be removed
    ~ Fixed: Single Sponge pixels have NaN moisture
    ~ Fixed: Non-string hoverStat values crash simulation
    ~ Fixed: Crash when pixel changes state into a customColor element
   [Technical]
    + URL parameter ?holiday=false disables holiday events
    + Pressure Plate 'min' attribute for minimum density
    + 'onStateHigh' and 'onStateLow' element properties
    + 'buttonGlow' element property
    + Saves with abnormally large canvases display a warning
    + createPixel and changePixel functions accept null values
    ~ Corn updated to use 'onStateHigh' property
    ~ Pixel 'glow' attribute can be false to override default
    ~ Pixel 'glow' attribute is removed when pixel changes
    ~ Random element is no longer hard-coded
---
 changelog.html        |   60 ++
 changelog.txt         |   58 ++
 index.html            | 1389 ++++++++++++++++++++++++-----------------
 mod-list.html         |    1 +
 mods/lighting_test.js |   79 +++
 mods/souls.js         |  144 +++++
 6 files changed, 1166 insertions(+), 565 deletions(-)
 create mode 100644 mods/lighting_test.js
 create mode 100644 mods/souls.js

diff --git a/changelog.html b/changelog.html
index dd8cbd4b..400c8429 100644
--- a/changelog.html
+++ b/changelog.html
@@ -109,6 +109,66 @@
 <p>The original <a href="https://sandboxels.r74n.com/changelog.txt">plain text version</a> of this is still maintained.</p>
 </div>
 
+<h2 id="1.10.1">[Version 1.10.1 - October 5, 2024 - Creepy Crawlies]</h2>
+<ul>
+<li>[Crawly]</li>
+<li>+ Spider, will climb and create Webs</li>
+<li>+ Web (Hidden), will trap bugs</li>
+<li>+ Ants can climb walls</li>
+<li>[Creepy]</li>
+<li>+ Soul (Hidden), from Humans</li>
+<li>+ Ectoplasm (Hidden)</li>
+<li>+ Tombstone, spawns Souls</li>
+<li>~ Note: Soul features will move to the souls.js mod after October</li>
+<li>+ Candy is candy corn-colored</li>
+<li>+ Humans will wear orange shirts on Halloween</li>
+<li>[Changes]</li>
+<li>+ Fire can heat existing pixels when placed over them</li>
+<li>+ Wet Sand and Mud release Steam when heated</li>
+<li>+ Smashing Clouds can release their Water</li>
+<li>+ Water will create Bubbles before boiling</li>
+<li>+ Dirty Water can be purified before boiling</li>
+<li>+ Panicking humans will cause others to panic</li>
+<li>+ Rice can be fermented</li>
+<li>+ Rats can eat Vines</li>
+<li>+ Bleach kills Algae</li>
+<li>+ Salt slowly dissolves in Bleach</li>
+<li>+ Bleach destroys Ink and Dye</li>
+<li>+ Bleach stains Porcelain Shards brown</li>
+<li>+ Caramel dissolves in Vinegar</li>
+<li>+ Image tool set to Paint will recolor pixels</li>
+<li>+ Midas Touch converts hot liquids to Molten Gold</li>
+<li>~ Thermite can no longer form Slag</li>
+<li>~ Milk boils more realistically</li>
+<li>~ Increased minimum temperature for Meat to make Grease</li>
+<li>~ Blaster explodes into less Plasma</li>
+<li>~ Moved Hive to after Bee when unhidden</li>
+<li>+ Rust alias 'Iron Oxide'</li>
+<li>[Bug Fixes]</li>
+<li>~ Fixed: Mix with Replace Mode deletes pixels</li>
+<li>~ Fixed: Cannot Erase lines on mobile</li>
+<li>~ Fixed: Heat glow appears in inappropriate views</li>
+<li>~ Fixed: Void can be dragged</li>
+<li>~ Fixed: Oxidized Copper can't sink in liquids</li>
+<li>~ Fixed: Pressure Plate doesn't conduct Heat or sink</li>
+<li>~ Fixed: Fire created by molten pixels isn't hot enough</li>
+<li>~ Fixed: Mods added with backslash can't be removed</li>
+<li>~ Fixed: Single Sponge pixels have NaN moisture</li>
+<li>~ Fixed: Non-string hoverStat values crash simulation</li>
+<li>~ Fixed: Crash when pixel changes state into a customColor element</li>
+<li>[Technical]</li>
+<li>+ URL parameter ?holiday=false disables holiday events</li>
+<li>+ Pressure Plate 'min' attribute for minimum density</li>
+<li>+ 'onStateHigh' and 'onStateLow' element properties</li>
+<li>+ 'buttonGlow' element property</li>
+<li>+ Saves with abnormally large canvases display a warning</li>
+<li>+ createPixel and changePixel functions accept null values</li>
+<li>~ Corn updated to use 'onStateHigh' property</li>
+<li>~ Pixel 'glow' attribute can be false to override default</li>
+<li>~ Pixel 'glow' attribute is removed when pixel changes</li>
+<li>~ Random element is no longer hard-coded</li>
+</ul>
+
 <h2 id="1.10">[Version 1.10 - August 2, 2024 - Return of the Sand]</h2>
 <ul>
 <li>+ Rice</li>
diff --git a/changelog.txt b/changelog.txt
index 7e9da3fb..e75a3f6a 100644
--- a/changelog.txt
+++ b/changelog.txt
@@ -6,6 +6,64 @@ See sneak peaks for upcoming updates on the Discord: https://discord.gg/ejUc6YPQ
 
 A fancier version of this changelog can be found here: https://sandboxels.R74n.com/changelog
 
+[Version 1.10.1 - October 5, 2024 - Creepy Crawlies]
+   [Crawly]
+    + Spider, will climb and create Webs
+    + Web (Hidden), will trap bugs
+    + Ants can climb walls
+   [Creepy]
+    + Soul (Hidden), from Humans
+    + Ectoplasm (Hidden)
+    + Tombstone, spawns Souls
+    ~ Note: Soul features will move to the souls.js mod after October
+    + Candy is candy corn-colored
+    + Humans will wear orange shirts on Halloween
+   [Changes]
+    + Fire can heat existing pixels when placed over them
+    + Wet Sand and Mud release Steam when heated
+    + Smashing Clouds can release their Water
+    + Water will create Bubbles before boiling
+    + Dirty Water can be purified before boiling
+    + Panicking humans will cause others to panic
+    + Rice can be fermented
+    + Rats can eat Vines
+    + Bleach kills Algae
+    + Salt slowly dissolves in Bleach
+    + Bleach destroys Ink and Dye
+    + Bleach stains Porcelain Shards brown
+    + Caramel dissolves in Vinegar
+    + Image tool set to Paint will recolor pixels
+    + Midas Touch converts hot liquids to Molten Gold
+    ~ Thermite can no longer form Slag
+    ~ Milk boils more realistically
+    ~ Increased minimum temperature for Meat to make Grease
+    ~ Blaster explodes into less Plasma
+    ~ Moved Hive to after Bee when unhidden
+    + Rust alias 'Iron Oxide'
+   [Bug Fixes]
+    ~ Fixed: Mix with Replace Mode deletes pixels
+    ~ Fixed: Cannot Erase lines on mobile
+    ~ Fixed: Heat glow appears in inappropriate views
+    ~ Fixed: Void can be dragged
+    ~ Fixed: Oxidized Copper can't sink in liquids
+    ~ Fixed: Pressure Plate doesn't conduct Heat or sink
+    ~ Fixed: Fire created by molten pixels isn't hot enough
+    ~ Fixed: Mods added with backslash can't be removed
+    ~ Fixed: Single Sponge pixels have NaN moisture
+    ~ Fixed: Non-string hoverStat values crash simulation
+    ~ Fixed: Crash when pixel changes state into a customColor element
+   [Technical]
+    + URL parameter ?holiday=false disables holiday events
+    + Pressure Plate 'min' attribute for minimum density
+    + 'onStateHigh' and 'onStateLow' element properties
+    + 'buttonGlow' element property
+    + Saves with abnormally large canvases display a warning
+    + createPixel and changePixel functions accept null values
+    ~ Corn updated to use 'onStateHigh' property
+    ~ Pixel 'glow' attribute can be false to override default
+    ~ Pixel 'glow' attribute is removed when pixel changes
+    ~ Random element is no longer hard-coded
+
 [Version 1.10 - August 2, 2024 - Return of the Sand]
     + Rice
     + Galvanized Steel (Hidden)
diff --git a/index.html b/index.html
index 750b14ce..b7417e35 100644
--- a/index.html
+++ b/index.html
@@ -48,7 +48,7 @@
     <meta name="twitter:creator:id" content="1436857621827530753">
 
     <script> // versioning info
-        currentversion = "1.10";
+        currentversion = "1.10.1";
         saveVersion = 2;
     </script>
     <style>
@@ -75,7 +75,7 @@
             "availability":"https://schema.org/InStock"
           },
           "genre": "Falling-sand game",
-          "softwareVersion":"1.9.1",
+          "softwareVersion":"1.10.1",
           "datePublished":"2021-12-15",
           "dateCreated":"2021-12-15",
           "gameTip":"https://sandboxels.r74n.com/controls",
@@ -135,447 +135,455 @@
         
         defaultCooldown = 8;
         behaviors = {
-    POWDER_OLD: [
-        "XX|XX|XX",
-        "XX|XX|XX",
-        "M2|M1|M2",
-    ],
-    POWDER: function(pixel) {
-        if (pixel.start === pixelTicks) {return}
-        if (pixel.charge && elements[pixel.element].behaviorOn) {
-            pixelTick(pixel);
-            return;
+POWDER_OLD: [
+    "XX|XX|XX",
+    "XX|XX|XX",
+    "M2|M1|M2",
+],
+POWDER: function(pixel) {
+    if (pixel.start === pixelTicks) {return}
+    if (pixel.charge && elements[pixel.element].behaviorOn) {
+        pixelTick(pixel);
+        return;
+    }
+    if (!tryMove(pixel, pixel.x, pixel.y+1)) {
+        if (Math.random() < 0.5) {
+            if (!tryMove(pixel, pixel.x+1, pixel.y+1)) {
+                tryMove(pixel, pixel.x-1, pixel.y+1);
+            }
+        } else if (!tryMove(pixel, pixel.x-1, pixel.y+1)) {
+            tryMove(pixel, pixel.x+1, pixel.y+1);
         }
-        if (!tryMove(pixel, pixel.x, pixel.y+1)) {
+    }
+    doDefaults(pixel);
+},
+AGPOWDER: [
+    "M2|M1|M2",
+    "XX|XX|XX",
+    "XX|XX|XX",
+],
+LIQUID_OLD: [
+    "XX|XX|XX",
+    "M2|XX|M2",
+    "M1|M1|M1",
+],
+LIQUID: function(pixel) {
+    if (pixel.start === pixelTicks) {return}
+    if (pixel.charge && elements[pixel.element].behaviorOn) {
+        pixelTick(pixel);
+        return;
+    }
+    var viscMove = true;
+    if (elements[pixel.element].viscosity) {
+        viscMove = (Math.random()*100) < 100 / Math.pow(elements[pixel.element].viscosity, 0.25);
+    }
+    if (!viscMove) {
+        var move1Spots = [
+            0
+        ]
+    }
+    else {
+        var move1Spots = [
+            1,0,-1
+        ]
+    }
+    var moved = false;
+    for (var i = 0; i < move1Spots.length; i++) {
+        const j = Math.random()*move1Spots.length | 0;
+        const coord = move1Spots[j];
+        if (tryMove(pixel, pixel.x+coord, pixel.y+1)) { moved = true; break; }
+        move1Spots.splice(j, 1);
+    }
+    if (!moved) {
+        if (viscMove) {
             if (Math.random() < 0.5) {
-                if (!tryMove(pixel, pixel.x+1, pixel.y+1)) {
-                    tryMove(pixel, pixel.x-1, pixel.y+1);
+                if (!tryMove(pixel, pixel.x+1, pixel.y)) {
+                    tryMove(pixel, pixel.x-1, pixel.y);
+                }
+            } else {
+                if (!tryMove(pixel, pixel.x-1, pixel.y)) {
+                    tryMove(pixel, pixel.x+1, pixel.y);
                 }
-            } else if (!tryMove(pixel, pixel.x-1, pixel.y+1)) {
-                tryMove(pixel, pixel.x+1, pixel.y+1);
             }
         }
-        doDefaults(pixel);
-    },
-    AGPOWDER: [
-        "M2|M1|M2",
-        "XX|XX|XX",
-        "XX|XX|XX",
-    ],
-    LIQUID_OLD: [
-        "XX|XX|XX",
-        "M2|XX|M2",
-        "M1|M1|M1",
-    ],
-    LIQUID: function(pixel) {
-        if (pixel.start === pixelTicks) {return}
-        if (pixel.charge && elements[pixel.element].behaviorOn) {
-            pixelTick(pixel);
-            return;
-        }
-        var viscMove = true;
-        if (elements[pixel.element].viscosity) {
-            viscMove = (Math.random()*100) < 100 / Math.pow(elements[pixel.element].viscosity, 0.25);
-        }
-        if (!viscMove) {
-            var move1Spots = [
-                0
-            ]
+    }
+    doDefaults(pixel);
+},
+SUPERFLUID_OLD: [
+    "XX|XX|XX",
+    "XX|XX|M2 AND BO",
+    "XX|M1|M2",
+],
+SUPERFLUID: function(pixel) {
+    if (pixel.start === pixelTicks) {return}
+    if (pixel.charge && elements[pixel.element].behaviorOn) {
+        pixelTick(pixel);
+        return;
+    }
+    if (!tryMove(pixel, pixel.x, pixel.y+1)) {
+        // go either left or right depending on pixel.flipX
+        var newx = pixel.flipX ? pixel.x-1 : pixel.x+1;
+        if (Math.random() < 0.5) {
+            if (!tryMove(pixel, newx, pixel.y)) {
+                pixel.flipX = !pixel.flipX;
+                tryMove(pixel, newx, pixel.y+1);
+            }
         }
         else {
-            var move1Spots = [
-                1,0,-1
-            ]
-        }
-        var moved = false;
-        for (var i = 0; i < move1Spots.length; i++) {
-            const j = Math.random()*move1Spots.length | 0;
-            const coord = move1Spots[j];
-            if (tryMove(pixel, pixel.x+coord, pixel.y+1)) { moved = true; break; }
-            move1Spots.splice(j, 1);
-        }
-        if (!moved) {
-            if (viscMove) {
-                if (Math.random() < 0.5) {
-                    if (!tryMove(pixel, pixel.x+1, pixel.y)) {
-                        tryMove(pixel, pixel.x-1, pixel.y);
-                    }
-                } else {
-                    if (!tryMove(pixel, pixel.x-1, pixel.y)) {
-                        tryMove(pixel, pixel.x+1, pixel.y);
-                    }
-                }
+            if (!tryMove(pixel, newx, pixel.y+1)) {
+                if (!tryMove(pixel, newx, pixel.y)) { pixel.flipX = !pixel.flipX; }
             }
         }
-        doDefaults(pixel);
-    },
-    SUPERFLUID_OLD: [
-        "XX|XX|XX",
-        "XX|XX|M2 AND BO",
-        "XX|M1|M2",
-    ],
-    SUPERFLUID: function(pixel) {
-        if (pixel.start === pixelTicks) {return}
-        if (pixel.charge && elements[pixel.element].behaviorOn) {
-            pixelTick(pixel);
-            return;
+    }
+    doDefaults(pixel);
+},
+LIGHTWEIGHT: [
+    "XX|XX|XX",
+    "XX|FX%0.25|XX",
+    "M2%10|M1%10|M1%10",
+],
+SLIDE: [
+    "XX|XX|XX",
+    "XX|XX|M2 AND BO",
+    "XX|M1|M1",
+],
+AGLIQUID: [
+    "M1|M1|M1",
+    "M2|XX|M2",
+    "XX|XX|XX",
+],
+WALL: [
+    "XX|XX|XX",
+    "XX|XX|XX",
+    "XX|XX|XX",
+],
+UL_UR: [
+    "M1|M1|M1",
+    "M2|XX|M2",
+    "XX|M2|XX",
+],
+UL_UR_OPTIMIZED: function(pixel) {
+    if (pixel.start === pixelTicks) {return}
+    if (pixel.charge && elements[pixel.element].behaviorOn) {
+        pixelTick(pixel);
+        return;
+    }
+    var move1Spots = [0,1,-1]
+    var moved = false;
+    for (var i = 0; i < move1Spots.length; i++) {
+        const j = Math.random()*move1Spots.length | 0;
+        const coord = move1Spots[j];
+        if (tryMove(pixel, pixel.x+coord, pixel.y-1)) { moved = true; break; }
+        else { move1Spots.splice(j, 1);}
+    }
+    if (!moved && !pixel.del) {
+        var move2Spots = [
+            [0, 1],
+            [1, 0],
+            [-1, 0],
+        ]
+        for (var i = 0; i < move2Spots.length; i++) {
+            const j = Math.random()*move2Spots.length | 0;
+            const coords = move2Spots[j];
+            if (tryMove(pixel, pixel.x+coords[0], pixel.y+coords[1])) { break; }
+            else { move2Spots.splice(j, 1); }
         }
-        if (!tryMove(pixel, pixel.x, pixel.y+1)) {
-            // go either left or right depending on pixel.flipX
-            var newx = pixel.flipX ? pixel.x-1 : pixel.x+1;
-            if (Math.random() < 0.5) {
-                if (!tryMove(pixel, newx, pixel.y)) {
-                    pixel.flipX = !pixel.flipX;
-                    tryMove(pixel, newx, pixel.y+1);
+    }
+    if (!pixel.del) { doDefaults(pixel); }
+},
+GAS_OLD: [
+    "M2|M1|M2",
+    "M1|XX|M1",
+    "M2|M1|M2",
+],
+GAS: function(pixel) {
+    if (pixel.start === pixelTicks) {return}
+    if (pixel.charge && elements[pixel.element].behaviorOn) {
+        pixelTick(pixel);
+        return;
+    }
+    let move1Spots = adjacentCoords.slice(0);
+    var moved = false;
+    for (var i = 0; i < move1Spots.length; i++) {
+        const j = Math.random()*move1Spots.length | 0;
+        const coords = move1Spots[j];
+        if (tryMove(pixel, pixel.x+coords[0], pixel.y+coords[1])) { moved = true; break; }
+        move1Spots.splice(j, 1);
+    }
+    if (!moved) {
+        let move2Spots = diagonalCoords.slice(0);
+        for (var i = 0; i < move2Spots.length; i++) {
+            const j = Math.random()*move2Spots.length | 0;
+            const coords = move2Spots[j];
+            if (tryMove(pixel, pixel.x+coords[0], pixel.y+coords[1])) { break; }
+            move2Spots.splice(j, 1);
+        }
+    }
+    doDefaults(pixel);
+},
+DGAS_OLD: [
+    "M2|M1|M2",
+    "M1|DL%5|M1",
+    "M2|M1|M2",
+],
+DGAS: function(pixel) {
+    if (Math.random() < 0.05) {
+        deletePixel(pixel.x,pixel.y);
+        return;
+    }
+    behaviors.GAS(pixel);
+},
+SUPPORT: [
+    "XX|XX|XX",
+    "SP|XX|SP",
+    "XX|M1|XX",
+],
+SUPPORTPOWDER: [
+    "XX|XX|XX",
+    "SP|XX|SP",
+    "M2|M1|M2",
+],
+DELETE: [
+    "XX|DL|XX",
+    "DL|XX|DL",
+    "XX|DL|XX",
+],
+FILL: [
+    "XX|CL|XX",
+    "CL|XX|CL",
+    "XX|CL|XX",
+],
+CLONER: [
+    "XX|CF|XX",
+    "CF|XX|CF",
+    "XX|CF|XX",
+],
+STURDYPOWDER_OLD: [
+    "XX|XX|XX",
+    "XX|XX|XX",
+    "XX|M1|XX",
+],
+STURDYPOWDER: function(pixel) {
+    if (pixel.start === pixelTicks) {return}
+    if (pixel.charge && elements[pixel.element].behaviorOn) {
+        pixelTick(pixel);
+        return;
+    }
+    tryMove(pixel,pixel.x,pixel.y+1);
+    doDefaults(pixel);
+},
+SELFDELETE: [
+    "XX|XX|XX",
+    "XX|DL|XX",
+    "XX|XX|XX",
+],
+FOAM: [
+    "XX|XX|XX",
+    "XX|DL%5|XX",
+    "M2%25|M1%25|M2%25",
+],
+BUBBLE: [
+    "XX|XX|XX",
+    "XX|DL%0.25 AND FX%1|M1%5",
+    "XX|M1%1|M1%2",
+],
+STICKY: [
+    "XX|ST|XX",
+    "ST|XX|ST",
+    "XX|ST AND M1|XX",
+],
+MOLTEN: function(pixel) {
+    if (Math.random() < 0.025 && isEmpty(pixel.x,pixel.y-1)) {
+        createPixel("fire",pixel.x,pixel.y-1);
+        pixelMap[pixel.x][pixel.y-1].temp = pixel.temp;
+        if (elements[pixel.element].fireColor) {
+            pixelMap[pixel.x][pixel.y-1].color = pixelColorPick(pixelMap[pixel.x][pixel.y-1],elements[pixel.element].fireColor);
+        }
+    }
+    behaviors.LIQUID(pixel);
+},
+MOLTEN_OLD: [
+    "XX|CR:fire%2.5|XX",
+    "M2|XX|M2",
+    "M1|M1|M1",
+],
+RADPOWDER: [
+    "XX|CR:radiation%1|XX",
+    "CR:radiation%1|XX|CR:radiation%1",
+    "M2|M1|M2",
+],
+RADMOLTEN: [
+    "XX|CR:fire,fire,fire,radiation%4.5|XX",
+    "M2 AND CR:radiation%1|XX|M2 AND CR:radiation%1",
+    "M1|M1|M1",
+],
+RADLIQUID: [
+    "XX|CR:radiation%2|XX",
+    "M2 AND CR:radiation%2|XX|M2 AND CR:radiation%2",
+    "M1|M1|M1",
+],
+BOUNCY: function(pixel) {
+    if (pixel.bx===undefined) {
+        // choose 1, 0, or -1
+        pixel.bx = Math.random() < 0.5 ? 1 : Math.random() < 0.5 ? 0 : -1;
+        pixel.by = Math.random() < 0.5 ? 1 : Math.random() < 0.5 ? 0 : -1;
+        // if both are 0, make one of them 1 or -1
+        if (pixel.bx===0 && pixel.by===0) {
+            if (Math.random() < 0.5) { pixel.bx = Math.random() < 0.5 ? 1 : -1; }
+            else { pixel.by = Math.random() < 0.5 ? 1 : -1; }
+        }
+    }
+    // move and invert direction if hit
+    if (!pixel.del && pixel.bx && !tryMove(pixel, pixel.x+pixel.bx, pixel.y)) { pixel.bx = -pixel.bx; }
+    if (!pixel.del && pixel.by && !tryMove(pixel, pixel.x, pixel.y+pixel.by)) { pixel.by = -pixel.by; }
+},
+FEEDPIXEL: function(pixel) {
+    if (!pixel.food) { pixel.food = 1 }
+    else { pixel.food ++ }
+    if (pixel.food > (elements[pixel.element].foodNeed||30)) {
+        // loop through adjacentCoords and check each pixel to lay an egg
+        for (var i = 0; i < adjacentCoords.length; i++) {
+            var x = pixel.x+adjacentCoords[i][0];
+            var y = pixel.y+adjacentCoords[i][1];
+            if (isEmpty(x, y)) {
+                if (elements[pixel.element].egg) {
+                    createPixel(elements[pixel.element].egg,x,y)
                 }
+                else {
+                    createPixel("egg",x,y)
+                    pixelMap[x][y].animal = elements[pixel.element].baby || pixel.element;
+                    if (elements[pixel.element].eggColor) {
+                        pixelMap[x][y].color = pixelColorPick(pixelMap[x][y],elements[pixel.element].eggColor)
+                    }
+                }
+                pixel.food = 0;
+                break;
+            }
+        }
+    }
+},
+KILLPIXEL1: function(pixel) {
+    pixel.dead = true;
+},
+KILLPIXEL2: function(pixel1,pixel2) {
+    pixel2.dead = true;
+},
+FLY: function(pixel, onHit) {
+    var nx = pixel.flipX ? -1 : 1;
+    var ny = Math.random() < 0.5 ? -1 : 1;
+    var hit = false;
+    if (!tryMove(pixel, pixel.x+nx, pixel.y+ny)) {
+        if (!tryMove(pixel, pixel.x+nx, pixel.y-ny)) {
+            if (!tryMove(pixel, pixel.x, pixel.y+ny)) {
+                if (!tryMove(pixel, pixel.x, pixel.y-ny)) {hit=[pixel.x, pixel.y-ny]}
+            }else {hit=[pixel.x, pixel.y+ny]}
+        }else {hit=[pixel.x+nx, pixel.y-ny]}
+    }else {hit=[pixel.x+nx, pixel.y+ny]}
+    if (hit && onHit) {
+        if (!isEmpty(hit[0], hit[1], true)) {
+            onHit(pixel, pixelMap[hit[0]][hit[1]]);
+        }
+        else {onHit(pixel);}
+    }
+    if (pixel.del) {return}
+    if (!isEmpty(pixel.x+nx,pixel.y) || Math.random() < 0.02) {
+        pixel.flipX = !pixel.flipX;
+    }
+    if (pixel.charge && elements[pixel.element].behaviorOn) {
+        pixelTick(pixel)
+    }
+    doDefaults(pixel);
+},
+CRAWLER2: function(pixel,onHit,afterMove) {
+    var newX = 0; var newY = 0;
+    var floorX = 0; var floorY = 0;
+    if (pixel.r === undefined) { pixel.r = 0 }
+    if (pixel.climb === undefined) { pixel.climb = 0 }
+    if (pixel.r === 0) { newX = 1; floorY = 1; }
+    else if (pixel.r === 1) { newY = 1; floorX = 1; }
+    else if (pixel.r === 2) { newX = -1; floorY = 1; }
+    else if (pixel.r === 3) { newY = -1; floorX = 1;}
+    
+    if (!isEmpty(pixel.x-floorX,pixel.y-floorY)) {
+        if (!isEmpty(pixel.x+floorX,pixel.y+floorY) && Math.random() < 0.5) {}
+        else {
+            floorX = -floorX; floorY = -floorY;
+        }
+    }
+
+    if (!(isEmpty(pixel.x+floorX,pixel.y+floorY) && tryMove(pixel,pixel.x,pixel.y+1))) { // fall
+        pixel.climb++;
+        if (!tryMove(pixel,pixel.x+newX,pixel.y+newY) && !tryMove(pixel,pixel.x+newX,pixel.y+newY+(Math.random() < 0.5 ? 1 : -1))) { // hits wall
+            pixel.climb = 0;
+            if (onHit) { onHit(pixel,newX,newY); }
+            if (!isEmpty(pixel.x+newX,pixel.y+newY,true) && pixelMap[pixel.x+newX][pixel.y+newY].element === pixel.element) {
+                pixelMap[pixel.x+newX][pixel.y+newY].r = pixel.r;
             }
             else {
-                if (!tryMove(pixel, newx, pixel.y+1)) {
-                    if (!tryMove(pixel, newx, pixel.y)) { pixel.flipX = !pixel.flipX; }
-                }
+                pixel.r = Math.floor(Math.random() * 4);
             }
         }
-        doDefaults(pixel);
-    },
-    LIGHTWEIGHT: [
-        "XX|XX|XX",
-        "XX|FX%0.25|XX",
-        "M2%10|M1%10|M1%10",
-    ],
-    SLIDE: [
-        "XX|XX|XX",
-        "XX|XX|M2 AND BO",
-        "XX|M1|M1",
-    ],
-    AGLIQUID: [
-        "M1|M1|M1",
-        "M2|XX|M2",
-        "XX|XX|XX",
-    ],
-    WALL: [
-        "XX|XX|XX",
-        "XX|XX|XX",
-        "XX|XX|XX",
-    ],
-    UL_UR: [
-        "M1|M1|M1",
-        "M2|XX|M2",
-        "XX|M2|XX",
-    ],
-    UL_UR_OPTIMIZED: function(pixel) {
-        if (pixel.start === pixelTicks) {return}
-        if (pixel.charge && elements[pixel.element].behaviorOn) {
-            pixelTick(pixel);
-            return;
-        }
-        var move1Spots = [0,1,-1]
-        var moved = false;
-        for (var i = 0; i < move1Spots.length; i++) {
-            const j = Math.random()*move1Spots.length | 0;
-            const coord = move1Spots[j];
-            if (tryMove(pixel, pixel.x+coord, pixel.y-1)) { moved = true; break; }
-            else { move1Spots.splice(j, 1);}
-        }
-        if (!moved && !pixel.del) {
-            var move2Spots = [
-                [0, 1],
-                [1, 0],
-                [-1, 0],
-            ]
-            for (var i = 0; i < move2Spots.length; i++) {
-                const j = Math.random()*move2Spots.length | 0;
-                const coords = move2Spots[j];
-                if (tryMove(pixel, pixel.x+coords[0], pixel.y+coords[1])) { break; }
-                else { move2Spots.splice(j, 1); }
+        else if (pixel.r % 2 === 1) {
+            if (tryMove(pixel,pixel.x+floorX,pixel.y)) {
+                pixel.r = floorX < 0 ? 2 : 0;
+                pixel.climb = 0;
             }
         }
-        if (!pixel.del) { doDefaults(pixel); }
-    },
-    GAS_OLD: [
-        "M2|M1|M2",
-        "M1|XX|M1",
-        "M2|M1|M2",
-    ],
-    GAS: function(pixel) {
-        if (pixel.start === pixelTicks) {return}
-        if (pixel.charge && elements[pixel.element].behaviorOn) {
-            pixelTick(pixel);
-            return;
+        else if (tryMove(pixel,pixel.x,pixel.y+floorY)) {
+            pixel.r = floorY < 0 ? 3 : 1;
+            pixel.climb = 0;
         }
-        let move1Spots = adjacentCoords.slice(0);
-        var moved = false;
-        for (var i = 0; i < move1Spots.length; i++) {
-            const j = Math.random()*move1Spots.length | 0;
-            const coords = move1Spots[j];
-            if (tryMove(pixel, pixel.x+coords[0], pixel.y+coords[1])) { moved = true; break; }
-            move1Spots.splice(j, 1);
-        }
-        if (!moved) {
-            let move2Spots = diagonalCoords.slice(0);
-            for (var i = 0; i < move2Spots.length; i++) {
-                const j = Math.random()*move2Spots.length | 0;
-                const coords = move2Spots[j];
-                if (tryMove(pixel, pixel.x+coords[0], pixel.y+coords[1])) { break; }
-                move2Spots.splice(j, 1);
-            }
-        }
-        doDefaults(pixel);
-    },
-    DGAS_OLD: [
-        "M2|M1|M2",
-        "M1|DL%5|M1",
-        "M2|M1|M2",
-    ],
-    DGAS: function(pixel) {
-        if (Math.random() < 0.05) {
-            deletePixel(pixel.x,pixel.y);
-            return;
-        }
-        behaviors.GAS(pixel);
-    },
-    SUPPORT: [
-        "XX|XX|XX",
-        "SP|XX|SP",
-        "XX|M1|XX",
-    ],
-    SUPPORTPOWDER: [
-        "XX|XX|XX",
-        "SP|XX|SP",
-        "M2|M1|M2",
-    ],
-    DELETE: [
-        "XX|DL|XX",
-        "DL|XX|DL",
-        "XX|DL|XX",
-    ],
-    FILL: [
-        "XX|CL|XX",
-        "CL|XX|CL",
-        "XX|CL|XX",
-    ],
-    CLONER: [
-        "XX|CF|XX",
-        "CF|XX|CF",
-        "XX|CF|XX",
-    ],
-    STURDYPOWDER_OLD: [
-        "XX|XX|XX",
-        "XX|XX|XX",
-        "XX|M1|XX",
-    ],
-    STURDYPOWDER: function(pixel) {
-        if (pixel.start === pixelTicks) {return}
-        if (pixel.charge && elements[pixel.element].behaviorOn) {
-            pixelTick(pixel);
-            return;
-        }
-        tryMove(pixel,pixel.x,pixel.y+1);
-        doDefaults(pixel);
-    },
-    SELFDELETE: [
-        "XX|XX|XX",
-        "XX|DL|XX",
-        "XX|XX|XX",
-    ],
-    FOAM: [
-        "XX|XX|XX",
-        "XX|DL%5|XX",
-        "M2%25|M1%25|M2%25",
-    ],
-    BUBBLE: [
-        "XX|XX|XX",
-        "XX|DL%0.25 AND FX%1|M1%5",
-        "XX|M1%1|M1%2",
-    ],
-    STICKY: [
-        "XX|ST|XX",
-        "ST|XX|ST",
-        "XX|ST AND M1|XX",
-    ],
-    MOLTEN: function(pixel) {
-        if (Math.random() < 0.025 && isEmpty(pixel.x,pixel.y-1)) {
-            createPixel("fire",pixel.x,pixel.y-1)
-            if (elements[pixel.element].fireColor) {
-                pixelMap[pixel.x][pixel.y-1].color = pixelColorPick(pixelMap[pixel.x][pixel.y-1],elements[pixel.element].fireColor);
-            }
-        }
-        behaviors.LIQUID(pixel);
-    },
-    MOLTEN_OLD: [
-        "XX|CR:fire%2.5|XX",
-        "M2|XX|M2",
-        "M1|M1|M1",
-    ],
-    RADPOWDER: [
-        "XX|CR:radiation%1|XX",
-        "CR:radiation%1|XX|CR:radiation%1",
-        "M2|M1|M2",
-    ],
-    RADMOLTEN: [
-        "XX|CR:fire,fire,fire,radiation%4.5|XX",
-        "M2 AND CR:radiation%1|XX|M2 AND CR:radiation%1",
-        "M1|M1|M1",
-    ],
-    RADLIQUID: [
-        "XX|CR:radiation%2|XX",
-        "M2 AND CR:radiation%2|XX|M2 AND CR:radiation%2",
-        "M1|M1|M1",
-    ],
-    BOUNCY: function(pixel) {
-        if (pixel.bx===undefined) {
-            // choose 1, 0, or -1
-            pixel.bx = Math.random() < 0.5 ? 1 : Math.random() < 0.5 ? 0 : -1;
-            pixel.by = Math.random() < 0.5 ? 1 : Math.random() < 0.5 ? 0 : -1;
-            // if both are 0, make one of them 1 or -1
-            if (pixel.bx===0 && pixel.by===0) {
-                if (Math.random() < 0.5) { pixel.bx = Math.random() < 0.5 ? 1 : -1; }
-                else { pixel.by = Math.random() < 0.5 ? 1 : -1; }
-            }
-        }
-        // move and invert direction if hit
-        if (!pixel.del && pixel.bx && !tryMove(pixel, pixel.x+pixel.bx, pixel.y)) { pixel.bx = -pixel.bx; }
-        if (!pixel.del && pixel.by && !tryMove(pixel, pixel.x, pixel.y+pixel.by)) { pixel.by = -pixel.by; }
-    },
-    FEEDPIXEL: function(pixel) {
-        if (!pixel.food) { pixel.food = 1 }
-        else { pixel.food ++ }
-        if (pixel.food > (elements[pixel.element].foodNeed||30)) {
-            // loop through adjacentCoords and check each pixel to lay an egg
-            for (var i = 0; i < adjacentCoords.length; i++) {
-                var x = pixel.x+adjacentCoords[i][0];
-                var y = pixel.y+adjacentCoords[i][1];
-                if (isEmpty(x, y)) {
-                    if (elements[pixel.element].egg) {
-                        createPixel(elements[pixel.element].egg,x,y)
-                    }
-                    else {
-                        createPixel("egg",x,y)
-                        pixelMap[x][y].animal = elements[pixel.element].baby || pixel.element;
-                        if (elements[pixel.element].eggColor) {
-                            pixelMap[x][y].color = pixelColorPick(pixelMap[x][y],elements[pixel.element].eggColor)
-                        }
-                    }
-                    pixel.food = 0;
-                    break;
-                }
-            }
-        }
-    },
-    KILLPIXEL1: function(pixel) {
-        pixel.dead = true;
-    },
-    KILLPIXEL2: function(pixel1,pixel2) {
-        pixel2.dead = true;
-    },
-    FLY: function(pixel, onHit) {
-        var nx = pixel.flipX ? -1 : 1;
-        var ny = Math.random() < 0.5 ? -1 : 1;
-        var hit = false;
-        if (!tryMove(pixel, pixel.x+nx, pixel.y+ny)) {
-            if (!tryMove(pixel, pixel.x+nx, pixel.y-ny)) {
-                if (!tryMove(pixel, pixel.x, pixel.y+ny)) {
-                    if (!tryMove(pixel, pixel.x, pixel.y-ny)) {hit=[pixel.x, pixel.y-ny]}
-                }else {hit=[pixel.x, pixel.y+ny]}
-            }else {hit=[pixel.x+nx, pixel.y-ny]}
-        }else {hit=[pixel.x+nx, pixel.y+ny]}
-        if (hit && onHit) {
-            if (!isEmpty(hit[0], hit[1], true)) {
-                onHit(pixel, pixelMap[hit[0]][hit[1]]);
-            }
-            else {onHit(pixel);}
-        }
-        if (pixel.del) {return}
-        if (!isEmpty(pixel.x+nx,pixel.y) || Math.random() < 0.02) {
-            pixel.flipX = !pixel.flipX;
-        }
-        if (pixel.charge && elements[pixel.element].behaviorOn) {
-            pixelTick(pixel)
-        }
-        doDefaults(pixel);
-    },
-    CRAWLER: function(pixel) {
-        if (Math.random() < 0.08) { // flip
-            pixel.flipX = !pixel.flipX;
-        }
-        var dir = pixel.flipX ? -1 : 1;
-        var dirY = pixel.flipY ? -1 : 1;
-        if (!tryMove(pixel,pixel.x,pixel.y+dirY)) { // fall or climb
-            if (!tryMove(pixel,pixel.x+dir,pixel.y)) { // hits wall
-                if (!pixel.hilled && !isEmpty(pixel.x+dir,pixel.y,true) && pixelMap[pixel.x+dir][pixel.y].element === "ant_wall") {
-                    pixel.hilled = true;
-                }
-                tryMove(pixel,pixel.x+dir,pixel.y + (Math.random() < 0.25 ? 1 : -1));
-            }
-            if (Math.random() < 0.01 && !isEmpty(pixel.x+dir,pixel.y+1,true) && eLists.CRAWLTHRU.indexOf(pixelMap[pixel.x+dir][pixel.y+1].element) !== -1) {
-                if (!pixel.hilled || !isEmpty(pixel.x+dir,pixel.y,true) && pixelMap[pixel.x+dir][pixel.y].element === "ant_wall") {
-                    var wallCoords = [
-                        [-1,-1],[1,-1],
-                        [-1,0],[1,0],
-                        [0,1]
-                    ];
-                    if (!isEmpty(pixel.x,pixel.y-2)) {
-                        wallCoords.push([0,-1])
-                    }
-                    if (Math.random() < 0.15) { wallCoords.push([-1,1]) }
-                    if (Math.random() < 0.15) { wallCoords.push([1,1]) }
-                    // loop through wallCoords, change pixel to ant_wall if in crawlthru
-                    for (var i = 0; i < wallCoords.length; i++) {
-                        var x = pixel.x+dir+wallCoords[i][0];
-                        var y = pixel.y+1+wallCoords[i][1];
-                        if (!isEmpty(x,y,true) && eLists.CRAWLTHRU.indexOf(pixelMap[x][y].element) !== -1) {
-                            changePixel(pixelMap[x][y],"ant_wall");
-                        }
-                    }
-                    deletePixel(pixel.x+dir,pixel.y+1);
-                    tryMove(pixel,pixel.x+dir,pixel.y+1);
-                }
-            }
-            else if (Math.random() < 0.08 && !isEmpty(pixel.x+dir,pixel.y-1,true) && eLists.CRAWLTHRU.indexOf(pixelMap[pixel.x+dir][pixel.y-1].element) !== -1) {
-                swapPixels(pixel,pixelMap[pixel.x+dir][pixel.y-1]);
-            }
-        }
-        doDefaults(pixel);
-    },
-    ABSORB: function(pixel,limit=100,rate=0.1) {
-        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 newPixel = pixelMap[x][y];
-                if (newPixel.element === pixel.element) {
-                    var avg = ((pixel.moist||0) + (newPixel.moist||0))/2;
-                    pixel.moist = avg;
-                    newPixel.moist = avg;
-                }
-                else if (elements[pixel.element].reactions[newPixel.element] && (!elements[pixel.element].reactions[newPixel.element].elem2 || elements[pixel.element].reactions[newPixel.element].tempMin) && (pixel.moist||0) < limit && Math.random() < rate) {
-                    deletePixel(x,y);
-                    pixel.moist++;
-                }
-            }
-            else if (pixel.moist >= 1 && pixel.temp > 100 && !outOfBounds(x,y) && Math.random() < 0.1) {
-                createPixel("steam",x,y);
-                pixel.moist--;
-            }
-        }
-    },
-    RELEASE_MOISTURE: 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) && pixel.moist >= 1) {
-                createPixel("water",x,y);
-                pixel.moist--;
-            }
-        }
-    },
-    DO_TICK: function(pixel) {
-        if (elements[pixel.element].tick1) {
-            elements[pixel.element].tick1(pixel); return;
-        }
-        elements[pixel.element].tick(pixel);
+        if (afterMove) { afterMove(pixel,newX,newY); }
     }
+    else {
+        pixel.r = Math.random() < 0.5 ? 0 : 2;
+        pixel.climb = 0;
+    }
+    doDefaults(pixel);
+},
+CRAWLER: function(pixel) {},
+ABSORB: function(pixel,limit=100,rate=0.1) {
+    if (pixel.moist === undefined) { pixel.moist = 0 }
+    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 newPixel = pixelMap[x][y];
+            if (newPixel.element === pixel.element) {
+                var avg = ((pixel.moist||0) + (newPixel.moist||0))/2;
+                pixel.moist = avg;
+                newPixel.moist = avg;
+            }
+            else if (elements[pixel.element].reactions[newPixel.element] && (!elements[pixel.element].reactions[newPixel.element].elem2 || elements[pixel.element].reactions[newPixel.element].tempMin) && (pixel.moist||0) < limit && Math.random() < rate) {
+                deletePixel(x,y);
+                pixel.moist++;
+            }
+        }
+        else if (pixel.moist >= 1 && pixel.temp > 100 && !outOfBounds(x,y) && Math.random() < 0.1) {
+            createPixel("steam",x,y);
+            pixel.moist--;
+        }
+    }
+},
+RELEASE_MOISTURE: function(pixel) {
+    if (pixel.moist === undefined) { pixel.moist = 0 }
+    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) && pixel.moist >= 1) {
+            createPixel("water",x,y);
+            pixel.moist--;
+        }
+    }
+},
+DO_TICK: function(pixel) {
+    if (elements[pixel.element].tick1) {
+        elements[pixel.element].tick1(pixel); return;
+    }
+    elements[pixel.element].tick(pixel);
+}
         }
         textures = {
             BRICK: [
@@ -609,6 +617,7 @@
         renderPresets = {
             HEATGLOW: function(pixel,ctx) {
                 drawDefault(ctx,pixel);
+                if (!viewInfo[view].colorEffects) { return }
                 var max = elements[pixel.element].tempHigh;
                 var ratio = ((pixel.temp/max*100)|0)/100;
                 if (ratio < 0.2) { return }
@@ -618,6 +627,7 @@
             },
             WOODCHAR: function(pixel,ctx) {
                 drawDefault(ctx,pixel);
+                if (!viewInfo[view].colorEffects) { return }
                 var max = 400;
                 var ratio = ((pixel.temp/max*100)|0)/100;
                 if (ratio < 0.5) { return }
@@ -626,6 +636,7 @@
             },
             PLANTCHAR: function(pixel,ctx) {
                 drawDefault(ctx,pixel);
+                if (!viewInfo[view].colorEffects) { return }
                 var max = 80;
                 var ratio = ((pixel.temp/max*100)|0)/100;
                 if (ratio < 0.5) { return }
@@ -634,6 +645,7 @@
             },
             CHARCOALHEAT: function(pixel,ctx) {
                 drawDefault(ctx,pixel);
+                if (!viewInfo[view].colorEffects) { return }
                 var max = 1100;
                 var ratio = ((pixel.temp/max*100)|0)/100;
                 if (ratio < 0.4) { return }
@@ -644,7 +656,7 @@
                 if (!pixel.origColor && pixel.color.match(/^rgb/)) {
                     pixel.origColor = pixel.color.match(/\d+/g);
                 }
-                if (!pixel.origColor || view) {
+                if (!pixel.origColor || !viewInfo[view].effects) {
                     drawDefault(ctx,pixel);
                     return;
                 }
@@ -841,6 +853,7 @@
         "SW|DL%5|SW",
         "SW|SW|SW",
     ],
+    tool: function(pixel){},
     category: "tools",
     darkText: true,
     canPlace: false,
@@ -867,7 +880,7 @@
     canPlace: false,
     desc: "Use on a pixel to bring up its info screen."
 },
-"shock": { //hard-coded
+"shock": {
     color: "#ffff00",
     behavior: [
         "SH|SH|SH",
@@ -1006,6 +1019,7 @@
         "bee": { elem2:"dead_bug", chance:0.05, oneway:true },
         "stink_bug": { elem2:"dead_bug", chance:0.1, oneway:true },
         "cured_meat": { elem1:"salt_water", elem2:"meat" },
+        "water": { elem2:"bubble", attr2:{"clone":"water"}, chance:0.001, tempMin:85 },
         // electrolysis:
         "aluminum": { elem1:["hydrogen","hydrogen","oxygen"], charged:true, chance:0.0025 },
         "zinc": { elem1:["hydrogen","hydrogen","oxygen"], charged:true, chance:0.015 },
@@ -1059,6 +1073,7 @@
                 pixel.clone = "salt_water";
             }
         }},
+        "salt_water": { elem2:"bubble", attr2:{"clone":"salt_water"}, chance:0.001, tempMin:85 },
         // electrolysis:
         "aluminum": { elem1:["hydrogen","hydrogen","oxygen","chlorine"], charged:true, chance:0.0025 },
         "zinc": { elem1:["hydrogen","hydrogen","oxygen","chlorine"], charged:true, chance:0.015 },
@@ -1105,6 +1120,7 @@
         "bee": { elem2:"dead_bug", chance:0.05, oneway:true },
         "stink_bug": { elem2:"dead_bug", chance:0.1, oneway:true },
         "uranium": { elem1: "dirty_water", chance:0.25 },
+        "sugar_water": { elem2:"bubble", attr2:{"clone":"sugar_water"}, chance:0.001, tempMin:85 },
         // electrolysis:
         "aluminum": { elem1:["hydrogen","hydrogen","oxygen","sugar"], charged:true, chance:0.0025 },
         "zinc": { elem1:["hydrogen","hydrogen","oxygen","sugar"], charged:true, chance:0.015 },
@@ -1151,6 +1167,7 @@
         "algae": { elem1:"water" },
         "kelp": { elem1:"water" },
         "uranium": { elem1: "dirty_water", chance:0.25 },
+        "seltzer": { elem2:"bubble", attr2:{"clone":"seltzer"}, chance:0.001, tempMin:85 },
         // electrolysis:
         "aluminum": { elem1:["hydrogen","hydrogen","oxygen","carbon_dioxide"], charged:true, chance:0.0025 },
         "zinc": { elem1:["hydrogen","hydrogen","oxygen","carbon_dioxide"], charged:true, chance:0.015 },
@@ -1191,7 +1208,8 @@
         "fly": { elem2:"dead_bug", chance:0.1, oneway:true },
         "firefly": { elem2:"dead_bug", chance:0.1, oneway:true },
         "bee": { elem2:"dead_bug", chance:0.05, oneway:true },
-        "stink_bug": { elem2:"dead_bug", chance:0.1, oneway:true }
+        "stink_bug": { elem2:"dead_bug", chance:0.1, oneway:true },
+        "dirty_water": { elem2:"bubble", attr2:{"clone":"water"}, chance:0.001, tempMin:85 },
     },
     hidden: true,
     state: "liquid",
@@ -1246,6 +1264,7 @@
         "antibody": { elem2:null, chance:0.01 },
         "poison": { elem2:null, chance:0.01 },
         "charcoal": { elem1:"water", chance:0.02 },
+        "pool_water": { elem2:"bubble", attr2:{"clone":"pool_water"}, chance:0.001, tempMin:85 },
     },
     hidden: true,
     state: "liquid",
@@ -1301,6 +1320,9 @@
     },
     tempHigh: 100,
     stateHigh: "mudstone",
+    onStateHigh: function(pixel) {
+        releaseElement(pixel,"steam");
+    },
     tempLow: -50,
     stateLow: "permafrost",
     category: "land",
@@ -1318,6 +1340,9 @@
     },
     tempHigh: 100,
     stateHigh: "packed_sand",
+    onStateHigh: function(pixel) {
+        releaseElement(pixel,"steam");
+    },
     tempLow: -50,
     stateLow: "packed_sand",
     category: "land",
@@ -1523,8 +1548,8 @@
     reactions: {
         "wood": { elem1:"lichen" },
         "chlorine": { elem1:"dead_plant", elem2:null, chance:0.035 },
-        "liquid_chlorine": { elem1:"dead_plant", elem2:null, chance:0.035 },
         "baking_soda": { elem1:"dead_plant", elem2:null, chance:0.035 },
+        "bleach": { elem1:"dead_plant", elem2:null, chance:0.035 },
         "broth": { elem2:"water", chance:0.05 },
         "tea": { elem2:"water", chance:0.05 },
         "nitrogen": { elem2:"algae", chance:0.05 },
@@ -1568,6 +1593,12 @@
         behaviors.UL_UR_OPTIMIZED(pixel);
         if (!pixel.del && settings.burn===0 && (pixelTicks-pixel.start > 70) && Math.random() < 0.1 ) { changePixel(pixel,"smoke") }
     },
+    tool: function(pixel) {
+        if (pixel.temp >= elements.fire.temp) {return;}
+        pixel.temp += elements.fire.temp/(elements[pixel.element].extinguish ? 240 : 60);
+        pixelTempCheck(pixel);
+    },
+    canPlace: true,
     renderer: renderPresets.HUESHIFT,
     reactions: {
         "water": { elem1: "smoke" },
@@ -1808,6 +1839,12 @@
         "M2|CH:smoke%8|M2",
         "XX|M2|XX",
     ],
+    tool: function(pixel) {
+        if (pixel.temp <= elements.cold_fire.temp) {return;}
+        pixel.temp += elements.cold_fire.temp/(elements[pixel.element].extinguish ? 240 : 60);
+        pixelTempCheck(pixel);
+    },
+    canPlace: true,
     reactions: {
         "fire": { elem1: "smoke", elem2: "smoke" },
         "plasma": { elem1: "light", elem2: "light" },
@@ -1981,7 +2018,7 @@
     color: ["#ae7d5b","#9b6d54","#7e4d31"],
     behavior: behaviors.STURDYPOWDER,
     tick: function(pixel) {
-        if (pixel.temp > 100 && Math.random() < 0.0025 && isEmpty(pixel.x,pixel.y-1)) {
+        if (pixel.temp > 150 && Math.random() < 0.0025 && isEmpty(pixel.x,pixel.y-1)) {
             changePixel(pixel,"grease")
         }
     },
@@ -2164,6 +2201,9 @@
     tick: function(pixel) {
         changePixel(pixel,randomChoices[Math.floor(Math.random() * randomChoices.length)]);
     },
+    onPlace: function(pixel) {
+        changePixel(pixel,randomChoices[Math.floor(Math.random() * randomChoices.length)]);
+    },
     category: "special",
     excludeRandom: true
 },
@@ -2406,7 +2446,8 @@
     },
     category:"special",
     hardness: 1,
-    excludeRandom: true
+    excludeRandom: true,
+    movable: false
 },
 "sun": {
     color: "#ffffbd",
@@ -2713,7 +2754,41 @@
 },
 "ant": {
     color: "#5e0b04",
-    behavior: behaviors.CRAWLER,
+    behavior: function(pixel){
+        behaviors.CRAWLER2(pixel,function(pixel,newX,newY){
+    if (!pixel.hilled && !isEmpty(pixel.x+newX,pixel.y,true) && pixelMap[pixel.x+newX][pixel.y].element === "ant_wall") {
+        pixel.hilled = true;
+    }
+},function(pixel,newX,newY){
+    if (Math.random() < 0.01 && !isEmpty(pixel.x+newX,pixel.y+1,true) && eLists.CRAWLTHRU.indexOf(pixelMap[pixel.x+newX][pixel.y+1].element) !== -1) {
+        if (!pixel.hilled || !isEmpty(pixel.x+newX,pixel.y,true) && pixelMap[pixel.x+newX][pixel.y].element === "ant_wall") {
+            var wallCoords = [
+                [-1,-1],[1,-1],
+                [-1,0],[1,0],
+                [0,1]
+            ];
+            if (!isEmpty(pixel.x,pixel.y-2)) {
+                wallCoords.push([0,-1])
+            }
+            if (Math.random() < 0.15) { wallCoords.push([-1,1]) }
+            if (Math.random() < 0.15) { wallCoords.push([1,1]) }
+            // loop through wallCoords, change pixel to ant_wall if in crawlthru
+            for (var i = 0; i < wallCoords.length; i++) {
+                var x = pixel.x+newX+wallCoords[i][0];
+                var y = pixel.y+1+wallCoords[i][1];
+                if (!isEmpty(x,y,true) && eLists.CRAWLTHRU.indexOf(pixelMap[x][y].element) !== -1) {
+                    changePixel(pixelMap[x][y],"ant_wall");
+                }
+            }
+            deletePixel(pixel.x+newX,pixel.y+1);
+            tryMove(pixel,pixel.x+newX,pixel.y+1);
+        }
+    }
+    else if (Math.random() < 0.08 && !isEmpty(pixel.x+newX,pixel.y-1,true) && eLists.CRAWLTHRU.indexOf(pixelMap[pixel.x+newX][pixel.y-1].element) !== -1) {
+        swapPixels(pixel,pixelMap[pixel.x+newX][pixel.y-1]);
+    }
+})
+    },
     // behavior: [
     //     "XX|XX|SW:dirt,sand,gravel,clay_soil,mulch%8",
     //     "XX|FX%8|M2 AND BO",
@@ -2753,7 +2828,94 @@
     burnTime:25,
     state: "solid",
     density: 500,
-    conduct: 0.15
+    conduct: 0.05
+},
+"spider": {
+    color: "#4f2d2d",
+    behavior: function(pixel){
+        var webs = [];
+        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) && elements[pixelMap[x][y].element].id === elements.web.id) {
+                webs.push(pixelMap[x][y]);
+                if (pixel.web === undefined) { pixel.web = Math.floor(Math.random() * (5 - 1) + 1) }
+            }
+        }
+        if (webs.length) {
+            if (Math.random() < 0.1) {
+                var web = choose(webs);
+                shuffleArray(squareCoordsShuffle);
+                for (var i = 0; i < squareCoordsShuffle.length; i++) {
+                    var coord = squareCoordsShuffle[i];
+                    var x = web.x+coord[0];
+                    var y = web.y+coord[1];
+                    if (webs.length === 1 && coord[0] && coord[1] && isEmpty(x,y) && Math.random() < 0.1) {
+                        createPixel("web",x,y);
+                        break;
+                    }
+                    else if (tryMove(pixel,x,y)) { break }
+                }
+            }
+            doDefaults(pixel);
+        }
+        else {
+            behaviors.CRAWLER2(pixel,undefined,function(pixel){
+                if (pixel.r % 2 === 1 && pixel.climb > 10 && pixel.web === undefined && Math.random() < 0.1) {
+                    if (tryMove(pixel,pixel.x,pixel.y-1,"web")) {
+                        pixel.web = Math.floor(Math.random() * (50 - 10) + 10);
+                    }
+                }
+            });
+        }
+    },
+    foodNeed: 4,
+    reactions: {
+        "dead_bug": { elem2:null, chance:0.1, func:behaviors.FEEDPIXEL },
+        "bleach": { elem1:"dead_bug", chance:0.1 },
+        "alcohol": { elem1:"dead_bug", chance:0.05 },
+        "vinegar": { elem1:"dead_bug", chance:0.03 },
+    },
+    tempHigh: 100,
+    stateHigh: "ash",
+    tempLow: 0,
+    stateLow: "dead_bug",
+    breakInto: "dead_bug",
+    category:"life",
+    burn:95,
+    burnTime:25,
+    state: "solid",
+    density: 500,
+    conduct: 0.05,
+    cooldown: defaultCooldown
+},
+"web": {
+    color: ["#d7d9d1","#c0c3b6","#a8ac9a"],
+    behavior: behaviors.WALL,
+    reactions: {
+        "fly": { elem2:"dead_bug", chance:0.1 },
+        "flea": { elem2:"dead_bug", chance:0.1 },
+        "termite": { elem2:"dead_bug", chance:0.05 },
+        "ant": { elem2:"dead_bug", chance:0.05 },
+        "firefly": { elem2:"dead_bug", chance:0.1 },
+        "stink_bug": { elem2:["dead_bug","stench"], chance:0.035 },
+        "bee": { elem2:"dead_bug", chance:0.02 },
+        "bleach": { elem1:null, chance:0.1 },
+        "vinegar": { elem1:null, chance:0.05 },
+        "juice": { elem1:null, chance:0.03 },
+        "soap": { elem1:null, chance:0.2 },
+    },
+    tempHigh: 220,
+    stateHigh: "smoke",
+    burn: 15,
+    burnTime: 30,
+    burnInto: ["smoke","smoke","smoke","smoke","ash"],
+    category: "life",
+    state: "solid",
+    breakInto: [null,null,"dust"],
+    hidden: true
 },
 "fly": {
     color: "#4c4e42",
@@ -2839,6 +3001,72 @@
     density: 600,
     conduct: 0.15
 },
+"bee": {
+    color: "#c4b100",
+    tick: function(pixel) {
+        if (pixelTicks-pixel.lastP > 150 && pixel.pollen && Math.random() < 0.0005 && isEmpty(pixel.x,pixel.y+1)) {
+            createPixel("pollen",pixel.x,pixel.y+1);
+            pixelMap[pixel.x][pixel.y+1].seed = pixel.pollen;
+            pixel.pollen = undefined;
+        }
+        behaviors.FLY(pixel,function(bee,hitPixel){
+            if (hitPixel) {
+                if (elements[hitPixel.element].seed === true) {
+                    bee.pollen = hitPixel.element;
+                    bee.lastP = pixelTicks
+                }
+                else if (elements[hitPixel.element].seed) {
+                    bee.pollen = elements[hitPixel.element].seed;
+                    bee.lastP = pixelTicks
+                }
+                if (hitPixel.lastP && (bee.lastP === undefined || bee.lastP < hitPixel.lastP)) {
+                    bee.lastP = hitPixel.lastP
+                }
+                // BEE HIVE
+                if (bee.hive === undefined) {
+                    if (hitPixel.hive !== undefined) { bee.hive = hitPixel.hive }
+                    else if (Math.random() < 0.01 && eLists.HIVEPLACE.indexOf(hitPixel.element) !== -1) {
+                        bee.queen = true;
+                        bee.mats = Math.floor(Math.random() * 9) + 4; //from 3 to 10
+                        bee.hive = Math.floor(Math.random() * 256);
+                        deletePixel(bee.x,bee.y);
+                        createPixel("hive",bee.x,bee.y);
+                        pixelMap[bee.x][bee.y].hive = bee.hive;
+                        pixelMap[bee.x][bee.y].bees.push(bee);
+                        return;
+                    }
+                }
+                else if (hitPixel.element === "hive" && hitPixel.bees.length < 5 && Math.random() < 0.25) {
+                    deletePixel(bee.x,bee.y);
+                    hitPixel.bees.push(bee);
+                    return;
+                }
+            }
+        })
+    },
+    reactions: {
+        "sugar_water": { elem2:null, chance:0.25, func:behaviors.FEEDPIXEL },
+        "soda": { elem2:null, chance:0.25, func:behaviors.FEEDPIXEL },
+        "sugar": { elem2:null, chance:0.15, func:behaviors.FEEDPIXEL },
+        "honey": { elem2:null, chance:0.15, func:behaviors.FEEDPIXEL },
+        "yeast": { elem2:null, chance:0.15, func:behaviors.FEEDPIXEL },
+        "caramel": { elem2:null, chance:0.25, func:behaviors.FEEDPIXEL },
+        "candy": { elem2:null, chance:0.05, func:behaviors.FEEDPIXEL },
+        "oil": { elem1:"dead_bug", chance:0.2 },
+    },
+    egg: "honey",
+    tempHigh: 100,
+    stateHigh: "ash",
+    tempLow: 0,
+    stateLow: "dead_bug",
+    breakInto: ["dead_bug","honey"],
+    category:"life",
+    burn:95,
+    burnTime:25,
+    state: "solid",
+    density: 600,
+    conduct: 0.15
+},
 "hive": {
     color: "#a6a479",
     tick: function(pixel) {
@@ -2922,72 +3150,6 @@
     hidden: true,
     movable: false
 },
-"bee": {
-    color: "#c4b100",
-    tick: function(pixel) {
-        if (pixelTicks-pixel.lastP > 150 && pixel.pollen && Math.random() < 0.0005 && isEmpty(pixel.x,pixel.y+1)) {
-            createPixel("pollen",pixel.x,pixel.y+1);
-            pixelMap[pixel.x][pixel.y+1].seed = pixel.pollen;
-            pixel.pollen = undefined;
-        }
-        behaviors.FLY(pixel,function(bee,hitPixel){
-            if (hitPixel) {
-                if (elements[hitPixel.element].seed === true) {
-                    bee.pollen = hitPixel.element;
-                    bee.lastP = pixelTicks
-                }
-                else if (elements[hitPixel.element].seed) {
-                    bee.pollen = elements[hitPixel.element].seed;
-                    bee.lastP = pixelTicks
-                }
-                if (hitPixel.lastP && (bee.lastP === undefined || bee.lastP < hitPixel.lastP)) {
-                    bee.lastP = hitPixel.lastP
-                }
-                // BEE HIVE
-                if (bee.hive === undefined) {
-                    if (hitPixel.hive !== undefined) { bee.hive = hitPixel.hive }
-                    else if (Math.random() < 0.01 && eLists.HIVEPLACE.indexOf(hitPixel.element) !== -1) {
-                        bee.queen = true;
-                        bee.mats = Math.floor(Math.random() * 9) + 4; //from 3 to 10
-                        bee.hive = Math.floor(Math.random() * 256);
-                        deletePixel(bee.x,bee.y);
-                        createPixel("hive",bee.x,bee.y);
-                        pixelMap[bee.x][bee.y].hive = bee.hive;
-                        pixelMap[bee.x][bee.y].bees.push(bee);
-                        return;
-                    }
-                }
-                else if (hitPixel.element === "hive" && hitPixel.bees.length < 5 && Math.random() < 0.25) {
-                    deletePixel(bee.x,bee.y);
-                    hitPixel.bees.push(bee);
-                    return;
-                }
-            }
-        })
-    },
-    reactions: {
-        "sugar_water": { elem2:null, chance:0.25, func:behaviors.FEEDPIXEL },
-        "soda": { elem2:null, chance:0.25, func:behaviors.FEEDPIXEL },
-        "sugar": { elem2:null, chance:0.15, func:behaviors.FEEDPIXEL },
-        "honey": { elem2:null, chance:0.15, func:behaviors.FEEDPIXEL },
-        "yeast": { elem2:null, chance:0.15, func:behaviors.FEEDPIXEL },
-        "caramel": { elem2:null, chance:0.25, func:behaviors.FEEDPIXEL },
-        "candy": { elem2:null, chance:0.05, func:behaviors.FEEDPIXEL },
-        "oil": { elem1:"dead_bug", chance:0.2 },
-    },
-    egg: "honey",
-    tempHigh: 100,
-    stateHigh: "ash",
-    tempLow: 0,
-    stateLow: "dead_bug",
-    breakInto: ["dead_bug","honey"],
-    category:"life",
-    burn:95,
-    burnTime:25,
-    state: "solid",
-    density: 600,
-    conduct: 0.15
-},
 "stink_bug": {
     color: ["#56482d","#52472c","#635443"],
     properties: {
@@ -3049,7 +3211,20 @@
 },
 "dead_bug": {
     color: ["#38302a","#403732","#453a2e","#241d15","#242e23"],
-    behavior: behaviors.POWDER,
+    tick: function(pixel) {
+        var inWeb = false;
+        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) && elements[pixelMap[x][y].element].id === elements.web.id) {
+                inWeb = true;
+                break;
+            }
+        }
+        if (inWeb) { doDefaults(pixel); }
+        else { behaviors.POWDER(pixel); }
+    },
     reactions: {
         "water": { elem2:"foam", attr2:{"clone":"water"}, color2:"#e3d8ca", chance:0.001 },
         "salt_water": { elem2:"foam", attr2:{"clone":"salt_water"}, color2:"#e3d8ca", chance:0.001 }
@@ -3118,6 +3293,7 @@
         "egg": { elem2:"yolk", chance:0.5, oneway:true },
         "grape": { elem2:"juice", chance:0.5, color2:"#291824", oneway:true },
         "ant": { elem2:"dead_bug", chance:0.05, oneway:true },
+        "spider": { elem2:"dead_bug", oneway:true },
         "fly": { elem2:"dead_bug", oneway:true },
         "firefly": { elem2:"dead_bug", oneway:true },
         "bee": { elem2:"dead_bug", oneway:true },
@@ -3166,6 +3342,10 @@
             if (head.dead) { // If head is dead, kill body
                 pixel.dead = head.dead;
             }
+            else if (head.panic > 0) {
+                pixel.panic = head.panic;
+                delete head.panic;
+            }
         }
         else { var head = null }
         if (pixel.burning) {
@@ -3176,6 +3356,7 @@
         }
         else if (pixel.panic > 0) {
             pixel.panic -= 0.1;
+            if (pixel.panic < 0) { pixel.panic = 0; }
         }
 
         if (isEmpty(pixel.x, pixel.y-1)) {
@@ -3205,6 +3386,13 @@
                         break;
                     }
                 }
+                else if (!isEmpty(pixel.x+move[0], pixel.y+move[1], true)) {
+                    var hitPixel = pixelMap[pixel.x+move[0]][pixel.y+move[1]];
+                    if (hitPixel.element === "body" || hitPixel.element === "head" && hitPixel.panic < pixel.panic) {
+                        // interact with other human
+                        hitPixel.panic = pixel.panic;
+                    }
+                }
             }
             // 15% chance to change direction
             if (Math.random() < 0.15) {
@@ -3470,6 +3658,7 @@
         "tomato": { elem2:null, chance:0.1, func:behaviors.FEEDPIXEL },
         "sauce": { elem2:null, chance:0.3, func:behaviors.FEEDPIXEL },
         "plant": { elem2:null, chance:0.1, func:behaviors.FEEDPIXEL },
+        "vine": { elem2:null, chance:0.1, func:behaviors.FEEDPIXEL },
         "evergreen": { elem2:null, chance:0.1, func:behaviors.FEEDPIXEL },
         "algae": { elem2:null, chance:0.2, func:behaviors.FEEDPIXEL },
         "grass_seed": { elem2:null, chance:0.3 , func:behaviors.FEEDPIXEL},
@@ -3555,6 +3744,7 @@
         "snail": { elem2:"limestone", chance:0.05, func:behaviors.FEEDPIXEL },
         "slug": { elem2:null, chance:0.2, func:behaviors.FEEDPIXEL },
         "worm": { elem2:null, chance:0.2, func:behaviors.FEEDPIXEL },
+        "spider": { elem2:null, chance:0.2, func:behaviors.FEEDPIXEL },
         "algae": { elem2:null, chance:0.5, func:behaviors.FEEDPIXEL },
         "kelp": { elem2:"water", chance:0.5, func:behaviors.FEEDPIXEL },
         "oxygen": { elem2:"carbon_dioxide", chance:0.5 },
@@ -3640,6 +3830,7 @@
         "firefly": { elem2:null, chance:0.6, func:behaviors.FEEDPIXEL },
         "worm": { elem2:null, chance:0.25, func:behaviors.FEEDPIXEL },
         "tadpole": { elem2:null, chance:0.25, func:behaviors.FEEDPIXEL },
+        "spider": { elem2:null, chance:0.25, func:behaviors.FEEDPIXEL },
         "oxygen": { elem2:"carbon_dioxide", chance:0.5 },
         "dead_bug": { elem2:null, chance:0.2, func:behaviors.FEEDPIXEL },
         "broth": { elem2:"water", chance:0.2, func:behaviors.FEEDPIXEL },
@@ -7100,7 +7291,7 @@
     stateLow: "ice_cream",
     stateLowColorMultiplier: [0.97,0.93,0.87],
     tempHigh: 100,
-    stateHigh: ["smoke","smoke","smoke","quicklime"],
+    stateHigh: ["steam","bubble","cream","cream","sugar"],
     viscosity: 1.5,
     category: "liquids",
     state: "liquid",
@@ -7258,8 +7449,8 @@
         "sugar": { elem2:null, chance:0.005},
     },
     viscosity: 1.5,
-    tempHigh: 1000,
-    stateHigh: ["smoke","smoke","smoke","steam","steam","calcium"],
+    tempHigh: 200,
+    stateHigh: ["steam","bubble","sugar"],
     tempLow: 0,
     stateLow: "ice_cream",
     stateLowColorMultiplier: 0.97,
@@ -7514,6 +7705,7 @@
         "mushroom_gill": { elem2:null, chance:0.05 },
         "mushroom_cap": { elem2:null, chance:0.05 },
         "pollen": { elem2:null, chance:0.05 },
+        "caramel": { elem2:null, chance:0.01 },
         "salt": { elem1: null, elem2: "sodium_acetate", chance:0.05 },
         "lettuce": { elem2:"pickle", chance:0.01 },
         "egg": { elem2:"pickle", color2:"#e0e0ab", chance:0.01 },
@@ -7705,24 +7897,20 @@
 },
 "corn": {
     color: ["#f8d223","#d6ba2a","#f7f5ba","#dbd281","#cdb12d"],
-    tick: function(pixel) {
-        if (pixel.temp >= 180) {
-            changePixel(pixel,"popcorn");
-            if (isEmpty(pixel.x,pixel.y-1)) {
-                tryMove(pixel,pixel.x,pixel.y-1);
-                if (isEmpty(pixel.x-1,pixel.y)) { createPixel("pop",pixel.x-1,pixel.y) }
-                if (isEmpty(pixel.x+1,pixel.y)) { createPixel("pop",pixel.x+1,pixel.y) }
-                if (isEmpty(pixel.x,pixel.y-1)) { createPixel("pop",pixel.x,pixel.y-1) }
-                if (isEmpty(pixel.x,pixel.y+1)) { createPixel("pop",pixel.x,pixel.y+1) }
-            }
-        }
-        doDefaults(pixel)
-    },
+    behavior: behaviors.WALL,
     category: "food",
     burn: 10,
     burnTime: 200,
     breakInto: "flour",
     breakIntoColor: ["#ffe9a8","#ffecb3","#ffe28a"],
+    tempHigh: 180,
+    stateHigh: "popcorn",
+    onStateHigh: function(pixel) {
+        tryMove(pixel,pixel.x,pixel.y-1);
+        tryMove(pixel,pixel.x,pixel.y-1);
+        tryMove(pixel,pixel.x,pixel.y-1);
+        releaseElement(pixel,"pop",4);
+    },
     state: "solid",
     density: 721,
     seed: "corn_seed",
@@ -7900,6 +8088,7 @@
         "sugar_water": { elem2:"alcohol", chance:0.005, color2:"#80724d" },
         "soda": { elem2:"alcohol", chance:0.005, color2:"#80724d" },
         "corn": { elem2:"alcohol", chance:0.005, color2:"#b8b6a2" },
+        "rice": { elem2:"alcohol", chance:0.005, color2:"#ecc986" },
         "honey": { elem2:"alcohol", chance:0.005, color2:"#dccb72" },
         "molasses": { elem2:"alcohol", chance:0.005, color2:"#803924" },
         "herb": { elem2:"tea", chance:0.005 },
@@ -8511,6 +8700,7 @@
         "worm": { elem2: "dead_bug", chance:0.1 },
         "flea": { elem2: "dead_bug", chance:0.1 },
         "termite": { elem2: "dead_bug", chance:0.1 },
+        "spider": { elem2: "dead_bug", chance:0.1 },
         "stink_bug": { elem2: "dead_bug", chance:0.1 },
         "smog": { elem2: "cloud" },
         "water": { elem1: ["foam","bubble"], chance:0.005 },
@@ -8555,6 +8745,8 @@
         "pollen": { elem2:null, chance:0.1 },
         "antidote": { elem2:null, chance:0.1 },
         "porcelain": { stain2:"#b3967f" },
+        "porcelain_shard": { stain2:"#b3967f" },
+        "salt": { elem2:"foam", chance:0.001 },
     },
     tempHigh: 111,
     stateHigh: ["salt","steam"],
@@ -8618,7 +8810,8 @@
         "sugar_water": { elem1:null, chance:0.05 },
         "seltzer": { elem1:null, chance:0.05 },
         "dirty_water": { elem1:null, chance:0.05 },
-        "pool_water": { elem1:null, chance:0.05 }
+        "pool_water": { elem1:null, chance:0.05 },
+        "bleach": { elem1:null, elem2:null, chance:0.05 }
     },
     customColor: true,
     stain: 0.66,
@@ -8640,7 +8833,8 @@
         "seltzer": { elem1:null, chance:0.01 },
         "dirty_water": { elem1:null, chance:0.01 },
         "pool_water": { elem1:null, chance:0.01 },
-        "dye": { elem1:"dye", color1:"#171717" }
+        "dye": { elem1:"dye", color1:"#171717" },
+        "bleach": { elem1:null, elem2:null, chance:0.05 }
     },
     tool: function(pixel) {
         if (pixel.element === "paper") {
@@ -8833,6 +9027,7 @@
         "bee": { elem1:null, elem2:"dead_bug" },
         "stink_bug": { elem1:null, elem2:"dead_bug" },
         "termite": { elem1:null, elem2:"dead_bug" },
+        "spider": { elem1:null, elem2:"dead_bug" },
         "flea": { elem1:null, elem2:"dead_bug" },
         "slug": { elem1:null, elem2:"slime" },
         "snail": { elem1:null, elem2:"limestone" },
@@ -8984,6 +9179,7 @@
         "stinkbug": { elem1:"amber", elem2:null, chance:0.1 },
         "slug": { elem1:"amber", elem2:null, chance:0.1 },
         "snail": { elem1:"amber", elem2:null, chance:0.1 },
+        "spider": { elem1:"amber", elem2:null, chance:0.1 },
     },
     tempHigh: 103.05,
     stateHigh: ["sugar","smoke","smoke"],
@@ -9681,6 +9877,7 @@
     tempLow: 100,
     stateLow: "rain_cloud",
     state: "gas",
+    breakInto: "rain_cloud",
     density: 0.4,
     ignoreAir: true,
     conduct: 0.03
@@ -9701,6 +9898,7 @@
     temp: 70,
     tempHigh: 100,
     stateHigh: "cloud",
+    breakInto: "water",
     tempLow: 0,
     stateLow: "snow_cloud",
     state: "gas",
@@ -10062,7 +10260,7 @@
         if (elements.midas_touch.reactions[pixel.element]) { return; }
         if (Math.random() < (elements[pixel.element].hardness || 0.25)) { return; }
         if (elements[pixel.element].state === "liquid") {
-            changePixel(pixel,"midas_touch");
+            changePixel(pixel, (pixel.temp > 500 ? "molten_gold" : "midas_touch"));
         }
         else if (elements[pixel.element].state === "gas") {
             changePixel(pixel,"spray_paint");
@@ -10141,6 +10339,7 @@
         "bee": { elem2:["ash","firefly","fly","ant"], chance:0.4 },
         "firefly": { elem2:["ash","bee","fly"], chance:0.4 },
         "stink_bug": { elem2:"ash", chance:0.4 },
+        "spider": { elem2:"ash", chance:0.4 },
         "frog": { elem2:["ash","meat","rotten_meat","cooked_meat","tadpole"], chance:0.4 },
         "tadpole": { elem2:["frog","frog","worm",null], chance:0.4 },
         "fish": { elem2:["ash","meat","rotten_meat","cooked_meat"], chance:0.4 },
@@ -10331,7 +10530,8 @@
     state: "solid",
     density: 5250,
     conduct: 0.37,
-    hardness: 0.3
+    hardness: 0.3,
+    alias: "iron oxide"
 },
 "oxidized_copper": {
     color: ["#406555","#42564a","#517364"],
@@ -10343,6 +10543,7 @@
     hidden: true,
     tempHigh: 1085,
     stateHigh: "molten_copper",
+    state: "solid",
     density: 8960,
     conduct: 0.85,
     hardness: 0.2,
@@ -10838,6 +11039,7 @@
         "ruins": { elem2:"rock_wall" },
         "warp": { elem2:null },
         "midas_touch": { elem2:null },
+        "web": { elem2:null },
     },
     temp:20,
     state: "gas",
@@ -11831,7 +12033,7 @@
                 }
             }
             if (!tryMove(pixel,pixel.x,pixel.y+1,["flash","heat_ray","electric"]) && !skip) {
-                explodeAt(pixel.x,pixel.y,20,"plasma");
+                explodeAt(pixel.x,pixel.y,20,["plasma","heat_ray","flash"]);
                 var coords = circleCoords(pixel.x,pixel.y,15);
                 coords.forEach(function(coord){
                     var x = coord.x;
@@ -11918,7 +12120,8 @@
     color: "#8a8a84",
     tick: function(pixel) {
         if (!isEmpty(pixel.x, pixel.y-1, true)){
-            if (pixelMap[pixel.x][pixel.y-1].element != "pressure_plate" || pixelMap[pixel.x][pixel.y-1].on) {
+            if (pixel.min && elements[pixelMap[pixel.x][pixel.y-1].element].density < pixel.min) {}
+            else if (pixelMap[pixel.x][pixel.y-1].element != "pressure_plate" || pixelMap[pixel.x][pixel.y-1].on) {
                 pixel.on = true;
                 var coordsToShock = [
                     [pixel.x, pixel.y+1],
@@ -11941,8 +12144,11 @@
             pixel.on = false;
         }
         tryMove(pixel, pixel.x, pixel.y+1);
+        doDefaults(pixel);
     },
-    category: "machines"
+    category: "machines",
+    state: "solid",
+    density: 7850
 },
 "primordial_soup": {
     color: ["#501f24","#6d2e1d"],
@@ -11993,7 +12199,7 @@
     stain: -0.1
 },
 "molten_slag": {
-    ignore: ["salt","plastic","sulfur","epsom_salt","potassium_salt","borax","solder","ash","dirt","tuff"]
+    ignore: ["salt","plastic","sulfur","epsom_salt","potassium_salt","borax","solder","ash","dirt","tuff","thermite","molten_thermite"]
 },
 "molten_dirt": {
     stateLow: ["mudstone","mudstone","mudstone","mudstone","mudstone","mudstone","mudstone","mudstone","mudstone","mudstone","mudstone","mudstone","rock"]
@@ -12076,8 +12282,23 @@
 
 };
 var currentMonth = new Date().getMonth();
-if (currentMonth == 9) { // October
+if (window.location.href.includes("holiday=false")) {}
+else if (currentMonth == 9) { // October
     elements.pumpkin_seed.hidden = false;
+    var script = document.createElement('script');
+    script.src = "mods/souls.js"
+    document.head.appendChild(script);
+    if (new Date().getDate() >= 30) {
+        elements.body.color = "#bf5c00";
+    }
+    elements.candy.colorPattern = [
+        "W","W","W","W","W",
+        "O","O","O","O","O",
+        "Y","Y","Y","Y","Y",
+    ]
+    elements.candy.colorKey = {"W":"#ffffff", "Y":"#ffcd55", "O":"#ff9933"}
+    elements.candy.color = ["#ffffff","#ffffff","#ff9933","#ff9933","#ffcd55","#ffcd55"]
+    elements.candy.breakIntoColor = ["#ffffff","#ffcd55","#ff9933"]
 }
 else if (currentMonth == 11) { // December
     elements.candy.colorPattern = [
@@ -12474,7 +12695,7 @@ if (langCode) {
                 element = element[Math.floor(Math.random()*element.length)];
             }
             currentPixels.push(new Pixel(x, y, element));
-            if (currentPixels.length > maxPixelCount) {
+            if (currentPixels.length > maxPixelCount || !element) {
                 currentPixels[currentPixels.length-1].del = true;
             }
             else if (elements[element] && elements[element].onPlace !== undefined) {
@@ -12506,6 +12727,7 @@ if (langCode) {
         }
 
         function changePixel(pixel,element,changetemp=true) {
+            if (!element) { return }
             if (elements[pixel.element].onChange !== undefined) {
                 elements[pixel.element].onChange(pixel,element);
             }
@@ -12527,6 +12749,7 @@ if (langCode) {
             }
             delete pixel.origColor; // remove stain
             delete pixel.clone;
+            delete pixel.glow;
             if (pixel.r && !elementInfo.rotatable) {
                 delete pixel.r;
             }
@@ -12653,6 +12876,18 @@ if (langCode) {
             if (r.func) { r.func(pixel1,pixel2); }
             return r.elem1!==undefined || r.elem2!==undefined;
         }
+        function releaseElement(pixel,element,count=1) {
+            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)) {
+                    createPixel(element,x,y);
+                    count--;
+                    if (count <= 0) { break; }
+                }
+            }
+        }
 
         loadedSounds = {};
         function playSound(sound) {
@@ -13337,7 +13572,15 @@ behaviorRules = {
                     tryMove(pixelMap[coord1.x][coord1.y],coord2.x,coord2.y);
                 }
                 else if (exists1 && exists2) {
-                    swapPixels(pixelMap[coord1.x][coord1.y],pixelMap[coord2.x][coord2.y]);
+                    var pixel1 = pixelMap[coord1.x][coord1.y];
+                    var pixel2 = pixelMap[coord2.x][coord2.y];
+                    swapPixels(pixel1,pixel2);
+                    if (elements[pixel1.element].onMix) {
+                        elements[pixel1.element].onMix(pixel1,pixel2);
+                    }
+                    if (elements[pixel2.element].onMix) {
+                        elements[pixel2.element].onMix(pixel2,pixel1);
+                    }
                 }
             }
         }
@@ -13725,8 +13968,9 @@ behaviorRules = {
                 if (result === null) {deletePixel(pixel.x,pixel.y);return false}
                 else {
                     if (elements[result].customColor) {
+                        var tempColor = pixel.color;
                         changePixel(pixel,result,false);
-                        pixel.color = color;
+                        pixel.color = tempColor;
                     }
                     else if (elementInfo.stateHighColor) {
                         changePixel(pixel,result,false);
@@ -13753,6 +13997,9 @@ behaviorRules = {
                     if (elementInfo.fireColor && result==="fire") {
                         pixel.color = pixelColorPick(pixel,elementInfo.fireColor);
                     }
+                    if (elementInfo.onStateHigh) {
+                        elementInfo.onStateHigh(pixel);
+                    }
                 }
             }
             // If the pixel's temp <= the elementInfo tempLow, change pixel.element to elementInfo.stateLow
@@ -13772,8 +14019,9 @@ behaviorRules = {
                 if (result === null) {deletePixel(pixel.x,pixel.y);return false}
                 else {
                     if (elements[result].customColor) {
+                        var tempColor = pixel.color;
                         changePixel(pixel,result,false);
-                        pixel.color = color;
+                        pixel.color = tempColor;
                     }
                     else if (elementInfo.stateLowColor) {
                         changePixel(pixel,result,false);
@@ -13797,6 +14045,9 @@ behaviorRules = {
                         pixel.color = "rgb("+r+","+g+","+b+")";
                     }
                     else { changePixel(pixel,result,false); }
+                    if (elementInfo.onStateLow) {
+                        elementInfo.onStateLow(pixel);
+                    }
                 }
             }
             return true;
@@ -14055,6 +14306,9 @@ behaviorRules = {
             else if (version > saveVersion) {
                 alert("This save was made in a newer version of Sandboxels, and may not load correctly. Please use the latest version.")
             }
+            if (saveConfig.height*saveConfig.width >= 1000000) {
+                if (!confirm("This save is very large. Are you sure you want to load it?")) { return }
+            }
             resizeCanvas(saveConfig.height*savePixelSize+savePixelSize,saveConfig.width*savePixelSize+savePixelSize,savePixelSize);
             clearAll(true);
             tempSettings = JSON.stringify(settings);
@@ -14273,8 +14527,8 @@ behaviorRules = {
             [-1,0]
         ];
         squareCoords = [
-            [0,1],
             [0,-1],
+            [0,1],
             [1,0],
             [-1,0],
             [1,1],
@@ -14392,9 +14646,11 @@ behaviorRules = {
         viewInfo = {
             1: { // Normal View (Default)
                 name: "",
+                effects: true,
+                colorEffects: true,
                 pixel: function(pixel,ctx) {
                     var a = (settings.textures !== 0) ? pixel.alpha : undefined;
-                    if ((elements[pixel.element].isGas && elements[pixel.element].glow !== false) || elements[pixel.element].glow || pixel.glow) {
+                    if (((elements[pixel.element].isGas && elements[pixel.element].glow !== false) || elements[pixel.element].glow || pixel.glow) && pixel.glow !== false) {
                         drawPlus(ctx,pixel.color,pixel.x,pixel.y,undefined,a)
                         // if (isEmpty(pixel.x+1,pixel.y) || isEmpty(pixel.x-1,pixel.y) || isEmpty(pixel.x,pixel.y+1) || isEmpty(pixel.x,pixel.y-1)) {}
                     }
@@ -14423,6 +14679,7 @@ behaviorRules = {
             },
             3: { // Basic View
                 name: "basic",
+                colorEffects: true,
                 pixel: function(pixel,ctx) {
                     drawSquare(ctx,pixel.color,pixel.x,pixel.y)
                     if (pixel.charge && view !== 2) { // Yellow glow on charge
@@ -14437,12 +14694,11 @@ behaviorRules = {
             return n*pixelSize;
         }
         function drawDefault(ctx,pixel) {
-            let viewN = view;
-            if (!viewInfo[viewN]) {
-                viewN = 1;
+            if (!viewInfo[view]) {
+                setView(1);
             }
-            if (viewInfo[viewN].pixel) {
-                viewInfo[viewN].pixel(pixel,ctx)
+            if (viewInfo[view].pixel) {
+                viewInfo[view].pixel(pixel,ctx)
             }
         }
         function drawSquare(ctx,color,x,y,scale=1,opacity=1) {
@@ -14481,19 +14737,18 @@ behaviorRules = {
             // Draw the current pixels
             if (!hiding) {
                 let pixelDrawList = pixelsFirst.concat(pixelsLast);
-                let viewN = view;
-                if (!viewInfo[viewN]) {
-                    viewN = 1;
+                if (!viewInfo[view]) {
+                    setView(1);
                 }
                 if (renderPrePixelList.length) {
                     for (let i = 0; i < renderPrePixelList.length; i++) {
                         renderPrePixelList[i](ctx);
                     }
                 }
-                if (viewInfo[viewN].pre) {
-                    viewInfo[viewN].pre(ctx);
+                if (viewInfo[view].pre) {
+                    viewInfo[view].pre(ctx);
                 }
-                if (viewInfo[viewN].pixel) {
+                if (viewInfo[view].pixel) {
                     for (let i = 0; i < pixelDrawList.length; i++) {
                         let pixel = pixelDrawList[i];
                         if (pixelMap[pixel.x][pixel.y] == undefined) {continue}
@@ -14502,7 +14757,7 @@ behaviorRules = {
                             elements[pixel.element].renderer(pixel,ctx);
                         }
                         else {
-                            viewInfo[viewN].pixel(pixel,ctx);
+                            viewInfo[view].pixel(pixel,ctx);
                         }
                         if (renderEachPixelList.length) {
                             for (let i = 0; i < renderEachPixelList.length; i++) {
@@ -14516,8 +14771,8 @@ behaviorRules = {
                         renderPostPixelList[i](ctx);
                     }
                 }
-                if (viewInfo[viewN].post) {
-                    viewInfo[viewN].post(ctx);
+                if (viewInfo[view].post) {
+                    viewInfo[view].post(ctx);
                 }
             }
             if (ctx.globalAlpha < 1) {
@@ -14644,7 +14899,7 @@ behaviorRules = {
             ctx.drawImage(placingImage,0,0,newWidth,newHeight);
             var newImage = ctx.getImageData(0,0,newWidth,newHeight);
             var elem = (settings.imageelem || "wood");
-            if (!elements[elem] || elements[elem].tool || elements[elem].canPlace===false) { elem = "wood";}
+            if ((!elements[elem] || elements[elem].tool || elements[elem].canPlace===false) && elem !== "paint") { elem = "wood";}
             // loop through each pixel in the ImageData
             for (var x = 0; x < newWidth; x++) {
                 for (var y = 0; y < newHeight; y++) {
@@ -14658,11 +14913,17 @@ behaviorRules = {
                         var pixelX = (placementX||mousePos.x) - Math.round(newWidth/2) + x+1;
                         var pixelY = (placementY||mousePos.y) - Math.round(newHeight/2) + y+1;
                         if (isEmpty(pixelX,pixelY)) {
+                            if (elem === "paint") { continue }
                             createPixel(elem,pixelX,pixelY);
                             pixelMap[pixelX][pixelY].color = pixelColorPick(pixelMap[pixelX][pixelY], RGBToHex([r,g,b]));
                         }
-                        else if (!outOfBounds(pixelX,pixelY) && (shiftDown || mode === "replace")) {
-                            changePixel(pixelMap[pixelX][pixelY],elem);
+                        else if (!outOfBounds(pixelX,pixelY)) {
+                            if (shiftDown || mode === "replace") {
+                                changePixel(pixelMap[pixelX][pixelY],elem);
+                            }
+                            else if (elem !== "paint") {
+                                continue;
+                            }
                             pixelMap[pixelX][pixelY].color = pixelColorPick(pixelMap[pixelX][pixelY], RGBToHex([r,g,b]));
                         }
                     }
@@ -14795,11 +15056,6 @@ behaviorRules = {
                     }
                     continue;
                 }
-                else if (currentElement === "random" && isEmpty(x, y)) {
-                    // create pixel with random element from "randomChoices" array
-                    createPixel(randomChoices[Math.floor(Math.random() * randomChoices.length)],x,y);
-                    continue;
-                }
                 else if (elements[currentElement].tool && !(elements[currentElement].canPlace && isEmpty(x,y))) {
                     // run the tool function on the pixel
                     if (!isEmpty(x,y,true)) {
@@ -14877,13 +15133,13 @@ behaviorRules = {
             if (currentElement === "pick" || currentElement === "lookup") {
                 var coords = [[mouseX,mouseY]];
             }
-            else if (!isMobile) {
+            else {
                 startPos = startPos || lastPos
                 var coords = lineCoords(startPos.x,startPos.y,mouseX,mouseY);
             }
-            else {
-                var coords = mouseRange(mouseX,mouseY);
-            }
+            // else {
+            //     var coords = mouseRange(mouseX,mouseY);
+            // }
             // For each x,y in coords
             var done = {};
             for (var i = 0; i < coords.length; i++) {
@@ -15060,8 +15316,8 @@ behaviorRules = {
             categoryButton.setAttribute("current", true);
         }
         function setView(n) {
-            if (!viewInfo[n] || n === 1) { // reset view
-                view = null;
+            if (!viewInfo[n]) { // reset view
+                view = 1;
             }
             else {
                 view = n;
@@ -15109,6 +15365,9 @@ behaviorRules = {
                     button.className += " bright"
                 }
             }
+            if (elements[element].buttonGlow) {
+                button.style.boxShadow = "0px 0px 20px "+elements[element].buttonGlow
+            }
             button.id = "elementButton-" + element;
             button.onclick = handleElementButtonClick;
             // on right click, show the element's info
@@ -15542,7 +15801,7 @@ behaviorRules = {
         }
         randomEventChoices = {
             "falling_pixel": ["fireball","fallout","seeds",["bomb","cold_bomb"],"human","gold_coin","feather","glitter","homunculus","egg","frozen_frog","sapling","smoke_grenade","party_popper","lightning","frozen_worm","pinecone","cactus","earthquake","tornado"],
-            "element_circle": ["carbon_dioxide","primordial_soup","fly","steam","oxygen","sugar","bee","firefly","tadpole","flash","foam","bless","liquid_light"],
+            "element_circle": ["carbon_dioxide","primordial_soup","fly","steam","oxygen","sugar","bee","firefly","tadpole","flash","foam","bless","liquid_light","spider"],
             "explosion": ["fire","cold_fire","methane","electric","light","laser","radiation","plasma","liquid_nitrogen","liquid_helium","liquid_neon","acid_gas","fw_ember","malware",["stench","plague"],["firework","fire","fire"],"bubble","confetti","balloon","dye","bless"]
         }
         function doRandomEvents() {
@@ -15574,19 +15833,19 @@ behaviorRules = {
                     stats += "<span id='stat-element' class='stat'>Elem:"+(elements[currentPixel.element].name || currentPixel.element).toUpperCase()+"</span>";
                     stats += "<span id='stat-temperature' class='stat'>Temp:"+formatTemp(currentPixel.temp)+"</span>";
                     if (currentPixel.charge) {
-                        stats += "<span id='stat-charge' class='stat'>C"+currentPixel.charge+"</span>";
+                        stats += "<span id='stat-charge' class='stat'>C"+parseFloat(currentPixel.charge)+"</span>";
                     }
                     if (currentPixel.burning) {
                         stats += "<span id='stat-burning' class='stat'>Burning</span>";
                     }
                     if (elements[currentPixel.element].hoverStat) {
-                        stats += "<span id='stat-hover' class='stat'>"+elements[currentPixel.element].hoverStat(currentPixel).replaceAll("<","&lt;")+"</span>";
+                        stats += "<span id='stat-hover' class='stat'>"+elements[currentPixel.element].hoverStat(currentPixel).toString().replaceAll("<","&lt;")+"</span>";
                     }
                     else if (currentPixel.clone) {
-                        stats += "<span id='stat-clone' class='stat'>"+currentPixel.clone.toUpperCase().replaceAll("<","&lt;")+"</span>";
+                        stats += "<span id='stat-clone' class='stat'>"+currentPixel.clone.toString().toUpperCase().replaceAll("<","&lt;")+"</span>";
                     }
                     else if (currentPixel.con && currentPixel.con.element) {
-                        stats += "<span id='stat-clone' class='stat'>"+currentPixel.con.element.toUpperCase().replaceAll("<","&lt;")+"</span>";
+                        stats += "<span id='stat-clone' class='stat'>"+currentPixel.con.element.toString().toUpperCase().replaceAll("<","&lt;")+"</span>";
                     }
                 }
             }
@@ -16005,7 +16264,7 @@ for (var k = 0; k < b0.split(" AND ").length; k++) {
         function addMod(url,noMessage) {
             // remove trailing slashes
             while (url.charAt(url.length-1) == "/") { url = url.substring(0, url.length-1); }
-            url = url.replaceAll(/['‘’“”"\$\{\}]/g,"");
+            url = url.replaceAll(/['‘’“”"\$\{\}\\]/g,"");
             // if the mod is in enabledMods, return
             for (var i = 0; i < enabledMods.length; i++) {
                 if (enabledMods[i] == url) { return; }
@@ -16236,7 +16495,7 @@ for (var k = 0; k < b0.split(" AND ").length; k++) {
         pixelTicks = 0;
 
         mode = null;
-        view = null;
+        view = 1;
         if (settings.view) {
             setView(settings.view)
         }
diff --git a/mod-list.html b/mod-list.html
index 94d9da34..8394f817 100644
--- a/mod-list.html
+++ b/mod-list.html
@@ -128,6 +128,7 @@
 <tr><td>fools.js</td><td>Adds back FOOLS Mode</td><td><a href="https://R74n.com" class="R74nLink">R74n</a></td></tr>
 <tr><td>fools24.js</td><td>Adds back the 2024 Multiversal Update (v5.9.1)</td><td><a href="https://R74n.com" class="R74nLink">R74n</a></td></tr>
 <tr><td>smooth_water.js</td><td>Changes water mechanics so that it flows in one direction until it bounces off of something</td><td><a href="https://R74n.com" class="R74nLink">R74n</a></td></tr>
+<tr><td>souls.js</td><td>Adds Human Souls, Ectoplasm, and Tombstones</td><td><a href="https://R74n.com" class="R74nLink">R74n</a></td></tr>
 <tr><td>spring.js</td><td>Many nature elements, like sakura trees, butterflies, beehives, and more</td><td><a href="https://R74n.com" class="R74nLink">R74n</a></td></tr>
 <tr><td>survival.js</td><td>With limited resources, you must craft, sell, and buy to progress</td><td><a href="https://R74n.com" class="R74nLink">R74n</a></td></tr>
 <tr><td>velocity.js</td><td>Beta for explosion velocity, and later wind, which may come to the base game in the future</td><td><a href="https://R74n.com" class="R74nLink">R74n</a></td></tr>
diff --git a/mods/lighting_test.js b/mods/lighting_test.js
new file mode 100644
index 00000000..522eb76f
--- /dev/null
+++ b/mods/lighting_test.js
@@ -0,0 +1,79 @@
+lightCoordsLevel1 = [
+[-1,-3],[0,-3],[1,-3],
+[-2,-2],[2,-2],
+[-3,-1],[3,-1],
+[-3,-0],[3,-0],
+[-3,1],[3,1],
+[-2,2],[2,2],
+[-1,3],[0,3],[1,3],
+]
+
+lightCoordsLevel2 = [
+[-1,-2],[0,-2],[1,-2],
+[-2,-1],[2,-1],
+[-2,0],[2,0],
+[-2,1],[2,1],
+[-1,2],[0,2],[1,2],
+]
+
+lightCoordsLevel3 = [
+[-1,-1],[1,-1],
+[-1,1],[1,1],
+]
+
+lightCoordsLevel3Extra = [
+[1,0],[-1,0],[0,1],[0,-1]
+]
+
+glowAmount = 2;
+
+viewInfo[4] = {
+    name: "lighting",
+    effects: true,
+    colorEffects: true,
+    pixel: viewInfo[1].pixel,
+    pre: function(ctx){
+        const pixelSize3 = pixelSize*3;
+        const pixelSize7 = pixelSize*7
+        const pixelSize5 = pixelSize*5
+        ctx.globalAlpha = 0.1;
+        for (let i = 0; i < currentPixels.length; i++) {
+            const pixel = currentPixels[i];
+            if (elements[pixel.element].id === elements.fire.id) {
+                ctx.fillStyle = pixel.color;
+                /* no occulusion: */
+                ctx.fillRect(canvasCoord(pixel.x-1), canvasCoord(pixel.y-3), pixelSize3, pixelSize7);
+                if (!isEmpty(pixel.x,pixel.y+1) && !isEmpty(pixel.x,pixel.y-1)) {
+                    continue;
+                }
+                ctx.fillRect(canvasCoord(pixel.x-3), canvasCoord(pixel.y-1), pixelSize7, pixelSize3);
+                if (!isEmpty(pixel.x+1,pixel.y) && !isEmpty(pixel.x-1,pixel.y)) {
+                    continue;
+                }
+                ctx.fillRect(canvasCoord(pixel.x-2), canvasCoord(pixel.y-2), pixelSize5, pixelSize5);
+                // ctx.globalAlpha = 0.1;
+                // lightCoordsLevel1.forEach(coords => {
+                //     let x = pixel.x+coords[0]; let y = pixel.y+coords[1];
+                //     if (!outOfBounds(x,y) && pixelMap[pixel.x+coords[0]][pixel.y+coords[1]] === undefined) {
+                //         ctx.fillRect(x*pixelSize, y*pixelSize, pixelSize, pixelSize);
+                //     }
+                // });
+                // ctx.globalAlpha = 0.2;
+                // lightCoordsLevel2.forEach(coords => {
+                //     let x = pixel.x+coords[0]; let y = pixel.y+coords[1];
+                //     if (!outOfBounds(x,y) && pixelMap[pixel.x+coords[0]][pixel.y+coords[1]] === undefined) {
+                //         ctx.fillRect(x*pixelSize, y*pixelSize, pixelSize, pixelSize);
+                //     }
+                // });
+                // ctx.globalAlpha = 0.3;
+                // lightCoordsLevel3.forEach(coords => {
+                //     let x = pixel.x+coords[0]; let y = pixel.y+coords[1];
+                //     if (!outOfBounds(x,y) && pixelMap[pixel.x+coords[0]][pixel.y+coords[1]] === undefined) {
+                //         ctx.fillRect(x*pixelSize, y*pixelSize, pixelSize, pixelSize);
+                //     }
+                // });
+            }
+        }
+        ctx.globalAlpha = 1;
+    }
+}
\ No newline at end of file
diff --git a/mods/souls.js b/mods/souls.js
new file mode 100644
index 00000000..6b0e79d9
--- /dev/null
+++ b/mods/souls.js
@@ -0,0 +1,144 @@
+elements.soul = {
+    color: "#87fff9",
+    tick: function(pixel) {
+        if (pixel.y <= 1) { deletePixel(pixel.x,pixel.y); return; }
+        if (Math.random() < 0.05) {
+            if (!tryMove(pixel,pixel.x,pixel.y-1)) {
+                if (!isEmpty(pixel.x,pixel.y-1,true)) {
+                    var hitPixel = pixelMap[pixel.x][pixel.y-1];
+                    if (elements[hitPixel.element].movable) {
+                        swapPixels(pixel,hitPixel);
+                    }
+                }
+            }
+        }
+        var dir = pixel.flipX ? -1 : 1;
+        if (!pixel.stage) {
+            if (Math.random() < 0.25) {
+                if (!tryMove(pixel,pixel.x+dir,pixel.y-( Math.random() < 0.33 ? 1 : 0 ))) {
+                    pixel.flipX = !pixel.flipX;
+                }
+                if (Math.random() < 0.1) {
+                    pixel.stage = 1;
+                    pixel.flipX = Math.random() < 0.5;
+                }
+            }
+        }
+        else if (pixel.stage === 1) {
+            if (!tryMove(pixel,pixel.x+dir,pixel.y+1)) { pixel.flipX = !pixel.flipX; }
+            if (Math.random() < 0.25) {
+                pixel.stage = 2;
+                pixel.flipX = Math.random() < 0.5;
+            }
+        }
+        else if (pixel.stage === 2) {
+            if (Math.random() < 0.25) {
+                var dirX = Math.floor(Math.random() * (2 - -1) + -1);
+                var dirY = Math.floor(Math.random() * (2 - -1) + -1);
+                tryMove(pixel,pixel.x+dirX,pixel.y+dirY);
+            }
+            if (Math.random() < 0.01) {
+                pixel.stage = 0;
+                pixel.flipX = Math.random() < 0.5;
+            }
+        }
+        if (!pixel.glow) {
+            if (Math.random() < 0.25) { pixel.glow = true; }
+        }
+        else if (Math.random() < 0.01) {
+            pixel.glow = false;
+        }
+        if (Math.random() < 0.0002 && isEmpty(pixel.x,pixel.y+1)) {
+            createPixel("ectoplasm",pixel.x,pixel.y+1);
+        }
+        if (Math.random() < 0.001) {
+            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)) {
+                    createPixel("flash",x,y);
+                    pixelMap[x][y].temp = -10;
+                }
+            }
+        }
+        doDefaults(pixel);
+    },
+    reactions: {
+        "light_bulb": { charged:true, elem2:"explosion" },
+        "led_r": { charged:true, elem2:"explosion" },
+        "led_g": { charged:true, elem2:"explosion" },
+        "led_b": { charged:true, elem2:"explosion" },
+        "wire": { charge2:1, chance:0.05 },
+        "body": { attr2:{"panic":20} },
+        "proton": { elem1:null },
+    },
+    temp: -10,
+    hardness: 100,
+    flippableX: true,
+    glow: true,
+    state: "gas",
+    density: 1000,
+    ignoreAir: true,
+    category: "life",
+    insulate: true,
+    hidden: true
+}
+
+elements.ectoplasm = {
+    color: ["#ADF9E7","#c1fbed"],
+    behavior: behaviors.LIQUID,
+    tick: function(pixel) {
+        if (pixel.temp >= -10 && Math.random() < 0.01 && pixelTicks-pixel.start > 100) {
+            deletePixel(pixel.x,pixel.y)
+        }
+    },
+    reactions: {
+        "body": { attr2:{"panic":20} }
+    },
+    temp: -10,
+    category: "liquids",
+    state: "liquid",
+    density: 0.0001,
+    ignoreAir: true,
+    insulate: true,
+    viscosity: 1666,
+    hardness: 100,
+    hidden: true
+}
+
+elements.head.breakInto = "soul";
+elements.head.burnInto = "soul";
+elements.head.stateHigh = "soul";
+elements.head.stateLow = "soul";
+elements.head.onDelete = function(pixel) {
+    releaseElement(pixel,"soul");
+}
+elements.head.onChange = function(pixel,element) {
+    if (element !== "soul") {
+        releaseElement(pixel,"soul");
+    }
+}
+
+elements.bless.reactions.soul = { elem2:"human" }
+elements.bless.reactions.ectoplasm = { elem2:null }
+
+elements.tombstone = {
+    color: ["#5f5f5f","#434343","#282828"],
+    behavior: [
+        "XX|CR:soul%0.01|XX",
+        "CR:soul%0.01|XX|CR:soul%0.01",
+        "XX|XX|XX",
+    ],
+    category:"special",
+    tempHigh: 950,
+    stateHigh: "magma",
+    state: "solid",
+    density: 2550,
+    hardness: 0.5,
+    breakInto: ["rock","rock","rock","rock","soul","ectoplasm"],
+    onStateHigh: function(pixel) {
+        releaseElement(pixel,"soul");
+    },
+    buttonGlow: "#87fff9"
+}
\ No newline at end of file