studyup 0.0.0-stage → 1.0.0

package/sandboxels-package/sandboxels-1.13.2/mods/randomness_but_tool.js

@@ -0,0 +1,26 @@
+elements.burn = {
+	color: ["#FF6B21", "#FFA600", "#FF4000"],
+	tool: function(pixel) {
+		pixel.burnStart = pixelTicks;
+		pixel.burning = true;
+	},
+	category: "tools",
+	excludeRandom: true,
+};
+
+elements.cursed_shock = {
+	color: ["#ffff00", "#00ff00", "#ffff00", "#00ff00", "#ffff00", "#00ff00", "#ffff00", "#00ff00"],
+	tool: function(pixel) {
+		if(pixel.chargeCD) {
+			delete pixel.chargeCD;
+		};
+		if (!pixel.charge) {
+			pixel.charge = 1;
+			if (elements[pixel.element].colorOn) {
+				pixel.color = pixelColorPick(pixel);
+			};
+		};
+	},
+	category: "tools",
+	excludeRandom: true,
+};

package/sandboxels-package/sandboxels-1.13.2/mods/ray_cloner.js

@@ -0,0 +1,150 @@
+var modName = "mods/ray_cloner.js";
+var libraryMod = "mods/code_library.js";
+var propMod = "mods/prop.js";
+var variablesMod = "mods/prop and prompt variables.js";
+if(enabledMods.includes(libraryMod) && enabledMods.includes(propMod) && enabledMods.includes(variablesMod)) {
+	function placeRegularlySpacedPixels(element,startX,startY,xSpacing,ySpacing,overwrite=false,stopAt=null,rayIgnore=[],spawnTemp=null,limit=1000) {
+		if(element.includes(",")) { element = element.split(",") };
+		var newElement = element;
+		if(isNaN(xSpacing) || isNaN(ySpacing)) {
+			throw new Error("Missing xSpacing or ySpacing");
+		};
+		if(xSpacing == 0 && ySpacing == 0) {
+			//pixel.color = convertColorFormats("#5F5F5F","rgb");
+			return false;
+		};
+		if(outOfBounds(startX,startY) /*|| (!overwrite && !isEmpty(startX,startY,false))*/) {
+			return false;
+		};	
+		var posX = startX;
+		var posY = startY;
+		var pixelsPlaced = 0;
+		//var tries = 0;
+		while(!outOfBounds(posX,posY) /*&& tries < 100*/) {
+			//tries++;
+			if(newElement instanceof Array) { newElement = newElement[Math.floor(Math.random() * newElement.length)] };
+			if(!elements[newElement]) {
+				//pixel.color = convertColorFormats("#FF5F5F","rgb");
+				console.error(`Nonexistent element ${newElement}`);
+				return false;
+			};
+			if(isEmpty(posX,posY,true)) {
+				createPixel(newElement,posX,posY);
+				if(spawnTemp !== null) { pixelMap[posX][posY].temp = spawnTemp };
+				pixelsPlaced++;
+			} else {
+				if(outOfBounds(posX,posY)) {
+					break;
+				} else {
+					if(!isEmpty(posX,posY,true)) {
+						var otherElement = pixelMap[posX][posY].element;
+						//console.log(tries,"tries");
+						//console.log("ri",rayIgnore);
+						if(rayIgnore) {
+							/*console.log(
+								rayIgnore instanceof Array,
+								otherElement,
+								otherElement == rayIgnore || rayIgnore.includes(otherElement)
+							);*/
+							if(rayIgnore instanceof Array) {
+								if(rayIgnore.includes(otherElement)) {
+									posX += xSpacing;
+									posY += ySpacing;
+									//console.log(posX, posY);
+									continue;
+								};
+							} else {
+								if(otherElement == rayIgnore) {
+									posX += xSpacing;
+									posY += ySpacing;
+									//console.log(posX,posY);
+									continue;
+								};
+							};
+						};
+						if(stopAt) {
+							if(stopAt instanceof Array) {
+								if(stopAt.includes(otherElement)) { break };
+							} else {
+								if(otherElement == stopAt) { break };
+							};
+						};
+						if(overwrite) {
+							changePixel(pixelMap[posX][posY],newElement)
+							if(spawnTemp !== null) {
+								pixelMap[posX][posY].temp = spawnTemp;
+							};
+							pixelsPlaced++
+						} else { break };
+					};
+				};
+			};
+			posX += xSpacing;
+			posY += ySpacing;
+			if(limit !== null && pixelsPlaced >= limit) {
+				return true;
+			};
+		};
+		return true;
+	};
+
+	elements.ray_cloner = {
+		properties: {
+			xSpacing: 0,
+			ySpacing: 0,
+			overwrite: false,
+			stopAt: null,
+			rayIgnore: [],
+			spawnAtPixelTemp: false,
+			maxPixels: 1000,
+			/*clone: "plasma",
+			xSpacing: 0,
+			ySpacing: 1,
+			overwrite: false,
+			stopAt: null,
+			rayIgnoreSelf: true,
+			spawnAtPixelTemp: true,
+			maxPixels: 1000,*/
+		},
+		//temp: 100000,
+		tick: function(pixel) {
+			storeFirstTouchingElement(pixel,"clone",true,true);
+			if(pixel.clone && pixel.charge) {
+					placeRegularlySpacedPixels(
+					pixel.clone,
+					pixel.x+pixel.xSpacing,
+					pixel.y+pixel.ySpacing,
+					pixel.xSpacing,
+					pixel.ySpacing,
+					pixel.overwrite,
+					pixel.stopAt,
+					pixel.rayIgnore,
+					pixel.spawnAtPixelTemp ? pixel.temp : null,
+					pixel.maxPixels
+				);
+				pixel.charge = 0
+			};
+		},
+		conduct: 1,
+		category: "machines",
+		state: "solid",
+		density: 3000,
+		insulate: true,
+		hardness: 0.8,
+		color: "#FFFF7F",
+		desc: `clone: Which element to place. Cannot be an array or comma-separated string, and will be chosen from the first pixel to touch it.<br/>
+	xSpacing and ySpacing: Horizontal and vertical spacing between x pixels. Note that blocking is only checked at these intervals. An xSpacing of 0 with a ySpacing of 1 would give a straight line going down; xS1 and yS0 would give a line to the right.<br/>
+	overwrite (default false): Whether to replace pixels the line goes into.<br/>
+	stopAt (default null): Elements the line to stop at if it hits. Also applies to overwrite, and has no effect if set to null. Can be a string or an array.<br/>
+	spawnAtPixelTemp (default false): Whether to place new pixels at the same temperature as this pixel.<br/>
+	maxPixels (default 1000): Maximum amount of pixels/changes (if xSpacing and ySpacing are both less than 2, this corresponds to the pixel length of the line).
+
+	<em>prop.js is highly recommended to set pixel properties</em>`,
+	};
+} else {
+	if(!enabledMods.includes(libraryMod))		{ enabledMods.splice(enabledMods.indexOf(modName),0,libraryMod) };
+	if(!enabledMods.includes(propMod))			{ enabledMods.splice(enabledMods.indexOf(modName),0,propMod) };
+	if(!enabledMods.includes(variablesMod))		{ enabledMods.splice(enabledMods.indexOf(modName),0,variablesMod) };
+	localStorage.setItem("enabledMods", JSON.stringify(enabledMods));
+	alert(`The "${libraryMod}", "${propMod}", and "${variablesMod}" mods are all required and have been automatically inserted (reload for this to take effect).`);
+};

package/sandboxels-package/sandboxels-1.13.2/mods/rays++.js

@@ -0,0 +1,60 @@
+elements.shock_ray = {
+    color: ["#fffba6", "#8c8279"],
+    tick: function (pixel) {
+        var x = pixel.x;
+        for (var y = pixel.y + 1; y < height; y++) {
+            if (outOfBounds(x, y)) {
+                break;
+            }
+            if (isEmpty(x, y)) {
+                if (Math.random() > 0.1) { continue }
+                createPixel("electric", x, y);
+            }
+            else {
+                if (elements[pixelMap[x][y].element].id === elements.flash.id) { continue }
+                if (elements[pixelMap[x][y].element].id === elements.god_ray.id) { break }
+                if (!elements[pixelMap[x][y].element].isGas && isEmpty(x, y - 1)) {
+                    createPixel("electric", x, y - 1);
+                }
+                if (Math.random() > 0.1) { continue }
+                elements.bless.tool(pixelMap[x][y])
+            }
+        }
+        deletePixel(pixel.x, pixel.y);
+    },
+	temp: 20,
+	category: "energy",
+	state: "gas",
+	excludeRandom: true,
+	noMix: true
+};
+elements.magic_ray = {
+    color: ["#a270ff","#f2d9ff"],
+    tick: function (pixel) {
+        var x = pixel.x;
+        for (var y = pixel.y + 1; y < height; y++) {
+            if (outOfBounds(x, y)) {
+                break;
+            }
+            if (isEmpty(x, y)) {
+                if (Math.random() > 0.1) { continue }
+                createPixel("magic", x, y);
+            }
+            else {
+                if (elements[pixelMap[x][y].element].id === elements.flash.id) { continue }
+                if (elements[pixelMap[x][y].element].id === elements.god_ray.id) { break }
+                if (!elements[pixelMap[x][y].element].isGas && isEmpty(x, y - 1)) {
+                    createPixel("magic", x, y - 1);
+                }
+                if (Math.random() > 0.1) { continue }
+                elements.bless.tool(pixelMap[x][y])
+            }
+        }
+        deletePixel(pixel.x, pixel.y);
+    },
+    temp: 20,
+    category: "energy",
+    state: "gas",
+    excludeRandom: true,
+    noMix: true
+};

package/sandboxels-package/sandboxels-1.13.2/mods/rays.js

@@ -0,0 +1,464 @@
+function whenAvailable(names, callback) {
+    var interval = 10; // ms
+    window.setTimeout(function() {
+		let bool = true;
+		for(let i = 0; i < names.length; i++)
+		{
+			if(!window[names[i]])
+			{
+				bool = false;
+			}
+		}
+        if (bool) {
+            callback();
+        } else {
+            whenAvailable(names, callback);
+        }
+    }, interval);
+}
+
+var modName = "mods/rays.js";
+var runAfterAutogenMod = "mods/runAfterAutogen2.js";
+var libraryMod = "mods/code_library.js";
+
+if(enabledMods.includes(runAfterAutogenMod) && enabledMods.includes(libraryMod)) {
+whenAvailable(["raaLoaded","libraryLoaded"], function() {
+	runAfterAutogen(function() {
+		snowAndIceCache = Object.keys(elements).filter(function(name) {
+			return name.endsWith("snow") || name.endsWith("ice") || name == "rime"
+		})
+	});
+	lightlikes = ["light","flash","laser","radiation","insulate_flash"];
+	grbBreakIntos = Object.keys(elements).filter(function(elemName) {
+		return elements[elemName].breakInto && elements[elemName].breakInto.includes("gamma_ray_burst");
+	});
+
+	elements.insulate_flash = {
+		hidden: true,
+		color: "#fffdcf",
+		tick: function(pixel) {
+			if (Math.random() < 0.75 && pixelTicks - pixel.start > 1) {
+				deletePixel(pixel.x, pixel.y)
+			}
+		},
+		reactions: {
+			"blood": { elem1:"pointer" },
+			"molten_stained_glass": { elem1:"rainbow" },
+			"gray_goo": { elem1:"static" }
+		},
+		category: "energy",
+		temp: 40,
+		state: "gas",
+		density: 1,
+		tempLow: -270,
+		stateLow: "light",
+		hidden: true,
+		noMix: true,
+		insulate: true
+	};
+
+	elements.heat_ray.tick = function(pixel) {
+		var x = pixel.x;
+		for (var y = pixel.y; y < height; y++) {
+			if (outOfBounds(x, y)) {
+				break;
+			}
+			if (isEmpty(x, y)) {
+				if (Math.random() > 0.025) { continue }
+				createPixel("insulate_flash", x, y);
+				pixelMap[x][y].color = "#ff0000";
+			}
+			else {
+				if (elements[pixelMap[x][y].element].isGas) { pixelMap[x][y].temp -= 50; continue; }
+				if (elements[pixelMap[x][y].element].id === elements.heat_ray.id) { break }
+				pixelMap[x][y].temp += 100;
+				break;
+			}
+		}
+		deletePixel(pixel.x, pixel.y);
+	};	
+
+	elements.sun.isSun = true;
+	if(elements.nellsun) { elements.nellsun.isSun = true };
+	if(elements.rainbow_sun) { elements.rainbow_sun.isSun = true };
+
+	elements.cold_ray = {
+		color: ["#00ffae","#00ffff"],
+		tick: function(pixel) {
+			var x = pixel.x;
+			for (var y = pixel.y; y < height; y++) {
+				if (outOfBounds(x, y)) {
+					break;
+				}
+				if (isEmpty(x, y)) {
+					if (Math.random() > 0.05) { continue }
+					createPixel("insulate_flash", x, y);
+					pixelMap[x][y].color = "#00ffff";
+				}
+				else {
+					if (elements[pixelMap[x][y].element].isGas) {
+						if(elements[pixelMap[x][y].element].isSun) {
+							pixelMap[x][y].temp -= 0.5;
+						} else {
+							pixelMap[x][y].temp -= 50;
+						};
+						continue; 
+					};
+					if (elements[pixelMap[x][y].element].id === elements.cold_ray.id) { break }
+					pixelMap[x][y].temp -= 150;
+					break;
+				}
+			}
+			deletePixel(pixel.x, pixel.y);
+		},
+		temp: -200,
+		category: "energy",
+		state: "gas",
+		excludeRandom: true,
+		noMix: true
+	};
+
+	elements.freeze_ray = {
+		color: ["#7fbfff","#bfffff"],
+		tick: function(pixel) {
+			var x = pixel.x;
+			for (var y = pixel.y; y < height; y++) {
+				if (outOfBounds(x, y)) {
+					break;
+				}
+				if (isEmpty(x, y)) {
+					if (Math.random() > 0.02) { continue }
+					createPixel("insulate_flash", x, y);
+					pixelMap[x][y].color = "#e1f8fc";
+				}
+				else {
+					var otherPixel = pixelMap[x][y];
+					var otherInfo = elements[otherPixel.element];
+					//Gas: Freeze chance, cool, always penetrate
+					if (otherInfo.isGas) {
+						if(Math.random() < 0.05 && otherInfo.stateLow) {
+							if(otherInfo.stateLow.includes("supernova") || otherInfo.stateLow.includes("gamma_ray_burst")) {
+								//do nothing
+							} else {
+								freezePixel(otherPixel)
+							};
+						};
+						if(elements[otherPixel.element].isSun) {
+							otherPixel.temp -= 0.5;
+						} else {
+							otherPixel.temp -= 50;
+						};
+						continue;
+					};
+
+					//Self: Break
+					if (otherInfo.id === elements.freeze_ray.id) { break }
+
+					//Non-gas, Freeze chance, cool more, half penetrate
+					if(Math.random() < 0.05 && otherInfo.stateLow) {
+						if(otherInfo.stateLow.includes("supernova") || otherInfo.stateLow.includes("gamma_ray_burst")) {
+							//do nothing
+						} else {
+							freezePixel(otherPixel)
+						};
+					};
+					pixelMap[x][y].temp -= 150;
+
+					if(Math.random() < 0.05) {
+					
+						if(!isEmpty(x,y-1,false)) {
+							if(pixelMap[x]?.[y-1]?.element && lightlikes.includes(pixelMap[x][y-1].element)) {
+								deletePixel(x,y-1);
+							};
+						};
+						var newSnow = tryCreatePixelReturn("snow",x,y-1);
+						if(newSnow) { newSnow.temp = -100 };
+					};
+
+					//Penetrate snow and ice
+					if(snowAndIceCache && snowAndIceCache.includes(otherPixel.element)) {
+						continue;
+					};
+
+					if(Math.random() < 0.7) { //thanks, I hate random continue
+						continue;
+					};
+					break;
+				}
+			}
+			deletePixel(pixel.x, pixel.y);
+		},
+		temp: -200,
+		category: "energy",
+		state: "gas",
+		excludeRandom: true,
+		noMix: true
+	};
+
+	var hasVelocity = enabledMods.includes("mods/velocity.js");
+
+	elements.smash_ray = {
+		color: ["#ff9999", "#8c8279"],
+		tick: function(pixel) {
+			var x = pixel.x;
+			for (var y = pixel.y; y < height; y++) {
+				if (outOfBounds(x, y)) {
+					break;
+				}
+				if (isEmpty(x, y)) {
+					if (Math.random() > 0.05) { continue }
+					createPixel("flash", x, y);
+					pixelMap[x][y].color = "#edd0c5";
+				}
+				else {
+					var otherPixel = pixelMap[x][y]
+					var otherInfo = elements[otherPixel.element];
+					if (!(grbBreakIntos.includes(otherPixel.element))) {
+						if (otherInfo.isGas) {
+							if(Math.random() > ((otherInfo.hardness ?? 0) ** 2)) { breakPixel(otherPixel,false,false) };
+							if(hasVelocity && otherPixel && !(lightlikes.includes(otherPixel.element))) {
+								var vels = [randomIntegerBetweenTwoValues(-7,7),randomIntegerBetweenTwoValues(-7,7)];
+								otherPixel.vx = vels[0];
+								otherPixel.vy = vels[1];
+							};
+							continue;
+							
+						};
+						if (otherInfo.id === elements.heat_ray.id) { break }
+						if(Math.random() > ((otherInfo.hardness ?? 0) ** 2)) { breakPixel(otherPixel,false,false) };
+						if(hasVelocity && otherPixel) {
+							var vels = [randomIntegerBetweenTwoValues(-7,7),randomIntegerBetweenTwoValues(-5,0)];
+							otherPixel.vx = vels[0];
+							otherPixel.vy = vels[1];
+						};
+						if(Math.random() < Math.max(0.8,0.3 + ((1 - (otherInfo.hardness ?? 0)) / 2))) { //thanks, I hate random continue
+							continue;
+						};
+						break;
+					}
+				}
+			}
+			deletePixel(pixel.x, pixel.y);
+		},
+		temp: 20,
+		category: "energy",
+		state: "gas",
+		excludeRandom: true,
+		noMix: true
+	};
+
+	//combines heat ray and smash ray
+	elements.death_ray = {
+		color: ["#a88d77", "#ff4a36"],
+		tick: function(pixel) {
+			var x = pixel.x;
+			for (var y = pixel.y; y < height; y++) {
+				if (outOfBounds(x, y)) {
+					break;
+				}
+				if (isEmpty(x, y)) {
+					if (Math.random() > 0.05) { continue }
+					createPixel("insulate_flash", x, y);
+					pixelMap[x][y].color = "#eb7b59";
+				}
+				else {
+					var otherPixel = pixelMap[x][y]
+					var otherInfo = elements[otherPixel.element];
+					otherPixel.temp += (400 * (shiftDown + 1));
+					if(otherPixel.del) { continue };
+					if (!(grbBreakIntos.includes(otherPixel.element))) {
+						if (otherInfo.isGas) {
+							if(Math.random() > ((otherInfo.hardness ?? 0) ** (4 + shiftDown))) { breakPixel(otherPixel,false,false) };
+							if(hasVelocity && otherPixel && !(lightlikes.includes(otherPixel.element))) {
+								var vels = [randomIntegerBetweenTwoValues(-7 - (shiftDown * 2),7 + (shiftDown * 2)),randomIntegerBetweenTwoValues(-7 - (shiftDown * 2),7 + (shiftDown * 2))];
+								otherPixel.vx = vels[0];
+								otherPixel.vy = vels[1];
+							};
+							continue;
+							
+						};
+						if (otherInfo.id === elements[pixel.element].id) { break }
+						if(Math.random() > ((otherInfo.hardness ?? 0) ** (2 + shiftDown))) { breakPixel(otherPixel,false,false) };
+						if(hasVelocity && otherPixel) {
+							var vels = [randomIntegerBetweenTwoValues(-9 - (shiftDown * 2),9 + (shiftDown * 2)),randomIntegerBetweenTwoValues(-7 - (shiftDown * 2),0 + (shiftDown * 2))];
+							otherPixel.vx = vels[0];
+							otherPixel.vy = vels[1];
+						};
+						if(Math.random() < ((shiftDown / 20) + (Math.max(0.9,0.4 + ((1 - (otherInfo.hardness ?? 0)) / 2))))) { //thanks, I hate random continue
+							continue;
+						};
+						break;
+					}
+				}
+			}
+			deletePixel(pixel.x, pixel.y);
+		},
+		temp: 4000,
+		category: "energy",
+		state: "gas",
+		excludeRandom: true,
+		noMix: true
+	};
+
+	elements.annihilation_ray = {
+		color: ["#220c0c", "#c11515"],
+		tick: function(pixel) {
+			var x = pixel.x;
+			for (var y = pixel.y; y < height; y++) {
+				if (outOfBounds(x, y)) {
+					break;
+				}
+				if (isEmpty(x, y)) {
+					if (Math.random() > 0.05) { continue }
+					createPixel("insulate_flash", x, y);
+					pixelMap[x][y].color = "#292929";
+				}
+				else {
+					var otherPixel = pixelMap[x][y];
+					var otherInfo = elements[otherPixel?.element];
+
+					if(otherPixel) {
+						otherPixel.temp += 2500 * (shiftDown + 1);
+						if(otherPixel.del || !otherPixel) { continue };
+
+						if (otherPixel && grbBreakIntos.includes(otherPixel.element)) {
+							if(Math.random() < 0.01 && otherPixel) {
+								deletePixel(otherPixel.x,otherPixel.y);
+							};
+							continue;
+						} else if(otherPixel) {
+							breakPixel(otherPixel,false,false);
+							if(otherPixel.del || !otherPixel) {
+								continue
+							};
+
+							if(otherPixel && hasVelocity) {
+								var vels = [randomIntegerBetweenTwoValues(-8,8),randomIntegerBetweenTwoValues(-6,0)];
+								otherPixel.vx = vels[0];
+								otherPixel.vy = vels[1];
+							};
+
+							if(otherPixel && Math.random() < (otherInfo.isGas ? 0.2 : 0.1)) {
+								deletePixel(otherPixel.x,otherPixel.y);
+								continue;
+							};
+
+							if(Math.random() > 0.8) {
+								continue;
+							};
+						};
+						if (otherInfo.id === elements[pixel.element].id) { break }
+					};
+				}
+			}
+			deletePixel(pixel.x, pixel.y);
+		},
+		temp: 150000000,
+		category: "energy",
+		state: "gas",
+		excludeRandom: true,
+		noMix: true
+	};
+
+	//bless falls within god ray
+	elements.bless.reactions.dry_dirt = { elem2: "dirt" };
+	elements.bless.reactions.dead_cum = { elem2: "cum" };
+	elements.bless.reactions.dead_cum_water = { elem2: "cum_water" };
+	elements.bless.reactions.dead_cum_ice = { elem2: "cum_ice" };
+	elements.bless.reactions.dead_cum_water_ice = { elem2: "cum_water_ice" };
+	elements.bless.reactions.dead_cum_snow = { elem2: "cum_snow" };
+	elements.bless.reactions.dead_cummy_mud = { elem2: "cummy_mud" };
+	elements.bless.reactions.dead_cummy_sand = { elem2: "cummy_sand" };
+	elements.bless.reactions.dead_cummy_permafrost = { elem2: "cummy_permafrost" };
+	elements.bless.reactions.burnt_cum = { elem2: null };
+	elements.bless.reactions.poop = { elem2: null };
+	elements.bless.reactions.dried_poop = { elem2: null };
+	elements.bless.reactions.shit = { elem2: null };
+	elements.bless.reactions.dried_shit = { elem2: null };
+	elements.bless.reactions.frozen_shit = { elem2: null };
+	elements.bless.reactions.diarrhea = { elem2: null };
+	elements.bless.reactions.frozen_diarrhea = { elem2: null };
+	elements.bless.reactions.piss = { elem2: null };
+	elements.bless.reactions.vomit = { elem2: null };
+	elements.bless.reactions.crimson_grass = { elem2: "grass" };
+	elements.bless.reactions.crimstone = { elem2: "rock" };
+	elements.bless.reactions.crimsand = { elem2: "sand" };
+	elements.bless.reactions.red_ice = { elem2: "ice" };
+	elements.bless.reactions.crimgravel = { elem2: "gravel" };
+	elements.bless.reactions.crimwater = { elem2: "water" };
+	elements.bless.reactions.crimsnow = { elem2: "snow" };
+	elements.bless.reactions.vicious_mushroom = { elem2: null };
+	elements.bless.reactions.crimson_vine = { elem2: "vine" };
+	/*elements.bless.reactions.shadewood = { elem2: "wood" };
+	elements.bless.reactions.shadewood_tree_branch = { elem2: "tree_branch" };
+	elements.bless.reactions.shadewood_sapling = { elem2: "sapling" };
+	elements.bless.reactions.shadewood_sawdust = { elem2: "sawdust" };
+	elements.bless.reactions.crimson_leaf = { elem2: "leaf" };*/
+	elements.bless.reactions.ichor = { elem2: null }; //per blood, absent the gods' immune systems (apparenly they don't need immune systems because of immortality anyway)
+	elements.bless.reactions.virus_bomb = { elem2: null };
+	elements.bless.reactions.life_eater_slurry = { elem2: null };
+	elements.bless.reactions.life_eater_explosion = { elem2: null };
+	elements.bless.reactions.life_eater_virus = { elem2: null };
+	elements.bless.reactions.injector_poison = { elem2: null };
+	elements.bless.reactions.dead_matter = { elem2: null };
+	elements.bless.reactions.life_eater_infected_dirt = { elem2: "dirt" };
+	elements.bless.reactions.poisoned_dirt = { elem2: "dirt" };
+	elements.bless.reactions.vicious_goldfish = { elem2: "fish" };
+	elements.bless.reactions.nellfire = { elem2: "bless" };
+	elements.bless.reactions.gloomwind = { elem2: null };
+	elements.bless.reactions.gloomfly = { elem2: null };
+	elements.bless.reactions.meat_monster = { elem2: null };
+	elements.bless.reactions.rotten_ravager = { elem2: null };
+	elements.bless.reactions.bone_beast = { elem2: null };
+	elements.bless.reactions.poisonwater = { elem2: "water" };
+	elements.bless.reactions.poisoned_ice = { elem2: "ice" };
+	elements.bless.reactions.poisoned_gas = { elem2: "steam" };
+	elements.bless.reactions.corrupt_land = { elem2: "dirt" };
+	elements.bless.reactions.corrupt_rock = { elem2: "rock" };
+	elements.bless.reactions.withery = { elem2: null };
+	elements.bless.reactions.withery_plant = { elem2: null };
+	elements.bless.reactions.corrupt_solid_rock = { elem2: "rock_wall" };
+	elements.bless.reactions.toxin = { elem2: "antidote" };
+	elements.bless.reactions.dead = { elem2: null };
+	elements.bless.reactions.brain = { elem2: null };
+	elements.bless.reactions.bioooze = { elem2: null };
+	elements.bless.tool = function(pixel) {
+        if (elements.bless.ignore.indexOf(pixel.element) !== -1) { return; }
+        if (pixel.burning) { // stop burning
+            delete pixel.burning;
+            delete pixel.burnStart;
+        }
+        if (pixel.nellburn) { // change: stop nellburn
+            delete pixel.nellburn;
+            delete pixel.nellburnStart;
+        }
+        if (pixel.temp > 100) {
+            pixel.temp = (pixel.temp+100)/2;
+            pixelTempCheck(pixel);
+            if (pixel.del) {return}
+        }
+        if (pixel.origColor) {
+            pixel.color = "rgb("+pixel.origColor.join(",")+")";
+            delete pixel.origColor;
+        }
+        if (pixel.charge) {
+            delete pixel.charge;
+            pixel.chargeCD = 16;
+        }
+        if (elements.bless.reactions[pixel.element] && Math.random()<0.25) {
+            var r = elements.bless.reactions[pixel.element];
+            var elem2 = r.elem2;
+            if (elem2 !== undefined) {
+                if (Array.isArray(elem2)) { elem2 = elem2[Math.floor(Math.random()*elem2.length)]; }
+                if (elem2 === null) { deletePixel(pixel.x,pixel.y) }
+                else { changePixel(pixel, elem2); }
+            }
+        }
+	};
+});
+} else {
+	if(!enabledMods.includes(libraryMod))			{ enabledMods.splice(enabledMods.indexOf(modName),0,libraryMod) };
+	if(!enabledMods.includes(runAfterAutogenMod))	{ enabledMods.splice(enabledMods.indexOf(modName),0,runAfterAutogenMod) };
+	localStorage.setItem("enabledMods", JSON.stringify(enabledMods));
+	alert(`The "${runAfterAutogenMod}" and "${libraryMod}" mods are required and have been automatically inserted (reload for this to take effect).`);
+};