studyup 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,23 @@
+const defaultTooltip = "---";
+let tooltipEle;
+window.addEventListener("load", ()=>{
+  tooltipEle = document.createElement("p");
+  tooltipEle.innerHTML = defaultTooltip;
+  setTimeout(()=>{
+    document.getElementById("extraInfo").children[1].appendChild(tooltipEle);
+    let buttons = document.getElementsByClassName("elementButton");
+    [...buttons].forEach(button=>{
+      let ele = button.getAttribute("element");
+      button.addEventListener("mouseenter", e=>{
+        if(elements.hasOwnProperty(ele)) {
+          if(elements[ele].hasOwnProperty("desc")) {
+            tooltipEle.innerHTML = elements[ele].desc;
+          }
+        }
+      });
+      button.addEventListener("mouseleave", e=>{
+        tooltipEle.innerHTML = defaultTooltip;
+      });
+    });
+  });
+});

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

@@ -0,0 +1,20 @@
+elements.led_r = { 
+    ...elements.led, 
+    customColor: false, 
+    color: "rgb(255,0,0)", 
+    colorObject: {r:255, g:0, b:0} 
+};
+
+elements.led_g = { 
+    ...elements.led, 
+    customColor: false, 
+    color: "rgb(0,255,0)", 
+    colorObject: {r:0, g:255, b:0} 
+};
+
+elements.led_b = { 
+    ...elements.led, 
+    customColor: false, 
+    color: "rgb(0,0,255)", 
+    colorObject: {r:0, g:0, b:255} 
+};

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

@@ -0,0 +1,85 @@
+elements.on_try_move_into_test = {
+	color: "#ffffff",
+	properties: {
+		ticks: 0,
+		attemptedMovesIntoPixel: 0,
+	},	
+	behavior: behaviors.POWDER,
+	reactions: {
+		"dirt": { elem1: "diamond" },
+	},
+	state: "solid",
+	hidden: true,
+	excludeRandom: true,
+	category: "special",
+	density: 1000,
+	tick: function(pixel) {
+		pixel.ticks++;
+	},
+	onTryMoveInto: function(pixel,otherPixel) {
+		pixel.attemptedMovesIntoPixel++;
+		var otherElement = otherPixel.element;
+		if(otherElement === "ash") {
+		console.log(`This is a test of potentially undesired multiplicate running. (tick: ${pixelTicks}, move attempts: ${pixel.attemptedMovesIntoPixel})`);
+			//if(deletePixel(pixel.x,pixel.y)) {
+			//	console.log("This pixel has been deleted.");
+			//};
+		};
+	},
+	desc: "Try burying this pixel and see what happens. (Use Debug)\n\nonTryMoveInto is run as part of tryMove, <em>before reactions</em>, while tick functions are run as part of pixelDraw.\n<span style='color:red;'>In some circumstances, such as a pixel being buried under a pile of anything that isn't a sturdy powder, this function may run multiple times per tick.</span> For example, bury this pixel in ash and look in the console.\n\nTo use this function, include in your element definition the \"onTryMoveInto\" key with a function value, similarly to tick functions. This function takes two arguments; \"otherPixel\" is the pixel that is trying to move and \"pixel\" is the pixel whose position otherPixel is trying to move into.",
+	related: ["debug", "ash"],
+}
+
+function tryMove(pixel,nx,ny,leaveBehind,force) {
+	if (pixel.drag && !force) { return true; }
+	var info = elements[pixel.element];
+	var oob = outOfBounds(nx,ny);
+	if (isEmpty(nx,ny,false,oob)) { // If coords is empty, move to coords
+		//console.log(`Moving ${pixel.element} (${pixel.x},${pixel.y}) to (${nx},${ny})`);
+		movePixel(pixel,nx,ny,leaveBehind);
+		return true;
+	}
+	else if (!oob) {
+		//console.log(`Moving ${pixel.element} (${pixel.x},${pixel.y}) to (${nx},${ny})`);
+		// Reactions
+		newPixel = pixelMap[nx][ny];
+		var newInfo = elements[newPixel.element];
+		var returnVal = false;
+		if(newInfo.onTryMoveInto !== undefined) {
+			newInfo.onTryMoveInto(newPixel,pixel);
+			if(!pixel || pixel.del) {
+				return "deleted";
+			};
+			returnVal = true;
+		}
+		var rr1 = false;
+		if (info.reactions !== undefined && info.reactions[newPixel.element] !== undefined) {
+			rr1 = reactPixels(pixel,newPixel)
+			if (rr1) {
+				return true;
+			}
+		}
+		if (!rr1 && elements[newPixel.element].reactions !== undefined && elements[newPixel.element].reactions[pixel.element] !== undefined && !elements[newPixel.element].reactions[pixel.element].oneway) {
+			if (reactPixels(newPixel,pixel)) {
+				return true;
+			}
+		}
+		// Density
+		if (elements[pixel.element].id !== elements[newPixel.element].id) {
+			if (info.density !== undefined && elements[newPixel.element].density !== undefined) {
+				// if the pixel's state + ">" + newPixel's state is in validDensitySwaps, and the pixel's density is larger than the newPixel's density, swap the pixels
+				if (validDensitySwaps[info.state][elements[newPixel.element].state] && info.density >= elements[newPixel.element].density) {
+					// chance depending on the difference in density
+					if (Math.random() < (info.density - elements[newPixel.element].density)/(info.density + elements[newPixel.element].density)) {
+						swapPixels(pixel,newPixel);
+						return true;
+					}
+				}
+			}
+		}
+		if(returnVal) {
+			return true;
+		}
+	}
+	return false;
+}

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

@@ -0,0 +1,146 @@
+window.addEventListener('load', function() {
+    console.log("attempted override")
+	pixelColorPick = function(pixel,customColor=null) {
+        var element = pixel.element;
+        var elementInfo = elements[element];
+        //if (elementInfo.behavior instanceof Array) {
+        
+        if (pixel.charge && elementInfo.colorOn) {
+            customColor = elementInfo.colorOn;
+        }
+        if (customColor != null) {
+            if (Array.isArray(customColor)) {
+                customColor = customColor[0];
+            }
+            if (customColor.startsWith("#")) {
+                customColor = hexToRGB(customColor);
+            }
+            var rgb = customColor;
+        }
+        else {
+            var rgb = elements[element].colorObject; // {r, g, b}
+            // If rgb is an array, choose a random item
+            if (Array.isArray(rgb)) {
+                rgb = rgb[0];
+            }
+        }
+        // Randomly darken or lighten the RGB color
+        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;
+        // Make sure the color is within the RGB range
+        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+")";
+        
+        /*}
+        else {
+            var color = elementInfo.color;
+            if (Array.isArray(color)) {
+                color = color[Math.floor(Math.random() * color.length)];
+            }
+        }*/
+        return color;
+    }
+    pixelTempCheck = function(pixel){
+        if (pixel.del) { return }
+        var elementInfo = elements[pixel.element];
+        if (pixel.temp < absoluteZero) { // Absolute Zero
+            pixel.temp = absoluteZero;
+        }
+        // If the pixel's temp >= the elementInfo tempHigh, change pixel.element to elementInfo.stateHigh
+        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 result is an array, choose a random item
+            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);
+                    // Make sure the color is within the RGB range
+                    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);
+                }
+            }
+        }
+        // If the pixel's temp <= the elementInfo tempLow, change pixel.element to elementInfo.stateLow
+        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 result is an array, choose a random item
+            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);
+                    // Make sure the color is within the RGB range
+                    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/orchidslibrary.js

@@ -0,0 +1,70 @@
+/*
+*Version 1.0.0
+*/
+function noiseify(color, range){
+    if(color.startsWith("#")){
+        color = hexToRGB(color);
+    } else {
+        color = getRGB(color);
+    }
+    let num = Math.round(Math.random()*(range*2))-range;
+    for(let value in color){
+        color[value] += num;
+    }
+    return `rgb(${color.r},${color.g},${color.b})`;
+}
+
+function is2d(arr){
+  return arr.some(item => Array.isArray(item));
+}
+
+function colorMix(p1, p2, bias = 0.5){
+	c1 = p1.color;
+	p1.color = interpolateRgb(getRGB(p1.color), getRGB(p2.color), bias);
+	p2.color = interpolateRgb(getRGB(c1), getRGB(p2.color), bias);
+}
+
+function interpolateRgb(rgb1, rgb2, ratio = 0.5) {
+  const interpolatedRgb = {
+    r: Math.round(rgb1.r + (rgb2.r - rgb1.r) * ratio),
+    g: Math.round(rgb1.g + (rgb2.g - rgb1.g) * ratio),
+    b: Math.round(rgb1.b + (rgb2.b - rgb1.b) * ratio),
+  };
+  return normalize(interpolatedRgb);
+}
+
+function getRGB(rgb){
+	if(rgb.startsWith("rgb(")){
+		let rgb2 = rgb.replace(")", "").replace("rgb(", "").replace(/,/g, "r").split("r")
+		return { r: parseInt(rgb2[0]), g: parseInt(rgb2[1]), b: parseInt(rgb2[2]) };
+	}  else {
+		return hexToRGB(rgb2);
+	}
+}
+function pixelToggle(pixel, multi = {r:1,g:1,b:1}){
+    if(pixel.toggle != undefined){
+        pixel.toggle = !pixel.toggle;
+        let rgb;
+        if(Array.isArray(elements[pixel.element].color)){
+            let elemColor = elements[pixel.element].color[Math.round(Math.random()*elements[pixel.element].color.length)];
+            rgb = hexToRGB(elemColor) || getRGB(elemColor);
+        } else {
+            let elemColor = elements[pixel.element].color;
+            rgb = hexToRGB(elemColor) || getRGB(elemColor);
+        }
+        let num = 5 - Math.round(Math.random()*10);
+        if(pixel.toggle){
+            for(let key in rgb){
+                rgb[key] += (100*multi[key]);
+                rgb[key] = Math.round(Math.max(Math.min(rgb[key], 255), 0));
+            }
+            pixel.color = `rgb(${rgb.r+num},${rgb.g+num},${rgb.b+num})`;
+        } 
+        else {
+            pixel.color = `rgb(${rgb.r+num},${rgb.g+num},${rgb.b+num})`;
+        }
+    }
+}
+function normalize(obj){
+    return `rgb(${obj.r},${obj.g},${obj.b})`;
+}

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

@@ -0,0 +1,232 @@
+function makePerlinMap(){
+    return Array.from({ length: Math.pow(12, 2) }, () => Math.random() * 2 * Math.PI);
+}
+function perlinNoise(C, x, y) {
+    // Helper function to calculate dot product
+    function dotProduct(a, b) {
+        return a[0] * b[0] + a[1] * b[1];
+    }
+
+    // Function d
+    function d(index) {
+        return [Math.cos(C[index]), Math.sin(C[index])];
+    }
+
+    // Function f
+    function f(x, y, t) {
+        return x + (y - x) * (6 * t ** 5 - 15 * t ** 4 + 10 * t ** 3);
+    }
+
+    // Function g
+    function g(x, y, z, w) {
+        const dx = x - z;
+        const dy = y - w;
+        return dotProduct([dx, dy], d(z + w * 6 + 1));
+    }
+
+    // Main function h
+    const x0 = Math.floor(x);
+    const x1 = Math.ceil(x);
+    const y0 = Math.floor(y);
+    const y1 = Math.ceil(y);
+
+    const g00 = g(x, y, x0, y0);
+    const g10 = g(x, y, x1, y0);
+    const g01 = g(x, y, x0, y1);
+    const g11 = g(x, y, x1, y1);
+
+    const fx = f(g00, g10, x - x0);
+    const fy = f(g01, g11, x - x0);
+
+    return Math.sqrt(2) * f(fx, fy, y - y0);
+}
+function getScalingFactor(d1, d2){
+    return Math.min(d1, d2)/6
+}
+function scaledPerlinNoise(C, x, y){
+    let scale = getScalingFactor(width, height)
+    return perlinNoise(C, x/scale, y/scale)
+}
+if (!eLists.oreSpawnConditions){eLists.oreSpawnConditions = {}}
+eLists.oreSpawnConditions = {...eLists.oreSpawnConditions, ...{
+    uranium: 0.67,
+    diamond: 0.67,
+    gold: 0.57,
+    pyrite: 0.56,
+    silver: 0.54,
+    iron: 0.47,
+    copper: 0.42,
+    charcoal: 0.42
+}}
+if (!eLists.oreRgb){eLists.oreRgb = {}}
+eLists.oreRgb = {...eLists.oreRgb, ...{
+    charcoal: "rgba(54, 54, 54, ",
+    iron: "rgba(247, 218, 157, ",
+    silver: "rgba(206, 206, 206, ",
+    copper: "rgba(151, 80, 10, ",
+    gold: "rgba(255, 215, 0, ",
+    pyrite: "rgba(134, 119, 31, ",
+    diamond: "rgba(125, 214, 255, ",
+    uranium: "rgba(0, 100, 8, "
+}}
+if (!eLists.idealOreHeight){eLists.idealOreHeight = {}}
+eLists.idealOreHeight = {...eLists.idealOreHeight, ...{
+    uranium: 0.2,
+    diamond: 0.06,
+    gold: 0.3,
+    pyrite: 0.34,
+    silver: 0.4,
+    iron: 0.7,
+    copper: 0.6,
+    charcoal: 0.4
+    }}
+let oldclearall = clearAll
+let oreMap = []
+clearAll = function(skipworldgen){
+    oreMap = []
+    oldclearall(skipworldgen)
+    oreMaps = {}
+    for (let ore of Object.keys(eLists.oreSpawnConditions)){
+        oreMaps[ore] = makePerlinMap()
+    }
+     //console.log(oreMaps)
+    for (let x in pixelMap){
+        oreMap.push([]);
+        for (let y in pixelMap){
+            oreMap[x].push(false);
+            for (let ore in eLists.oreSpawnConditions){
+                if ((scaledPerlinNoise(oreMaps[ore], x, y)-((Math.abs(y-((1-eLists.idealOreHeight[ore])*height)))/(1.33*height))+0.07) > eLists.oreSpawnConditions[ore]){
+                    oreMap[x][y] = ore
+                    //console.log(ore + " at " + x + ", " + y)
+                    break;
+                }
+            }
+        }
+    }
+}
+
+adjacentToCanvas = function(x, y, px, py){
+    if (x == 0 && y == -1){
+        return [[canvasCoord(px), canvasCoord(py)], [canvasCoord(px)+pixelSize, canvasCoord(py)]]
+    }
+    if (x == 0 && y == 1){
+        return [[canvasCoord(px), canvasCoord(py)+pixelSize], [canvasCoord(px)+pixelSize, canvasCoord(py)+pixelSize]]
+    }
+    if (x == -1 && y == 0){
+        return [[canvasCoord(px), canvasCoord(py)], [canvasCoord(px), canvasCoord(py)+pixelSize]]
+    }
+    if (x == 1 && y == 0){
+        return [[canvasCoord(px)+pixelSize, canvasCoord(py)], [canvasCoord(px)+pixelSize, canvasCoord(py)+pixelSize]]
+    }
+}
+renderEachPixel(function(pixel, ctx) {
+    if (currentElement == "ore_xray") {
+        if (Math.abs(pixel.x - mousePos.x) <= mouseSize/2 && Math.abs(pixel.y - mousePos.y) <= mouseSize/2) {
+            if (!oreMap[pixel.x][pixel.y]) {
+                drawSquare(ctx, "rgba(0, 0, 0, 0.7)", pixel.x, pixel.y, 1, 1);
+            } else {
+                drawSquare(ctx, eLists.oreRgb[oreMap[pixel.x][pixel.y]] + "0.7)", pixel.x, pixel.y, 1, 1);
+                let differentAdjacent = [];
+                for (let i = 0; i < adjacentCoords.length; i++) {
+                    let x = adjacentCoords[i][0] + pixel.x;
+                    let y = adjacentCoords[i][1] + pixel.y;
+                    if (isEmpty(x, y, true)) {
+                        differentAdjacent.push(adjacentCoords[i]);
+                    } else {
+                        let otherPixel = pixelMap[x][y];
+                        if (oreMap[x][y] != oreMap[pixel.x][pixel.y] && (oreMap[x][y] == false || eLists.oreSpawnConditions[oreMap[pixel.x][pixel.y]] >= eLists.oreSpawnConditions[oreMap[x][y]])) {
+                            differentAdjacent.push(adjacentCoords[i]);
+                        }
+                    }
+                }
+                differentAdjacent.forEach(adj => {
+                    let canvasadjacentCoords = adjacentToCanvas(adj[0], adj[1], pixel.x, pixel.y);
+                //    if (!canvasadjacentCoords){
+                //        console.log(adj)
+                //        return;
+               //     }
+                    //console.log(canvasadjacentCoords);
+                    ctx.beginPath();
+                    ctx.moveTo(canvasadjacentCoords[0][0], canvasadjacentCoords[0][1]);
+                    ctx.lineTo(canvasadjacentCoords[1][0], canvasadjacentCoords[1][1]);
+                    ctx.strokeStyle = eLists.oreRgb[oreMap[pixel.x][pixel.y]]+"1)";
+                    ctx.lineWidth = 4;
+                    ctx.stroke();
+                    //console.log("line")
+                });
+            }
+        }
+    }
+    if (oreMap.length < 2){
+        clearAll();
+    }
+});
+
+let validGroundElements = []
+for (let elementi in elements){
+    if (elements[elementi].category == "land"){
+        validGroundElements.push(elementi)
+    }
+}
+elements.pickaxe = {
+    category: "tools",
+    color: "#b0b0b0",
+    canPlace: false,
+    maxSize: 5,
+    tool: function(pixel){
+        if (oreMap[pixel.x][pixel.y].length > 0 && validGroundElements.includes(pixel.element)){
+            if (Math.random()>0.95){
+                changePixel(pixel, oreMap[pixel.x][pixel.y], false)
+                oreMap[pixel.x][pixel.y] = false
+            }
+            else if (Math.random() > 0.9){
+                deletePixel(pixel.x, pixel.y)
+                oreMap[pixel.x][pixel.y] = false
+            }
+        }
+        if (settings.limitless){elements.pickaxe.maxSize = 10000} else {elements.pickaxe.maxSize = 5}
+    }
+}
+elements.chisel = {
+    category: "tools",
+    color: "#8d8574",
+    canPlace: false,
+    maxSize: 3,
+    tool: function(pixel){
+        if (oreMap[pixel.x][pixel.y].length > 0 && validGroundElements.includes(pixel.element)){
+            if (Math.random()>0.95){
+                changePixel(pixel, oreMap[pixel.x][pixel.y], false)
+                oreMap[pixel.x][pixel.y] = false
+            }
+            else if (Math.random() > 0.98){
+                deletePixel(pixel.x, pixel.y)
+                oreMap[pixel.x][pixel.y] = false
+            }
+        }
+        if (settings.limitless){elements.chisel.maxSize = 10000} else {elements.chisel.maxSize = 3}
+    }
+}
+elements.brush = {
+    category: "tools",
+    color: "#805c2e",
+    canPlace: false,
+    maxSize: 1,
+    tool: function(pixel){
+        if (oreMap[pixel.x][pixel.y].length > 0 && validGroundElements.includes(pixel.element)){
+            if (Math.random()>0.985){
+                changePixel(pixel, oreMap[pixel.x][pixel.y], false)
+                oreMap[pixel.x][pixel.y] = false
+            }
+        }
+        if (settings.limitless){elements.brush.maxSize = 10000} else {elements.brush.maxSize = 1}
+    }
+}
+elements.ore_xray = {
+    category: "tools",
+    color: "#220f27",
+    canPlace: false,
+    maxSize: 15,
+    tool: function(pixel){
+        if (settings.limitless){elements.ore_xray.maxSize = 10000} else {elements.ore_xray.maxSize = 15}
+    }
+}