studyup 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,42 @@
+function FillTool(x,y)
+{
+    if (!isEmpty(x,y))
+    {
+        oldElement = pixelMap[x][y].element;
+    }
+    else
+    {
+        oldElement = undefined;
+    }
+    
+    Fill(x, y, oldElement);
+}
+
+function Fill(x, y, oldElement) 
+{
+    if (x < 0 || x >= width || y < 0 || y >= height) return;
+    
+    if (pixelMap[x][y] !== undefined && oldElement !== undefined)
+    {
+        if (pixelMap[x][y].element != oldElement) return;
+    }
+    else
+    {
+        if (pixelMap[x][y] != oldElement) return;
+    }
+    
+
+    var index = currentPixels.indexOf(pixelMap[x][y]);
+    if (index > -1) 
+    {
+        currentPixels.splice(index, 1);
+    }
+    currentPixels.push(new Pixel(x, y, currentElement));
+    
+    Fill(x + 1, y, oldElement);
+    Fill(x - 1, y, oldElement);
+    Fill(x, y + 1, oldElement);
+    Fill(x, y - 1, oldElement);
+}
+
+// Example: Fill(10, 10, pixelMap[10][10].element);

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

@@ -0,0 +1,115 @@
+var style = document.createElement('style');
+style.type = 'text/css';
+style.id = 'findStatusStylesheet';
+style.innerHTML = '.findStatus { color: #E11; text-decoration: none; }';
+document.getElementsByTagName('head')[0].appendChild(style);
+
+find = false;
+findElement = "sand";
+findColorPulseTimer = 0;
+findColorPulseTimerSubTimer = 0;
+
+function marasi(number) {
+	return Math.min(255,Math.round(Math.abs(Math.sin(number) * 255)));
+};
+		
+function updateFindDescription() {
+	var elems = findElement;
+	if(elems instanceof Array) {
+		elems = elems.join(", ");
+	};
+	elements.find_toggle.desc = `
+<em>I'm running out of keybinds</em>
+
+
+<span class="findStatus">If this text is green or underlined, find mode is on.</span> Currently finding: ${elems} <small style="font-size:80%;">(this display does not update automatically)</small>.
+<span onclick=toggleFind() style="color: #ff00ff;";>Click here</span> to toggle find mode. This highlights the currently selected element.<br/>
+<span style='color:#FF00FF' onClick=findFilterPrompt()>Click here to configure the find filter.</span>`;
+};
+
+function toggleFind() {
+	if(find != true) {
+		find = true;
+		document.getElementById("findStatusStylesheet").innerHTML = '.findStatus { color: #1E1; text-decoration: underline; }'; //Displayed info doen't update until it's pulled up again, so I'm using CSS to dynamically change the color of an element.
+	} else {
+		find = false;
+		document.getElementById("findStatusStylesheet").innerHTML = '.findStatus { color: #E11; text-decoration: none; }';
+	};
+	updateFindDescription();
+};
+
+findHighlighting = function() {
+	//console.log(3);
+	if(!find) {
+		return false;
+	}
+	var newCurrentPixels = currentPixels;
+	var pixelsFirst = [];
+	var pixelsLast = [];
+	var canvas = document.getElementById("game");
+	var ctx = canvas.getContext("2d");
+
+	for (var i = 0; i < newCurrentPixels.length; i++) {
+		pixel = newCurrentPixels[i];
+		//if (pixelMap[pixel.x][pixel.y] == undefined || currentPixels.indexOf(pixel) == -1) {continue}
+		if (pixel.del) {continue};
+		if (elements[pixel.element].isGas) {
+			pixelsLast.push(pixel);
+		} else {
+			pixelsFirst.push(pixel);
+		};
+	};
+
+	var pixelDrawList = pixelsFirst.concat(pixelsLast);
+	for (var i = 0; i < pixelDrawList.length; i++) {
+		pixel = pixelDrawList[i];
+		if (pixelMap[pixel.x][pixel.y] == undefined) {continue};
+		if(findElement instanceof Array ? findElement.includes(pixel.element) : pixel.element === findElement) {
+			ctx.fillStyle = "rgb(255," + marasi(findColorPulseTimer / 10) + ",0)";
+			ctx.fillRect(pixel.x*pixelSize, pixel.y*pixelSize, pixelSize, pixelSize);
+		};
+	};
+	
+	findColorPulseTimerSubTimer++;
+	if(findColorPulseTimerSubTimer >= 2) {
+		findColorPulseTimer++;
+		findColorPulseTimerSubTimer = 0;
+	};
+	
+	return true;
+};
+
+elements.find_toggle = {
+    color: ["#000000", "#000000", "#000000", "#000000", "#ff0000", "#ff0000", "#ff0000", "#ff0000"],
+	name: "find toggle (look at info)",
+    behavior: behaviors.SELFDELETE,
+    category: "tools",
+	excludeRandom: true,
+	desc: `
+<em>I'm running out of keybinds</em>
+
+
+<span class="findStatus">If this text is green or underlined, find mode is on.</span> Currently finding: sand <small style="font-size:80%;">(this display does not update automatically)</small>.
+<span onclick=toggleFind() style="color: #ff00ff;";>Click here</span> to toggle find mode. This highlights the currently selected element.<br/>
+<span style='color:#FF00FF' onClick=findFilterPrompt()>Click here to configure the find filter.</span>`,
+};
+
+function findFilterPrompt() {
+	var preElement = prompt("Enter the elements you want to highlight\nSeparate multiple elements with commas");
+	if(preElement === null || preElement === "") {
+		return false;
+	};
+	if(preElement.includes(",")) {
+		preElement = preElement.split(",");
+		findElement = preElement;
+		updateFindDescription();
+		return findElement;
+	};
+	findElement = preElement;
+	updateFindDescription();
+	return findElement;
+};
+
+renderPostPixel(findHighlighting);
+
+

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

@@ -0,0 +1,121 @@
+/*
+MIT License
+
+Copyright (c) 2024 BatteRaquette58 (a.k.a BatteRaquette581)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+const isFloat = /^[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)$/ // https://stackoverflow.com/questions/12643009/regular-expression-for-floating-point-numbers
+const isIDList = /^\d+(,\d+)*$/
+
+let cloner_elements = []
+// makes cloner elements ignore the new cloner, and vice versa
+const update_ignore_list = () => {
+    const hasCloner = /cloner/ // don't ask why out of all methods to detect a substring in a string, i chose regex
+    let element_keys = Object.keys(elements)
+    cloner_elements = element_keys.filter(element => hasCloner.test(element)) // all elements with "cloner" in their name
+    if (element_keys.includes("liquid_void")) // support for liquid_void.js
+        cloner_elements.push("liquid_void")
+    if (element_keys.includes("destroyable_cloner")) // support for nousersthings.js
+        cloner_elements.push("destroyable_cloner")
+    cloner_elements.forEach(element => {
+        if (elements[element].ignore == null)
+            elements[element].ignore = []
+        elements[element].ignore.push("fine_tuned_cloner")
+    }) // add the new cloner into the ignore list of the cloners
+}
+setTimeout(update_ignore_list, 2000) // i hate the way of doing this, but it's pretty much the only way to make this work...
+
+// check if position has no pixel, if yes, create a new pixel at this position
+const try_place = (element, x, y) => {
+    let succeeded = checkForEmptyPixels(x, y)
+    if (succeeded)
+        createPixel(element, x, y)
+    return succeeded
+}
+
+let FTC_cloning_frequency = null // store cloning frequency
+let FTC_blacklist = null
+elements.fine_tuned_cloner = {
+    color: "#dddd00",
+    behavior: behaviors.WALL,
+    category: "machines",
+    state: "solid",
+    darkText: true,
+
+    onSelect: _ => {
+        let cloning_frequency = prompt("Cloning frequency (how often the cloner clones, 1 being always, 0 being never, can be decimal):")
+        if (isFloat.test(cloning_frequency)) // make sure the user isn't putting something non-numeric
+            cloning_frequency = parseFloat(cloning_frequency)
+        else {
+            alert("Cloning frequency is not a number. Try again.")
+            selectElement("unknown")
+            return
+        }
+        if (!(0 <= cloning_frequency && cloning_frequency <= 1)) { // if not 0-1
+            alert("Cloning frequency is not between 0 and 1. Try again.")
+            selectElement("unknown")
+            return
+        }
+        FTC_cloning_frequency = cloning_frequency
+
+        let blacklist = prompt("Element blacklist (element IDs that the cloner cannot clone, seperated by commas, no trailing commas, leave empty if no blacklist):")
+        if (isIDList.test(blacklist))
+            blacklist = blacklist.split(",") // split blacklist by comma, to make a list of IDs
+        else if (blacklist === "") // if empty, empty blacklist list
+            blacklist = []
+        else {
+            alert("Invalid blacklist. Try again.")
+            selectElement("unknown")
+            return
+        }
+        FTC_blacklist = blacklist
+    },
+
+    tick: pixel => {
+        if (pixel.element === "fine_tuned_cloner") {
+            if (pixel.FTC_element == null) {
+                // assign FTC variables if not done already
+                if (pixel.FTC_cloning_frequency == null)
+                    pixel.FTC_cloning_frequency = FTC_cloning_frequency
+                if (pixel.FTC_blacklist == null)
+                    pixel.FTC_blacklist = FTC_blacklist
+
+                let neighbors = getNeighbors(pixel)
+                if (neighbors.length > 0) { // if there's neighbors
+                    neighbors.forEach(neighbor => {
+                        // make sure it's not a cloner element nor a blacklist element
+                        if ((!cloner_elements.includes(neighbor.element)) && (!pixel.FTC_blacklist.includes(elements[neighbor.element].id))) {
+                            pixel.FTC_element = neighbor.element // set clone element
+                        }
+                    })
+                }
+            }
+
+            if (Math.random() < pixel.FTC_cloning_frequency && pixel.FTC_element != null) { // if cloner already has its cloning element, and it's ready to clone:
+                if (!try_place(pixel.FTC_element, pixel.x, pixel.y - 1)) // try above
+                if (!try_place(pixel.FTC_element, pixel.x - 1, pixel.y)) // try at the left
+                if (!try_place(pixel.FTC_element, pixel.x + 1, pixel.y)) // try at the right
+                if (!try_place(pixel.FTC_element, pixel.x, pixel.y + 1)) // try under
+                    ; // pass, spots are already taken :p
+            }
+        }
+    },
+};

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

@@ -0,0 +1,128 @@
+elements.firefighting_foam = {
+    color: ["#E6F3FF", "#F0F8FF", "#F8FBFF"],
+    behavior: [
+        "XX|CR:foam%2.5|XX",
+        "M2 AND CR:foam%2.5|CH:foam%0.2|M2 AND CR:foam%2.5",
+        "M1|M1|M1",
+    ],
+    category: "liquids",
+    state: "liquid",
+    density: 0.9,
+    temp: 10,
+    conduct: 0.01,
+    stain: 0.01,
+    viscosity: 3000,
+    reactions: {
+        "greek_fire": { elem2: null, chance: 0.2 },
+        "water": { elem1: "foam", elem2: "salt_water", chance: 0.1 },
+        "acid": { elem1: "foam", elem2: "neutral_acid", chance: 0.05 },
+        "acid_gas": { elem1: "foam", elem2: "neutral_acid", chance: 0.05 },
+    },
+    tick: function (pixel) {
+        // Extinguish fire and smoke, remove burning state, and cool down pixels in a 6-pixel radius
+        let radius = 6
+        for (let dx = -radius; dx <= radius; dx++) {
+            for (let dy = -radius; dy <= radius; dy++) {
+                let nx = pixel.x + dx;
+                let ny = pixel.y + dy;
+                if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
+                    let neighborPixel = pixelMap[nx][ny];
+                    if (neighborPixel && neighborPixel.element) {
+                        if (neighborPixel.element === "fire" || neighborPixel.element === "smoke") {
+                            deletePixel(nx, ny);
+                        } else {
+                            // Remove burning state
+                            if (neighborPixel.burning) {
+                                neighborPixel.burning = false;
+                            }
+
+                            // Cool down the pixel
+                            if (neighborPixel.temp > 10) {
+                                neighborPixel.temp = Math.max(10, neighborPixel.temp - 5);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // Decay over time
+        if (Math.random() < 0.005) {
+            changePixel(pixel, "foam");
+        }
+        if (Math.random() < 0.0002) {
+            deletePixel(pixel.x, pixel.y);
+        }
+    }
+};
+
+elements.fire_extinguisher = {
+    color: "#ce2029",
+    behavior: [
+        "XX|XX|XX",
+        "XX|XX|XX",
+        "XX|XX|XX"
+    ],
+    category: "machines",
+    state: "solid",
+    density: 2,
+    temp: 20,
+    conduct: 0.1,
+    tick: function (pixel) {
+        let shouldExplode = false;
+
+        // Check for fire or smoke within a 10-pixel radius
+        let checkRadius = 10;
+        for (let dx = -checkRadius; dx <= checkRadius; dx++) {
+            for (let dy = -checkRadius; dy <= checkRadius; dy++) {
+                let nx = pixel.x + dx;
+                let ny = pixel.y + dy;
+                if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
+                    let neighborPixel = pixelMap[nx][ny];
+                    if (neighborPixel && (neighborPixel.element === "fire" || neighborPixel.element === "smoke")) {
+                        shouldExplode = true;
+                        break;
+                    }
+                }
+            }
+            if (shouldExplode) break;
+        }
+
+        if (shouldExplode) {
+            // Calculate the size of the fire extinguisher block
+            let blockSize = 1;
+            for (let dx = 0; dx < 3; dx++) {
+                for (let dy = 0; dy < 3; dy++) {
+                    let nx = pixel.x + dx - 1;
+                    let ny = pixel.y + dy - 1;
+                    if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
+                        let neighborPixel = pixelMap[nx][ny];
+                        if (neighborPixel && neighborPixel.element === "fire_extinguisher") {
+                            blockSize++;
+                        }
+                    }
+                }
+            }
+
+            // Calculate explosion radius based on block size
+            let explosionRadius = Math.max(blockSize * 5, 10);
+
+            // Create a large explosion of foam
+            for (let dx = -explosionRadius; dx <= explosionRadius; dx++) {
+                for (let dy = -explosionRadius; dy <= explosionRadius; dy++) {
+                    // Check if the pixel is within the circular radius
+                    if (dx * dx + dy * dy <= explosionRadius * explosionRadius) {
+                        let fx = pixel.x + dx;
+                        let fy = pixel.y + dy;
+                        if (fx >= 0 && fx < width && fy >= 0 && fy < height) {
+                            let targetPixel = pixelMap[fx][fy];
+                            if (!targetPixel || targetPixel.element === "air") {
+                                createPixel("firefighting_foam", fx, fy);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+};