studyup 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,725 @@
+var modName = "mods/human_edit.js";
+var onTryMoveIntoMod = "mods/onTryMoveInto.js";
+if(typeof(breakPixel) == "undefined") {
+	function breakPixel(pixel,changetemp=false,defaultBreakIntoDust=false) {
+		var info = elements[pixel.element];
+		if(typeof(info.breakInto) === "undefined") {
+			if(defaultBreakIntoDust) {
+				if(Math.random() < defaultBreakIntoDust) { changePixel(pixel,"dust",changetemp) };
+			};
+			return defaultBreakIntoDust;
+		};
+		var breakIntoElement = info.breakInto;
+		if(Array.isArray(breakIntoElement)) {
+			breakIntoElement = breakIntoElement[Math.floor(Math.random() * breakIntoElement.length)]
+		};
+		changePixel(pixel,breakIntoElement,changetemp)
+		return true
+	}
+};
+
+function hasPixel(x,y,elementInput) {
+	if(isEmpty(x,y,true)) { //if empty, it can't have a pixel
+		return false;
+	} else {
+		if(elementInput.includes(",")) { //CSTA
+			elementInput = elementInput.split(",");
+		};
+		if(Array.isArray(elementInput)) { //if element list
+			return elementInput.includes(pixelMap[x][y].element);
+		} else { //if single element
+			return pixelMap[x][y].element === elementInput;
+		};
+	};		
+};
+
+if(enabledMods.includes(onTryMoveIntoMod)) {
+	elements.brain = {
+		color: ["#fce3e3","#deb6c5","#f5ced5","#e87b8f"],
+		behavior: [
+			"XX|XX|XX",
+			"XX|CH:rotten_meat%1|XX",
+			"M2|M1|M2",
+		],
+		reactions: {
+			"dirty_water": { "elem1":"rotten_meat", "chance":0.1 },
+			"fly": { "elem1":"rotten_meat", "chance":0.2 },
+			"dioxin": { "elem1":"rotten_meat", "elem2":null, "chance":0.1 },
+			"uranium": { "elem1":"rotten_meat", "chance":0.1 },
+			"cancer": { "elem1":"rotten_meat", "chance":0.1 },
+			"plague": { "elem1":"rotten_meat", "elem2":null, "chance":0.3 },
+			"ant": { "elem1":"rotten_meat", "chance":0.1 },
+			"worm": { "elem1":"rotten_meat", "chance":0.1 },
+			"rat": { "elem1":"rotten_meat", "chance":0.3 },
+			"mushroom_spore": { "elem1":"rotten_meat", "chance":0.1 },
+			"mushroom_stalk": { "elem1":"rotten_meat", "chance":0.1 },
+			"mercury": { "elem1":"rotten_meat", "elem2":null, "chance":0.2 },
+			"mercury_gas": { "elem1":"rotten_meat", "elem2":null, "chance":0.1 },
+			"virus": { "elem1":"rotten_meat", "chance":0.1 },
+			"poison": { "elem1":"rotten_meat", "elem2":null, "chance":0.5 },
+			"infection": { "elem1":"rotten_meat", "elem2":null, "chance":0.1 },
+			"ink": { "elem1":"rotten_meat", "elem2":null, "chance":0.1 },
+			"acid": { "elem1":"rotten_meat", "elem2":null, "chance":0.5 },
+			"acid_gas": { "elem1":"rotten_meat", "chance":0.4 },
+			"cyanide": { "elem1":"rotten_meat", "elem2":null, "chance":0.5 },
+		},
+		tempHigh: 100,
+		stateHigh: "cooked_meat",
+		tempLow: -18,
+		stateLow: "frozen_meat",
+		category:"life",
+		hidden: true,
+		breakInto: ["meat", "blood"],
+		burn:10,
+		burnTime:200,
+		burnInto:["cooked_meat","steam","steam","salt"],
+		state: "solid",
+		density: 1081,
+		conduct: 1,
+	};
+
+	elements.cerebrospinal_fluid = {
+		color: "#ced7db",
+		behavior: behaviors.LIQUID,
+		state: "liquid",
+		tempHigh: 100,
+		stateHigh: "steam",
+		breakInto: "steam",
+		reactions: JSON.parse(JSON.stringify(elements.water.reactions)),
+	};
+
+	function validatePanic(pixel) {
+		//console.log(`validatePanic: validatePanic called on pixel ${pixel.element} at (${pixel.x},${pixel.y}) with panic level ${pixel.panic || 0}`);
+		if(pixel.element.endsWith("body")) {
+			//console.log("validatePanic called on body pixel (panic is stored in the head)");
+		};
+		if(Number.isNaN(pixel.panic)) {
+			//console.log("NaN case: panic set to 0");
+			pixel.panic = 0;
+		};
+		//console.log(`Bounding code running from value of ${pixel.panic}`);
+		pixel.panic = Math.max(0,Math.min(1,pixel.panic));
+		//console.log(`Validation result: Panic set to ${pixel.panic}`);
+
+		if(Number.isNaN(pixel.mood)) {
+			//console.log("NaN case: panic set to 0");
+			pixel.mood = 0;
+		};
+		//console.log(`Bounding code running from value of ${pixel.panic}`);
+		pixel.mood = Math.max(-3,Math.min(3,pixel.mood));
+		//console.log(`Validation result: Panic set to ${pixel.panic}`);
+	};
+
+	goodPixels = {
+		silver: { panicChange: 0.01, panicChangeChance: 0.1, moodChange: 0.004 },
+		gold: { panicChange: 0.02, panicChangeChance: 0.15, moodChange: 0.01 },
+		diamond: { panicChange: 0.03, panicChangeChance: 0.2, moodChange: 0.02 },
+	}; //effectively, the difference is that good pixels don't make the human flip direction (run away);
+	badPixels = {
+		rotten_meat: { panicChange: 0.02, panicChangeChance: 0.15, moodChange: -0.015 },
+		blood: { panicChange: 0.06, panicChangeChance: 0.2, moodChange: -0.006 },
+		brain: { panicChange: 0.1, panicChangeChance: 0.3, moodChange: -0.005 },
+		fire: { panicChange: 0.1, panicChangeChance: 0.1, moodChange: 0 },
+		poison: { panicChange: 0.2, panicChangeChance: 0.05, moodChange: -0.01 },
+		grenade: { panicChange: 0.2, panicChangeChance: 0.4, moodChange: -0.3 },
+		bomb: { panicChange: 0.2, panicChangeChance: 0.4, moodChange: -0.3 },
+		tnt: { panicChange: 0.2, panicChangeChance: 0.4, moodChange: 0 },
+		dynamite: { panicChange: 0.2, panicChangeChance: 0.4, moodChange: -0.3 },
+		anti_bomb: { panicChange: 0.2, panicChangeChance: 0.4, moodChange: -0.3 },
+		cluster_bomb: { panicChange: 0.2, panicChangeChance: 0.4, moodChange: -0.4 },
+		landmine: { panicChange: 0.25, panicChangeChance: 0.1, moodChange: -0.3 },
+		fireball: { panicChange: 0.25, panicChangeChance: 0.45, moodChange: -0.35 },
+		magma: { panicChange: 0.3, panicChangeChance: 0.2, moodChange: 0 },
+		plasma: { panicChange: 0.3, panicChangeChance: 0.2, moodChange: 0 },
+		nuke: { panicChange: 1, panicChangeChance: 1, moodChange: -1 }, //insta-panic
+		cluster_nuke: { panicChange: 1, panicChangeChance: 1, moodChange: -1 }, //insta-panic
+	}; //testing
+	otherPixels = ["head","body"]; //do custom code here
+
+	var initialTransparencyArray = ["glass","water","salt_water","sugar_water","steam","oxygen","nitrogen","neon","methane","propane","anesthesia","ammonia","carbon_dioxide","helium","hydrogen","ozone","radiation","pool_water"];
+	for(transparentElementIndex = 0; transparentElementIndex < initialTransparencyArray.length; transparentElementIndex++) {
+		var transparentElement = initialTransparencyArray[i];
+		if(typeof(elements[transparentElement]) !== "undefined") {
+			elements[transparentElement].transparent = true;
+		};
+	};
+
+	elements.body.properties = {
+		dead: false,
+		dir: 1,
+		extremePanicStart: null,
+	};
+	elements.body.tick = function(pixel) {
+		if(typeof(pixel.extremePanicStart) == "undefined") {
+			//console.log("oops");
+			pixel.extremePanicStart = null
+		};
+		if (tryMove(pixel, pixel.x, pixel.y+1)) { // Fall
+			if (!isEmpty(pixel.x, pixel.y-2, true)) { // Drag head down
+				var headpixel = pixelMap[pixel.x][pixel.y-2];
+				if (headpixel.element == "head") {
+					if (isEmpty(pixel.x, pixel.y-1)) {
+						movePixel(pixelMap[pixel.x][pixel.y-2], pixel.x, pixel.y-1);
+					}
+					else {
+						swapPixels(pixelMap[pixel.x][pixel.y-2], pixelMap[pixel.x][pixel.y-1]);
+					}
+				}
+			}
+		}
+		doHeat(pixel);
+		doBurning(pixel);
+		doElectricity(pixel);
+		if (pixel.dead) {
+			// Turn into rotten_meat if pixelTicks-dead > 500
+			if (pixelTicks-pixel.dead > 200) {
+				changePixel(pixel,"rotten_meat");
+			}
+			return
+		}
+
+		// Find the head
+		if (!isEmpty(pixel.x, pixel.y-1, true) && pixelMap[pixel.x][pixel.y-1].element == "head") {
+			var head = pixelMap[pixel.x][pixel.y-1];
+			if (head.dead) { // If head is dead, kill body
+				pixel.dead = head.dead;
+			}
+		}
+		else { var head = null }
+
+		if (isEmpty(pixel.x, pixel.y-1)) {
+			// create blood if decapitated 10% chance
+			if (Math.random() < 0.1) {
+				createPixel("blood", pixel.x, pixel.y-1);
+				// set dead to true 15% chance
+				if (Math.random() < 0.15) {
+					pixel.dead = pixelTicks;
+				}
+			}
+		}
+		if (head == null) { return };
+		
+		if (Math.random() < (0.1 + head.panic)) { // Move 10% chance, varying depending on panic value
+			var movesToTry = [
+				[1*pixel.dir,0],
+				[1*pixel.dir,-1],
+			];
+			// While movesToTry is not empty, tryMove(pixel, x, y) with a random move, then remove it. if tryMove returns true, break.
+			while (movesToTry.length > 0) {
+				var move = movesToTry.splice(Math.floor(Math.random() * movesToTry.length), 1)[0];
+				/*
+				console.log(move);
+				console.log("Body X:", pixel.x, "to", pixel.x+move[0]);
+				console.log("Body Y:", pixel.y, "to", pixel.y+move[1]);
+				console.log("Head X:",head.x, "to", head.x+move[0]);
+				console.log("Head Y:", head.y, "to", head.y+move[1]);
+				*/
+				//If head coords are empty
+				if (isEmpty(pixel.x+move[0], pixel.y+move[1]) && isEmpty(head.x+move[0], head.y+move[1])) {
+					//console.log("Head target coords are empty");
+					if (tryMove(pixel, pixel.x+move[0], pixel.y+move[1])) {
+						movePixel(head, head.x+move[0], head.y+move[1]);
+						//console.log(`Moved body to (${pixel.x},${pixel.y}) and head to (${head.x},${head.y})`);
+						//console.log(`Head-body offset (should always be [0,-1]): [${head.x-pixel.x},${head.y-pixel.y}]`)
+						break;
+					}
+				}
+			}
+			// 15% chance to change direction
+			if(!head.dirLocked) {
+				if (Math.random() < 0.15) {
+					pixel.dir *= -1;
+					//console.log("*turns around cutely to face ${pixel.dir < 0 ? 'left' : 'right'}*");
+				};
+			};
+		};	
+
+		//if not flagged for extreme panic
+		//extreme panic will not be flagged in good moods, just to be nice
+		if(pixel.extremePanicStart == null && head.panic > 0.8 && head.mood <= 0) {
+			//flag extreme panic
+			pixel.extremePanicStart = pixelTicks;
+		}
+		//if flagged for extreme panic and panic is still extreme
+		else if(pixel.extremePanicStart != null && (head.panic > 0.8 && head.mood <= 0)) {
+			//if extreme panic lasts too long
+			if(pixelTicks - pixel.extremePanicStart > 350) {
+				//random chance to die from exhaustion/a heart attack/whatever
+				if(Math.random() < 0.01) {
+					pixel.dead = true;
+				};
+			};
+		}
+		//if flagged for extreme panic and extreme panic is no longer extreme
+		else if(pixel.extremePanicStart != null && (head.panic <= 0.8 || head.mood > 0)) {
+			//unflag
+			pixel.extremePanicStart = null;
+		};
+		
+	};
+
+	elements.body.onTryMoveInto = function(pixel,otherPixel) {
+		var pX = pixel.x;
+		var pY = pixel.y;
+		if(!pixel.dead && hasPixel(pX,pY-1,"head")) { //if this body pixel is alive and has a head
+			var head = pixelMap[pX][pY-1];
+			var otherElement = otherPixel.element;
+			var oX = otherPixel.x;
+			var oY = otherPixel.y;
+			if(oY !== (pY - 1)) { //exclude the head above this body
+				if(otherElement === "head") { //if the pixel hitting this body is a head
+					if(hasPixel(oX,oY+1,"body")) { //if the pixel hitting this pixel has a body under it
+						var otherBody = pixelMap[oX][oY+1];
+						if(otherPixel.dead || otherBody.dead) { //if either part of that human is dead
+							head.panic += 0.08; //being hit by a dead ******* body is terrifying
+						} else {
+							if(otherPixel.panic > 0.04 && otherPixel.mood <= 0) { head.panic += 0.04 }; //living, normal, bodied heads scare only if that incoming human is already scared
+						};
+					} else { //if it's a severed head
+						if(otherPixel.dead) { //if the head is dead
+							head.panic += 0.08; //being hit by a /severed ******* head/ is terrifying
+						} else {
+							head.panic += 0.1; //being hit by a //******* severed head that's still alive// is even worse
+						};					
+					};
+				} else if(otherElement === "body") { //if the pixel hitting this body is a body
+					if(hasPixel(oX,oY-1,"head")) { //if the pixel hitting this pixel has a head on it
+						var otherHead = pixelMap[oX][oY-1];
+						if(otherPixel.dead || otherHead.dead) { //if either part of that human is dead
+							head.panic += 0.06; //dead whole body case
+						} else {
+							if(otherHead.panic > 0.04) { head.panic += 0.04 }; //living, normal, bodied heads scare only if that incoming human is already scared
+						};
+					} else { //severed body case
+						if(otherPixel.dead) { //if the body is dead
+							head.panic += 0.08; //imagine being hit by a severed human without the head
+						} else {
+							head.panic += 0.1; //imagine the above but the heart is still beating
+						};
+					};
+				};
+			};
+		};
+	};
+
+	elements.head.properties = {
+		dead: false,
+		dirLocked: false,
+		panic: 0,
+	};
+
+	elements.head.tick = function(pixel) {
+		doHeat(pixel);
+		doBurning(pixel);
+		doElectricity(pixel);
+		if (pixel.dead) {
+			// Turn into rotten_meat if pixelTicks-dead > 500
+			if (pixelTicks-pixel.dead > 200) {
+				changePixel(pixel,"rotten_meat");
+				return
+			}
+		}
+
+		// Find the body
+		if (!isEmpty(pixel.x, pixel.y+1, true) && pixelMap[pixel.x][pixel.y+1].element == "body") {
+			var body = pixelMap[pixel.x][pixel.y+1];
+			if (body.dead) { // If body is dead, kill head
+				pixel.dead = body.dead;
+			}
+		}
+		else { var body = null }
+
+		if (isEmpty(pixel.x, pixel.y+1)) {
+			tryMove(pixel, pixel.x, pixel.y+1);
+			// create blood if severed 10% chance
+			if (isEmpty(pixel.x, pixel.y+1) && !pixel.dead && Math.random() < 0.1) {
+				createPixel("blood", pixel.x, pixel.y+1);
+				// set dead to true 15% chance
+				if (Math.random() < 0.15) {
+					pixel.dead = pixelTicks;
+				}
+			}
+		}
+		
+		pixel.mood ??= 0;
+
+		if((pixelTicks-pixel.start) % 5 === 0) {
+			//Vision loop
+			var pX = pixel.x;
+			var pY = pixel.y;
+			if(pixel.dir === -1) {
+				for(i = -4; i < 4+1; i++) {
+					var oY = i;
+					//console.log(`Starting row look at row ${pY+oY}`)
+					for(j = (-1); j > (-16 - 1); j--) {
+						var oX = j;
+						var nX = pX+oX;
+						var nY = pY+oY;
+						if(outOfBounds(nX,nY)) {
+							//console.log(`Stopping row look at pixel (${nX},${nY}) due to OoB`)
+							break;
+						};
+						if(isEmpty(nX,nY)) {
+							//console.log(`Skipping pixel (${nX},${nY}) (empty)`)
+							continue;
+						};
+						if(!isEmpty(nX,nY,true)) {
+							var newPixel = pixelMap[nX][nY];
+							var newElement = newPixel.element;
+							if(Object.keys(goodPixels).includes(newElement)) {
+								//no dir flip
+								if(Math.random() > goodPixels[newElement].panicChangeChance) {
+									pixel.panic += goodPixels[newElement].panicChange;
+									pixel.mood += goodPixels[newElement].moodChange; //like if there was a pretty painting item, it would make you feel better but you wouldn't necessarily feel the need to run towards it
+								};
+								pixel.dirLocked = true;
+							} else if(Object.keys(badPixels).includes(newElement)) {
+								body.dir = 1; //flip dir
+								if(Math.random() > badPixels[newElement].panicChangeChance) {
+									pixel.panic += badPixels[newElement].panicChange;
+									pixel.mood += badPixels[newElement].moodChange;
+								};
+								pixel.dirLocked = true;
+							}; //good and bad should be mutually exclusive; good will be evaulated first because one inevitably has to be considered first
+							if(otherPixels.includes(newElement)) {
+								//specific custom code
+								if(newElement === "head") {
+									if(hasPixel(nX,nY+1,"body")) {
+										var newBody = pixelMap[nX][nY+1];
+										if(newPixel.dead || newBody.dead) {
+											pixel.panic += 0.02;	//if it's seeing a whole human, it's likely to see the dead head and the dead body, thus double-executing
+																	//it would be nice if there was a way to avoid double/multiple detection of the same human
+											if(hasPixel(pX,pY+1,"body")) { //mix error-proofing
+												var body = pixelMap[pX][pY+1];
+												body.dir = 1; //run away
+											};
+										} else {
+											if(newPixel.panic > 0.04) {
+												if(newPixel.panic > 0.8) {
+													pixel.panic += 0.015; //it will add up
+												} else if(newPixel.panic > 0.6) {
+													pixel.panic += 0.012;
+												} else if(newPixel.panic > 0.4) {
+													pixel.panic += 0.009;
+												} else if(newPixel.panic > 0.2) {
+													pixel.panic += 0.006;
+												} else {
+													pixel.panic += 0.003;
+												};
+												
+												//the vision loop is in the head, and this is in the "seeing head" case, then this will happen when the head sees another head, and heads store panic; this is in the "other head" is panicking case so this will ultimately be the code that runs when its human sees another human panicking
+												if(Math.random() < 0.5) {
+													//run in same direction as panicking person
+													pixel.dir = newPixel.dir
+												};
+											};
+										};
+									} else { //severed head
+										newPixel.dead ? pixel.panic += 0.03 : pixel.panic += 0.04;
+										if(hasPixel(pX,pY+1,"body")) {
+											var body = pixelMap[pX][pY+1];
+											body.dir = 1; //run away
+										};
+									};
+								} else if(newElement === "body") {
+									if(hasPixel(nX,nY-1,"head")) {
+										var newHead = pixelMap[nX][nY-1];
+										if(newPixel.dead || newHead.dead) {
+											pixel.panic += 0.02;
+											if(hasPixel(pX,pY+1,"body")) {
+												var body = pixelMap[pX][pY+1];
+												body.dir = 1; //run away
+											};
+										} else {
+											if(newHead.panic > 0.04) {
+												if(newHead.panic > 0.8) {
+													pixel.panic += 0.014; //it will add up
+												} else if(newHead.panic > 0.6) {
+													pixel.panic += 0.011;
+												} else if(newHead.panic > 0.4) {
+													pixel.panic += 0.008;
+												} else if(newHead.panic > 0.2) {
+													pixel.panic += 0.005;
+												} else {
+													pixel.panic += 0.002;
+												};
+											};
+										};
+									} else { //severed body
+										newPixel.dead ? pixel.panic += 0.025 : pixel.panic += 0.035;
+										if(hasPixel(pX,pY+1,"body")) { //mix error-proofing
+											var body = pixelMap[pX][pY+1];
+											body.dir = 1; //run away
+										};
+									};
+								};
+							};
+							//code outside of those three if blocks will be applied to pixels of all elements
+							if(!elements[newElement].transparent) {
+								break; //can't see through humans
+							};
+						};
+					};
+				};
+			} else if(pixel.dir === 1) {
+				for(i = -4; i < 4+1; i++) {
+					var oY = i;
+					//console.log(`Starting row look at row ${pY+oY}`)
+					for(j = 1; j < 16 + 1; j++) {
+						var oX = j;
+						var nX = pX+oX;
+						var nY = pY+oY;
+						if(outOfBounds(nX,nY)) {
+							//console.log(`Stopping row look at pixel (${nX},${nY}) due to OoB`)
+							break;
+						};
+						if(isEmpty(nX,nY)) {
+							//console.log(`Skipping pixel (${nX},${nY}) (empty)`)
+							continue;
+						};
+						if(!isEmpty(nX,nY,true)) {
+							var newPixel = pixelMap[nX][nY];
+							var newElement = newPixel.element;
+							if(Object.keys(goodPixels).includes(newElement)) {
+								//no dir flip
+								if(Math.random() > goodPixels[newElement].panicChangeChance) {
+									pixel.panic += goodPixels[newElement].panicChange;
+									pixel.mood += goodPixels[newElement].moodChange;
+								};
+								pixel.dirLocked = true;
+							} else if(Object.keys(badPixels).includes(newElement)) {
+								if(hasPixel(pX,pY+1,"body")) {
+									var body = pixelMap[pX][pY+1];
+									body.dir = -1; //run away
+								};
+								if(Math.random() > badPixels[newElement].panicChangeChance) {
+									pixel.panic += badPixels[newElement].panicChange;
+									pixel.mood += badPixels[newElement].moodChange;
+								};
+								pixel.dirLocked = true;
+							}; //good and bad should be mutually exclusive; good will be evaulated first because one inevitably has to be considered first
+							if(otherPixels.includes(newElement)) {
+								if(newElement === "head") {
+									if(hasPixel(nX,nY+1,"body")) {
+										var newBody = pixelMap[nX][nY+1];
+										if(newPixel.dead || newBody.dead) {
+											pixel.panic += 0.02;	//if it's seeing a whole human, it's likely to see the dead head and the dead body, thus double-executing
+																	//it would be nice if there was a way to avoid double/multiple detection of the same human
+											if(hasPixel(pX,pY+1,"body")) {
+												var body = pixelMap[pX][pY+1];
+												body.dir = -1; //run away
+											};
+										} else {
+											if(newPixel.panic > 0.04) {
+												if(newPixel.panic > 0.8) {
+													pixel.panic += 0.015; //it will add up
+												} else if(newPixel.panic > 0.6) {
+													pixel.panic += 0.012;
+												} else if(newPixel.panic > 0.4) {
+													pixel.panic += 0.009;
+												} else if(newPixel.panic > 0.2) {
+													pixel.panic += 0.006;
+												} else {
+													pixel.panic += 0.003;
+												};
+											};
+										};
+									} else { //severed head
+										newPixel.dead ? pixel.panic += 0.03 : pixel.panic += 0.04;
+										if(hasPixel(pX,pY+1,"body")) {
+											var body = pixelMap[pX][pY+1];
+											body.dir = -1; //run away
+										};
+									};
+								} else if(newElement === "body") {
+									if(hasPixel(nX,nY-1,"head")) {
+										var newHead = pixelMap[nX][nY-1];
+										if(newPixel.dead || newHead.dead) {
+											pixel.panic += 0.02;
+											if(hasPixel(pX,pY+1,"body")) {
+												var body = pixelMap[pX][pY+1];
+												body.dir = -1; //run away
+											};
+										} else {
+											if(newHead.panic > 0.04) {
+												if(newHead.panic > 0.8) {
+													pixel.panic += 0.014; //it will add up
+												} else if(newHead.panic > 0.6) {
+													pixel.panic += 0.011;
+												} else if(newHead.panic > 0.4) {
+													pixel.panic += 0.008;
+												} else if(newHead.panic > 0.2) {
+													pixel.panic += 0.005;
+												} else {
+													pixel.panic += 0.002;
+												};
+											};
+										};
+									} else { //severed body
+										newPixel.dead ? pixel.panic += 0.025 : pixel.panic += 0.035;
+										if(hasPixel(pX,pY+1,"body")) {
+											var body = pixelMap[pX][pY+1];
+											body.dir = -1; //run away
+										};
+									};
+								};
+							};
+							//code outside of those three if blocks will be applied to pixels of all elements
+							if(!elements[newElement].transparent) {
+								break; //can't see through humans
+							};
+						};
+					};
+				};
+			};
+		};
+
+		validatePanic(pixel);
+
+		if(Math.random() < 0.01) { //1% chance each tick to lose interest
+			pixel.dirLocked = false;
+			//console.log("Meh.");
+		};
+
+		if(Math.random() < ((pixel.panic) > 0.8 ? 0.04 : 0.02)) { //2% chance each tick to decrease panic (4% if the panic is extreme)
+			//console.log("Decreasing panic");
+			pixel.panic < 0.05 ? pixel.panic = 0 : pixel.panic -= 0.05;
+		};
+
+	};
+	elements.head.breakInto = ["bone","brain","brain","cerebrospinal_fluid","blood","blood","meat"];
+
+	elements.head.onTryMoveInto = function(pixel,otherPixel) {
+		var pX = pixel.x;
+		var pY = pixel.y;
+		if(!pixel.dead) {
+			var otherElement = otherPixel.element;
+			var oX = otherPixel.x;
+			var oY = otherPixel.y;
+			if(oY !== (pY + 1)) { //exclude the body under this head
+				if(otherElement === "head") { //if the pixel hitting this head is also a head
+					//console.log("head.onTryMoveInto: Head has tried to move into head");
+					if(hasPixel(oX,oY+1,"body")) { //if the pixel hitting this pixel has a body under it
+						var otherBody = pixelMap[oX][oY+1];
+						if(otherPixel.dead || otherBody.dead) { //if either part of that human is dead
+							pixel.panic += 0.08; //being hit by a dead ******* body is terrifying
+							//console.log("head.onTryMoveInto: panic increase, case: head hit by dead whole body (head's code branch)");
+						} else {
+							//if(otherPixel.panic > 0.04) { pixel.panic += 0.04; console.log("head.onTryMoveInto: panic increase, case: head hit by panicked whole body (head's code branch)"); }; //living, normal, headed bodies scare only if that incoming human is already scared
+						};
+					} else { //if it's a severed head
+						if(otherPixel.dead) { //if the head is dead
+							pixel.panic += 0.08; //being hit by a /severed ******* head/ is terrifying
+							//console.log("head.onTryMoveInto: panic increase, case: head hit by dead severed head");
+						} else {
+							pixel.panic += 0.1; //being hit by a //******* severed head that's still alive// is even worse
+							//console.log("head.onTryMoveInto: panic increase, case: head hit by living severed head");
+						};					
+					};
+				} else if(otherElement === "body") { //if the pixel hitting this head is a body
+					if(hasPixel(oX,oY-1,"head")) { //if the body hitting this pixel has a head on it
+						var otherHead = pixelMap[oX][oY-1];
+						if(otherPixel.dead || otherHead.dead) { //if either part of that human is dead
+							pixel.panic += 0.03; //dead whole body case
+							//console.log("head.onTryMoveInto: panic increase, case: head hit by dead whole body (body's code branch)");
+						} else {
+							if(otherHead.panic > 0.04) {
+								pixel.panic += 0.03;
+								//console.log("head.onTryMoveInto: panic increase, case: head crushed by panicked whole body (body's code branch)");
+							} else {
+								pixel.panic += 0.02;
+								//console.log("head.onTryMoveInto: panic increase, case: head crushed by whole body (body's code branch)");
+							};
+						};
+					} else { //severed body case
+						if(otherPixel.dead) { //if the body is dead
+							pixel.panic += 0.04; //imagine being hit by a severed human without the head
+							//console.log("head.onTryMoveInto: panic increase, case: head hit by dead severed body");
+						} else {
+							pixel.panic += 0.05; //imagine the above but the heart is still beating
+							//console.log("head.onTryMoveInto: panic increase, case: head hit by living severed body");
+						};
+					};
+				} else {
+					if(oX === pX && oY === pY-1) {
+						var otherInfo = elements[otherElement];
+						var otherState; typeof(otherInfo.state) === "undefined" ? otherState = null : otherState = otherInfo.state;
+						var otherDensity = typeof(otherInfo.density) === "undefined" ? otherDensity = null : otherDensity = otherInfo.density;
+						if(otherState === "solid") {
+							if(otherDensity > 5000) {
+								var chance = (0.1 + (otherDensity/50000)) / 5;
+								if(Math.random() < chance) {
+									breakPixel(pixel);
+								};
+							} else if(otherDensity >= 500) {
+								pixel.panic += (0.01 * (otherDensity / 500));
+							} else if(otherDensity >= 100) {
+								pixel.panic += (0.001 * (otherDensity / 100));
+							};
+						};
+					};
+				};
+			};
+		};
+	};
+
+	//Worldgen preset for testing
+
+	worldgentypes.basalt_dirt = {
+		layers: [
+			[0, "basalt", 0.05],
+			[0, "dirt"]
+		]
+	};
+
+	kep1er = [
+		["first_impact",	["#664482","#cf4ba3","#c15ca9","#f0a669"]],
+		["doublast",		["#2b98fd","#d0e26d","#e6f049","#dce4b3"]],
+		["fly-up",			["#f2f2f2","#15a667","#de0180"]],
+		["troubleshooter",	["#291923","#ed3fb6","#fee6f8","#64c5e0","#d6cdca","#330d25"]],
+		["fly-by",			["#e7e6dd","#fcf0ef","#efa1ba","#8d7cb6","#5e74ba","#2b5db5","#e292b7"]],
+		["lovestruck",		["#bfd9f0","#bfd9f0","#fef792","#c36475","#edd1d6"]],
+	];
+	
+	for(index in kep1er) {
+		index = parseInt(index);
+		var newName = kep1er[index][0];
+		var newColor = kep1er[index][1];
+		var newDisplayName = newName.replaceAll("_"," ").replaceAll("-"," - ").split(" ").map(x => x.substring(0,1).toUpperCase() + x.substring(1)).join(" ").replace(" - ","-");
+		elements[newName] = {
+			name: newDisplayName,
+			color: newColor,
+			tempHigh: 200,
+			stateHigh: ["ash","molten_plastic"],
+			density: 332, //based off of First Impact: https://www.amazon.com/Kep1er-IMPACT-Contents-Tracking-Connect/dp/B09MQMNZ62
+			tick: function(pixel) {
+				if(!(tryMove(pixel,pixel.x,pixel.y+1))) {
+					var directions = [];
+					if(isEmpty(pixel.x-1,pixel.y+1) && isEmpty(pixel.x-1,pixel.y+2)) {
+						directions.push(-1)
+					};
+					if(isEmpty(pixel.x+1,pixel.y+1) && isEmpty(pixel.x+1,pixel.y+2)) {
+						directions.push(1)
+					};
+					if(directions.length > 0) {
+						tryMove(pixel,pixel.x+directions[Math.floor(Math.random() * directions.length)],pixel.y)
+					};
+				}
+			},
+			reactions: {
+				water: { elem1: ["plastic","cellulose","cellulose"], elem2: ["water","water","cellulose",null,null], chance: 0.8 }
+			},
+			burn: 40,
+			burnTime: 150,
+			burnInto: ["ash","molten_plastic","carbon_dioxide","smoke"],
+			category: "other"
+		};
+		
+		goodPixels[newName] = { panicChange: 0.01, panicChangeChance: 0.2, moodChange: 0.035 };
+	};
+	
+} else {
+	enabledMods.splice(enabledMods.indexOf(modName),0,onTryMoveIntoMod)
+	localStorage.setItem("enabledMods", JSON.stringify(enabledMods));
+	alert(`The ${onTryMoveIntoMod} mod is required and has been automatically inserted (reload for this to take effect).`)
+};