studyup 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,141 @@
+// Sky.js
+
+// BetterSettings.js integration
+if (!enabledMods.includes("mods/betterSettings.js")) { enabledMods.unshift("mods/betterSettings.js"); localStorage.setItem("enabledMods", JSON.stringify(enabledMods)); window.location.reload() };
+
+var sky_settingsTab = new SettingsTab("Sky");
+
+var realtime_setting = new Setting("Use real life time for sky", "real_time", settingType.BOOLEAN, false, defaultValue=false);
+var initial_hour_setting = new Setting("Initial hour", "initial_hour", settingType.NUMBER, false, defaultValue=8);
+var ticks_per_hour_setting = new Setting("Ticks per hour", "ticks_per_hour", settingType.NUMBER, false, defaultValue=300);
+var airtemp_setting = new Setting("Change air temperature based on time", "air_temp", settingType.BOOLEAN, false, defaultValue=true);
+var drawSun = new Setting("Add sun", "drawSun", settingType.BOOLEAN, false, defaultValue=true);
+
+sky_settingsTab.registerSettings("Real time", realtime_setting);
+sky_settingsTab.registerSettings("Initial hour", initial_hour_setting);
+sky_settingsTab.registerSettings("Ticks per hour", ticks_per_hour_setting);
+sky_settingsTab.registerSettings("Temperature", airtemp_setting);
+sky_settingsTab.registerSettings("Sun", drawSun);
+
+settingsManager.registerTab(sky_settingsTab);
+
+// Destructuring makes it faster
+function lerpColor([r1, g1, b1], [r2, g2, b2], t) {
+    return [r1 + (r2 - r1) * t, g1 + (g2 - g1) * t, b1 + (b2 - b1) * t].map(Math.round);
+}
+
+function hourToTemp(hour, Tmin=10, Tmax=30) {
+    return Tmin + (Tmax - Tmin) * Math.pow(Math.sin((Math.PI / 24) * (hour - 4)), 2);
+}
+
+function getSunPositionInRect(x_, y_, w, h) {
+	// Convert hour to angle
+	var angle = Math.PI * (18 - hour) / 12;
+
+	// Convert angle to position
+	var centerX = x_ + (w / 2);
+	var centerY = y_ + h;
+	var radius = (w) / 2;
+	var x = centerX + radius * Math.cos(angle);
+	var y = centerY - radius * Math.sin(angle);
+
+	return { angle, x, y };
+}
+
+function getSkyColors(hour) {
+	const SKY_COLOR_PAIRS = [
+		[[0, 0, 15], [0, 0, 30]], // midnight
+		[[10, 10, 40], [20, 20, 60]],
+		[[255, 100, 50], [255, 150, 100]],
+		[[135, 206, 235], [180, 230, 255]],
+		[[135, 206, 250], [135, 206, 255]],
+		[[135, 206, 250], [120, 190, 240]],
+		[[255, 150, 100], [120, 70, 70]],
+		[[30, 15, 60], [20, 10, 40]],
+		[[0, 0, 15], [0, 0, 30]], // midnight
+	];
+
+	// Determine the interval (each interval is 3 hours)
+	const index = Math.floor(hour / 3);
+	const t = (hour % 3) / 3;
+
+	const [bottomStart, topStart] = SKY_COLOR_PAIRS[index];
+	const [bottomEnd, topEnd] = SKY_COLOR_PAIRS[index + 1];
+
+	return {
+		skyTop: `rgb(${lerpColor(topStart, topEnd, t).join(", ")})`,
+		skyBottom: `rgb(${lerpColor(bottomStart, bottomEnd, t).join(", ")})`,
+	};
+}
+
+function drawSunSquare(ctx, sunPos, size, color, blur) {
+	ctx.save();
+	ctx.filter = `blur(${blur}px)`;
+	ctx.translate(sunPos.x * pixelSize, sunPos.y * pixelSize);
+	ctx.rotate(sunPos.angle);
+	ctx.fillStyle = color;
+	ctx.fillRect(-size * 0.5, -size * 0.5, size, size);
+	ctx.restore();
+}
+
+function renderSkyAndSun(ctx) {
+	// Get sky colors and make gradient
+	const { skyTop, skyBottom } = getSkyColors(hour);
+	const gradient = ctx.createLinearGradient(0, 0, 0, height * pixelSize);
+	gradient.addColorStop(0, skyTop);
+	gradient.addColorStop(1, skyBottom);
+
+	ctx.globalAlpha = 1.0;
+	ctx.fillStyle = gradient;
+	ctx.fillRect(0, 0, (width + 1) * pixelSize, (height + 1) * pixelSize);
+
+	// Draw sun
+	if (hour < 5.5 || hour > 18.5) {return;}
+	if (!drawSun.value) {return;}
+
+	var sunPos = getSunPositionInRect(width * 0.1, height * 0.1, width * 0.8, height * 0.9);
+	var sunSize = pixelSize * 9;
+	var nearSunSetOrRise = Math.pow((1 - Math.cos((Math.PI / 6) * hour)) / 2, 4);
+	var color = RGBToHex(lerpColor([255, 230, 225], [255, 160, 128], nearSunSetOrRise));
+
+	drawSunSquare(ctx, sunPos, sunSize, color, 5); // Glow
+	drawSunSquare(ctx, sunPos, sunSize * 0.75, "#FFFFFF", 1);
+}
+
+function updateDayTime() {
+	if (paused) {return;}
+
+	if (realtime_setting.value) {
+		const now = new Date();
+		hour = now.getHours() + now.getMinutes() / 60;
+	} else {
+		var hours_per_tick = 1 / (ticks_per_hour_setting.value + 1);
+		hour = (hour + hours_per_tick) % 24; // Keep within 0-23
+	}
+
+	if (airtemp_setting.value) {
+		airTemp = hourToTemp(hour, 12, 26);
+	}
+}
+
+// Sky should be first layer
+function prioritizeSky() {
+	const idx = renderPrePixelList.indexOf(renderSkyAndSun);
+	if (idx !== -1) {
+		const [skyFn] = renderPrePixelList.splice(idx, 1);
+		renderPrePixelList.unshift(skyFn);
+	}
+}
+
+// Resetting canvas also resets hour
+function initializeSky() {
+	hour = initial_hour_setting.value;
+}
+
+// Hooks
+runAfterReset(initializeSky);
+runAfterLoad(prioritizeSky);
+runEveryTick(updateDayTime);
+renderPrePixel(renderSkyAndSun);
+
+var hour = initial_hour_setting.value;

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

@@ -0,0 +1,25 @@
+elements.slag = {
+    color: ["#4b3a2d","#6a5447","#6b5b53","#675851","#78756e"],
+    behavior: behaviors.POWDER,
+    tempHigh: 1780,
+    stateHigh: "molten_slag",
+    category: "powders",
+    density: 2400,
+    state: "solid",
+    conduct: 0.03,
+    movable: true,
+}
+
+elements.molten_slag = {
+    color: ["#964917","#963A17","#962C00","#D46924","#D45424","#D43F00","#D6722A","#D65B2A","#D64419","#CE6E29","#CE5829","#CE4200","#F09237","#F07537","#F05800"],
+    behavior: behaviors.MOLTEN,
+    temp: 1880,
+    tempLow: 1780,
+    stateLow: "slag",
+    viscosity: 10000,
+    hidden: true,
+    state: "liquid",
+    category: "molten",
+    density: 2160,
+    conduct: 0,
+} 

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

@@ -0,0 +1,6 @@
+elements.water.behavior = [
+    "XX|XX|XX",
+    "XX|XX|M2 AND BO",
+    "XX|M1|M2",
+];
+elements.water.flippableX = true;

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

@@ -0,0 +1,74 @@
+var modName = "mods/random_rocks.js";
+var onTryMoveIntoMod = "mods/onTryMoveInto.js";
+var libraryMod = "mods/code_library.js";
+
+if(enabledMods.includes(onTryMoveIntoMod) && enabledMods.includes(libraryMod)) {
+	elements.solid_rock = {
+		color: ["#808080","#4f4f4f","#949494"],
+		behavior: behaviors.WALL,
+		reactions: {
+			"water": {elem1: "wet_sand", chance: 0.00035},
+			"salt_water": {elem1: "wet_sand", chance: 0.0005},
+			"sugar_water": {elem1: "wet_sand", chance: 0.0004},
+			"seltzer": {elem1: "wet_sand", chance: 0.0004},
+			"dirty_water": {elem1: "wet_sand", chance: 0.0004},
+			"soda": {elem1: "wet_sand", chance: 0.0004},
+			"lichen": {elem1: "dirt", chance: 0.0025},
+			"grape": {elem2: "juice", chance: 0.1, color2: "#291824"},
+			"root": {elem1: "sand", chance: 0.0004},
+			"wheat": {elem2: "flour"},
+			"primordial_soup": {elem1: "wet_sand", chance: 0.001}
+		},
+		onTryMoveInto: function(pixel,otherPixel) {
+			if(elements[otherPixel.element].category === "corruption") {
+				if(Math.random() < 0.05) {
+					changePixel(pixel,"corrupt_solid_rock");
+					return;
+				};
+			} else {
+				reactionStealer(pixel,otherPixel,"rock");
+			};
+		},
+		tempHigh: 950,
+		stateHigh: "magma",
+		category: "land",
+		state: "solid",
+		density: 2600,
+		hardness: 0.55,
+		breakInto: "rock",
+	}
+
+	if(enabledMods.includes("mods/fey_and_more.js")) {
+		elements.corrupt_solid_rock = {
+			color: ["#514c78","#514c78","#2a264d","#2a264d","#514c78","#514c78"],
+			behavior: behaviors.WALL,
+			tempHigh: 1200,
+			category: "corruption",
+			state: "solid",
+			density: 1250,
+			breakInto: "corrupt_rock",
+			tick: function(pixel) {
+				var randomNeighborOffset = adjacentCoords[Math.floor(Math.random() * adjacentCoords.length)];
+				var rfX = pixel.x+randomNeighborOffset[0];
+				var rfY = pixel.y+randomNeighborOffset[1];
+				if(!isEmpty(rfX,rfY,true)) {
+					var otherPixel = pixelMap[rfX][rfY];
+					if(otherPixel.element === "solid_rock") {
+						if(Math.random() < 0.05) {
+							changePixel(otherPixel,"corrupt_solid_rock")
+						};
+					};
+				};
+			},
+		};
+		
+		runAfterLoad(function() {
+			elements.corrupt_solid_rock.reactions = elements.corrupt_land.reactions;
+		});
+	}
+} else {
+	if(!enabledMods.includes(libraryMod))		{ enabledMods.splice(enabledMods.indexOf(modName),0,libraryMod) };
+	if(!enabledMods.includes(onTryMoveIntoMod))	{ enabledMods.splice(enabledMods.indexOf(modName),0,onTryMoveIntoMod) };
+	localStorage.setItem("enabledMods", JSON.stringify(enabledMods));
+	alert(`The "${libraryMod}" and "${onTryMoveIntoMod}" mods are all required; any missing mods in this list have been automatically inserted (reload for this to take effect).`)
+};

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

@@ -0,0 +1,146 @@
+// all credits to nousernamefound for onecolor.js
+
+window.addEventListener('load', function() {
+    console.log("attempted override");
+
+    pixelColorPick = function(pixel, customColor = null) {
+        var element = pixel.element;
+        var elementInfo = elements[element];
+
+        if (pixel.charge && elementInfo.colorOn) {
+            customColor = elementInfo.colorOn;
+        }
+
+        if (customColor != null) {
+            if (Array.isArray(customColor)) {
+                customColor = customColor[Math.floor(Math.random() * customColor.length)]; 
+            }
+            if (customColor.startsWith("#")) {
+                customColor = hexToRGB(customColor);
+            }
+            var rgb = customColor;
+        } else {
+            var rgb = elements[element].colorObject; 
+            if (Array.isArray(rgb)) {
+                rgb = rgb[Math.floor(Math.random() * rgb.length)];
+            }
+        }
+
+        var coloroffset = Math.floor(Math.random() * (Math.random() > 0.5 ? -1 : 1) * Math.random() * 15);
+        var r = rgb.r + 0;
+        var g = rgb.g + 0;
+        var b = rgb.b + 0;
+
+        r = Math.max(0, Math.min(255, r));
+        g = Math.max(0, Math.min(255, g));
+        b = Math.max(0, Math.min(255, b));
+
+        var color = "rgb(" + r + "," + g + "," + b + ")";
+        return color;
+    }
+
+    pixelTempCheck = function(pixel) {
+        if (pixel.del) { return }
+        var elementInfo = elements[pixel.element];
+        if (pixel.temp < absoluteZero) { 
+            pixel.temp = absoluteZero;
+        }
+
+        if (pixel.temp >= elementInfo.tempHigh) {
+            var result = elementInfo.stateHigh;
+            if (elementInfo.extraTempHigh) {
+                for (var extraTemp in elementInfo.extraTempHigh) {
+                    if (pixel.temp >= extraTemp) {
+                        result = elementInfo.extraTempHigh[extraTemp];
+                    }
+                }
+            }
+
+            if (Array.isArray(result)) {
+                result = result[Math.floor(Math.random() * result.length)];
+            }
+            if (result === null) {
+                deletePixel(pixel.x, pixel.y);
+                return false;
+            } else {
+                if (elements[result].customColor) {
+                    changePixel(pixel, result, false);
+                    pixel.color = color;
+                } else if (elementInfo.stateHighColor) {
+                    changePixel(pixel, result, false);
+                    pixel.color = pixelColorPick(pixel, elementInfo.stateHighColor);
+                } else if (elementInfo.stateHighColorMultiplier) {
+                    var color = pixel.color;
+                    changePixel(pixel, result, false);
+                    var rgb = color.match(/\d+/g);
+                    var m = elementInfo.stateHighColorMultiplier;
+                    if (Array.isArray(m)) {
+                        m = m[0];
+                    }
+                    var r = Math.floor(rgb[0] * m);
+                    var g = Math.floor(rgb[1] * m);
+                    var b = Math.floor(rgb[2] * m);
+
+                    r = Math.max(0, Math.min(255, r));
+                    g = Math.max(0, Math.min(255, g));
+                    b = Math.max(0, Math.min(255, b));
+
+                    pixel.color = "rgb(" + r + "," + g + "," + b + ")";
+                } else {
+                    changePixel(pixel, result, false);
+                }
+
+                if (elementInfo.fireColor && result === "fire") {
+                    pixel.color = pixelColorPick(pixel, elementInfo.fireColor);
+                }
+            }
+        }
+
+        else if (pixel.temp <= elementInfo.tempLow) {
+            var result = elementInfo.stateLow;
+            if (elementInfo.extraTempLow) {
+                for (var extraTemp in elementInfo.extraTempLow) {
+                    if (pixel.temp <= extraTemp) {
+                        result = elementInfo.extraTempLow[extraTemp];
+                    }
+                }
+            }
+
+            if (Array.isArray(result)) {
+                result = result[Math.floor(Math.random() * result.length)];
+            }
+            if (result === null) {
+                deletePixel(pixel.x, pixel.y);
+                return false;
+            } else {
+                if (elements[result].customColor) {
+                    changePixel(pixel, result, false);
+                    pixel.color = color;
+                } else if (elementInfo.stateLowColor) {
+                    changePixel(pixel, result, false);
+                    pixel.color = pixelColorPick(pixel, elementInfo.stateLowColor);
+                } else if (elementInfo.stateLowColorMultiplier) {
+                    var color = pixel.color;
+                    changePixel(pixel, result, false);
+                    var rgb = color.match(/\d+/g);
+                    var m = elementInfo.stateLowColorMultiplier;
+                    if (Array.isArray(m)) {
+                        m = m[0];
+                    }
+                    var r = Math.floor(rgb[0] * m);
+                    var g = Math.floor(rgb[1] * m);
+                    var b = Math.floor(rgb[2] * m);
+
+                    r = Math.max(0, Math.min(255, r));
+                    g = Math.max(0, Math.min(255, g));
+                    b = Math.max(0, Math.min(255, b));
+
+                    pixel.color = "rgb(" + r + "," + g + "," + b + ")";
+                } else {
+                    changePixel(pixel, result, false);
+                }
+            }
+        }
+        return true;
+    }
+});

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

@@ -0,0 +1,287 @@
+/*
+* Version 1.1.0
+*/
+
+dependOn("orchidslibrary.js", ()=>{
+    elements.water.reactions.salt = undefined;
+    elements.water.reactions.sugar = undefined;
+    elements.water.properties = {capacity: 100, elemsDissolved: {}};
+    elements.salt.solubility = {water: 0.36, color: ["#7ca3f7", "#7798e0", "#89abf5", "#96b8ff"]};
+    elements.sugar.solubility = {water: 2, visc: 850, color: ["#9bb0de", "#a8bbe3", "#a2b8e8", "#a7b7d9"]};
+    elements.lye.solubility = {water: 1.09, color: ["#7ca3f7", "#7798e0", "#89abf5", "#96b8ff"]};
+    elements.caustic_potash.solubility = {water: 1.1, color: ["#7ca3f7", "#7798e0", "#89abf5", "#96b8ff"]};
+    elements.potassium_salt.solubility = {water: 0.3397, color: ["#7ca3f7", "#7798e0", "#89abf5", "#96b8ff"]};
+    elements.borax.solubility = {water: 0.041, color: ["#658ce0", "#7299ed", "#7597e0", "#78a1fa"]};
+    elements.epsom_salt.solubility = {water: 0.351, color: ["#658ce0", "#7299ed", "#7597e0", "#78a1fa"]};
+    elements.sodium_acetate.solubility = {water: 1.233, color: ["#7ca3f7", "#7798e0", "#89abf5", "#96b8ff"]};
+    elements.baking_soda.solubility = {water: 0.097, color: ["#7ca3f7", "#7798e0", "#89abf5", "#96b8ff"]};
+    elements.copper_sulfate.solubility = {water: 0.32, color: ["#4a68f0", "#3358ff", "#2948d6", "#2146ed"]};
+    elements.lye.reactions.water = undefined;
+    elements.soap.reactions.water = undefined;
+    elements.ash.solubility = {water: 1.1, func: function(p1, p2){
+        if(p1.elemsDissolved.caustic_potash != undefined){
+            p1.elemsDissolved.caustic_potash += p1.elemsDissolved.ash;
+            p1.elemsDissolved.ash = 0;
+        } else {
+            p1.elemsDissolved.caustic_potash = p1.elemsDissolved.ash;
+            p1.elemsDissolved.ash = 0;
+        }
+        if(p2.dissolved >= 100){
+            changePixel(p2, getItem(["limestone", "quicklime", "charcoal", "dust", "dust"]));
+            p2.dissolved = undefined;
+        }
+    }};
+    elements.water.reactions.ash = undefined;
+    function getItem(obj){
+        let res;
+        if(Array.isArray(obj)){
+            res = obj[Math.round(Math.random()*obj.length)];
+            while(res == null){
+                res = obj[Math.round(Math.random()*obj.length)];
+            }
+        } else {
+            res = obj;
+        }
+        return res;
+    }
+    function aqueousReaction(p1, p2){
+        for(let elem in p1.elemsDissolved){
+            if(elements[elem].reactions != null && p2.element != "water" && (elements[elem].reactions[p2.element] != undefined || (elements[p2.element].reactions != null && elements[p2.element].reactions[elem] != undefined))){
+                
+                let r = elements[elem].reactions[p2.element] || elements[p2.element].reactions[elem];
+                if(r.tempMin && !((p1.temp >= r.tempMin) && (p2.temp >= r.tempMin))){
+                    return false;
+                }
+                if(r.tempMax && !((p1.temp <= r.tempMax) && (p2.temp <= r.tempMax))){
+                    return false;
+			    }
+                if(r.charged && !(p1.charge || p2.charge)){
+                    return false;
+                }
+                let c = (r.chance != undefined) ? r.chance : 1;
+                c = c*((p1.elemsDissolved[elem]/100)/elements[elem].solubility.water);
+                if(Math.random() > c){
+                    return false;
+                }
+                if(r.aqFunc){
+                    r.aqFunc(p1, p2);
+                }
+                if(r.elem1 != undefined){
+                    let e = getItem(r.elem1);
+                    if(elements[e].solubility != undefined && elements[e].solubility.water != undefined){
+                        p1.elemsDissolved[e] = p1.elemsDissolved[elem];
+                        p1.elemsDissolved[elem] = undefined;                      
+                    } else {
+                        if(e === null){
+                            deletePixel(p1.x, p1.y);
+                        } else {
+                            changePixel(p1, e);
+                        }
+                    }
+                }
+                if(r.elem2 != undefined){
+                    changePixel(p2, getItem(r.elem2));
+                }
+                if(r.charge1){
+                    p1.charge = r.charge1;
+                }
+                if(r.charge2){
+                    p2.charge = r.charge2;
+                }
+                if(r.stain1){
+                    stainPixel(p1,r.stain1,0.05);
+                }
+                if(r.stain2){
+                    stainPixel(p2,r.stain2,0.05);
+                }
+            } else if (p2.element == "water"){
+                for(let e2 in p2.elemsDissolved){
+                    if(elements[elem].reactions != undefined && elements[elem].reactions[e2] != undefined){
+                        let r = elements[elem].reactions[e2];
+                        if(r.tempMin && !((p1.temp >= r.tempMin) && (p2.temp >= r.tempMin))){
+                            return false;
+                        }
+                        if(r.tempMax && !((p1.temp <= r.tempMax) && (p2.temp <= r.tempMax))){
+                            return false;
+                        }
+                        if(r.charged && !(p1.charge || p2.charge)){
+                            return false;
+                        }
+                        let c = (r.chance != undefined) ? r.chance : 1;
+                        c = c*((p1.elemsDissolved[elem]/100)/elements[elem].solubility.water);
+                        if(Math.random() > c){
+                            return false;
+                        }
+                        if(r.aqFunc){
+                            r.aqFunc(p1, p2);
+                        }
+                        if(r.elem1 != undefined){
+                            let e = getItem(r.elem1);
+                            if(elements[e].solubility != undefined && elements[e].solubility.water != undefined){
+                                p1.elemsDissolved[e] = p1.elemsDissolved[elem];
+                                p1.elemsDissolved[elem] = undefined;                      
+                            } else {
+                                if(e === null){
+                                    deletePixel(p1.x, p1.y);
+                                } else {
+                                    changePixel(p1, e);
+                                }
+                            }
+                        }
+                        if(r.elem2 != undefined){
+                            let e = getItem(r.elem2);
+                            if(elements[e].solubility != undefined && elements[e].solubility.water != undefined){
+                                p2.elemsDissolved[e] = p1.elemsDissolved[elem];
+                                p2.elemsDissolved[elem] = undefined;                      
+                            } else {
+                                if(e === null){
+                                    deletePixel(p2.x, p2.y);
+                                } else {
+                                    changePixel(p2, e);
+                                }
+                            }
+                        }
+                        if(r.charge1){
+                            p1.charge = r.charge1;
+                        }
+                        if(r.charge2){
+                            p2.charge = r.charge2;
+                        }
+                        if(r.stain1){
+                            stainPixel(p1,r.stain1,0.05);
+                        }
+                        if(r.stain2){
+                            stainPixel(p2,r.stain2,0.05);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    function updateColor(pixel){
+        let c = pixel.oColor;
+        for(let element in pixel.elemsDissolved){
+            //if(elements[element].solubility.color != undefined){
+                let color = (elements[element].solubility.color != undefined) ? getItem(elements[element].solubility.color) : getItem(elements[element].color);
+                /*if(Array.isArray(elements[element].solubility.color)){
+                    color = elements[element].solubility.color[Math.round(Math.random()*elements[element].solubility.color.length)];
+                    while(color == undefined){
+                        color = elements[element].solubility.color[Math.round(Math.random()*elements[element].solubility.color.length)];
+                    }
+                } else {
+                    color = elements[element].solubility.color;
+                }*/
+                if(color.startsWith("#")){
+                    color = hexToRGB(color);
+                } else if(color.startsWith("rgb(")){
+                    color = getRGB(color);
+                }
+                c = interpolateRgb(getRGB(c), color, ((pixel.elemsDissolved[element]/100)/elements[element].solubility.water) || 0.01);
+                //console.log(rgb, color, getRGB(pixel.oColor), ((pixel.elemsDissolved[elem]/100)/elements[elem].solubility.water));
+
+            }
+            pixel.color = c;
+            //}
+    }
+    function solventTick(pixel) {
+        if(pixel.start = pixelTicks+5){
+            pixel.oColor = pixel.color;
+        }
+        pixel.capacity = (1+((pixel.temp-20)/80))*100;
+        for(let coords of adjacentCoords){
+            let x = pixel.x+coords[0], y = pixel.y+coords[1];
+            let p2 = getPixel(x,y);
+            let total = 0;
+            for(let elem in pixel.elemsDissolved){
+                total += pixel.capacity*((pixel.elemsDissolved[elem]/100)/elements[elem].solubility.water);
+            }
+            if(p2 != null){
+                aqueousReaction(pixel, p2);
+            }
+            if(p2 != null && total < pixel.capacity){
+                if(elements[p2.element].solubility != null && elements[p2.element].solubility[pixel.element] != null){
+                    let solubilityObj = elements[p2.element].solubility;
+                    p2.dissolved = (p2.dissolved == undefined) ? elements[p2.element].solubility[pixel.element] : p2.dissolved+elements[p2.element].solubility[pixel.element];
+                    
+                    if(pixel.elemsDissolved[p2.element] == undefined){
+                        pixel.elemsDissolved[p2.element] = elements[p2.element].solubility[pixel.element];
+                    } else {
+                        pixel.elemsDissolved[p2.element] += elements[p2.element].solubility[pixel.element];
+                    }
+                    updateColor(pixel, p2.element);
+                    if(solubilityObj.func != undefined){
+                        solubilityObj.func(pixel, p2);
+                    }
+                    if(p2.dissolved >= 100){
+                        deletePixel(p2.x, p2.y);
+                    }
+                }
+            } else if(total > (pixel.capacity+20) && p2 == null) {
+                let solArr = [], elemArr = [];
+                for(let elem in pixel.elemsDissolved){
+                    elemArr.push(elem);
+                    solArr.push(elements[elem].solubility[pixel.element]);
+                }
+                let index = solArr.indexOf(Math.min(...solArr));
+                if(isEmpty(x,y) && !outOfBounds(x,y)){
+                    createPixel(elemArr[index], x, y);
+                    let max = (pixel.elemsDissolved[elemArr[index]] > (total-pixel.capacity)) ? total-pixel.capacity : pixel.elemsDissolved[elemArr[index]];
+                    pixelMap[x][y].dissolved = 100-max;
+                    updateColor(pixel);
+                    pixel.elemsDissolved[elemArr[index]] -= max;
+                }
+            }
+            else if (p2 != null && p2.element == "water"){
+                for(let elem in pixel.elemsDissolved){
+                    if(p2.elemsDissolved[elem] == undefined) {p2.elemsDissolved[elem] = 0;};
+                    if(p2.elemsDissolved[elem] > pixel.elemsDissolved[elem] && pixel.elemsDissolved[elem]/100 < elements[elem].solubility[pixel.element]){
+                        p2.elemsDissolved[elem]--;
+                        pixel.elemsDissolved[elem]++;
+                        updateColor(pixel);
+                        updateColor(p2);
+                    } else if (p2.elemsDissolved[elem] < pixel.elemsDissolved[elem] && p2.elemsDissolved[elem]/100 < elements[elem].solubility[pixel.element]) {
+                        p2.elemsDissolved[elem]++;
+                        pixel.elemsDissolved[elem]--;
+                        updateColor(pixel);
+                        updateColor(p2);
+                    }
+                }
+            }
+        }
+        if(pixel.temp >= elements[pixel.element].solventTempHigh){
+            let elem = null;
+            let num = Math.random();
+            if(elem === null){
+                for(let e in pixel.elemsDissolved){
+                    if(num <= ((pixel.elemsDissolved[e]/100)/elements[e].solubility.water)/4){
+                        elem = e;
+                    }
+                }
+            }
+            elem = (elem == null) ? "steam" : elem;
+            changePixel(pixel, elem, 110);
+            pixel.dissolvedElems = {};
+        }
+    }
+    behaviors.SOLVENT = function(pixel){
+        let visc = 0;
+        for(let elem in pixel.elemsDissolved){
+            if(elements[elem].solubility.visc != undefined){
+                visc += ((pixel.elemsDissolved[elem]/100)/elements[elem].solubility[pixel.element])*elements[elem].solubility.visc;
+            }
+        }
+        if(elements[pixel.element].viscosity != undefined){
+            visc = visc*(elements[pixel.element].viscosity/1000);
+        }
+        let chance = 1-(visc/1000);
+        let dir = (Math.random()<chance) ? (Math.random() < 0.5) ? 1 : -1 : 0;
+        if(!tryMove(pixel, pixel.x+dir, pixel.y+1) && !tryMove(pixel, pixel.x, pixel.y+1)){
+            tryMove(pixel, pixel.x+dir, pixel.y);
+        }
+    }
+    elements.water.tick = solventTick;
+    elements.water.behavior = behaviors.SOLVENT;
+    elements.water.tempHigh = undefined;
+    elements.water.solventTempHigh = 101;
+	elements.steam.tempLow = 99
+}, true);