studyup 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,315 @@
+//https://www.michaelbromley.co.uk/blog/simple-1d-noise-in-javascript/
+
+var Simple1DNoise = function() {
+    var MAX_VERTICES = 256;
+    var MAX_VERTICES_MASK = MAX_VERTICES -1;
+    var amplitude = 1;
+    var scale = 1;
+
+    var r = [];
+
+    for ( var i = 0; i < MAX_VERTICES; ++i ) {
+        r.push(Math.random());
+    }
+
+    var getVal = function( x ){
+        var scaledX = x * scale;
+        var xFloor = Math.floor(scaledX);
+        var t = scaledX - xFloor;
+        var tRemapSmoothstep = t * t * ( 3 - 2 * t );
+
+        /// Modulo using %
+        var xMin = xFloor % MAX_VERTICES_MASK;
+        var xMax = ( xMin + 1 ) % MAX_VERTICES_MASK;
+
+        var y = lerp( r[ xMin ], r[ xMax ], tRemapSmoothstep );
+
+        return y * amplitude;
+    };
+
+    /**
+    * Linear interpolation function.
+    * @param a The lower integer value
+    * @param b The upper integer value
+    * @param t The value between the two
+    * @returns {number}
+    */
+    var lerp = function(a, b, t ) {
+        return a * ( 1 - t ) + b * t;
+    };
+
+    // return the API
+    return {
+        getVal: getVal,
+        setAmplitude: function(newAmplitude) {
+            amplitude = newAmplitude;
+        },
+        setScale: function(newScale) {
+            scale = newScale;
+        }
+    };
+};
+
+function newHeightMap(pixelType, pixelType2, offset, amplitudes, scales) {
+    return {
+        color: "#000000",
+        behavior: behaviors.WALL,
+        category: "special",
+        hidden: true,
+        state: "solid",
+        offset: 0.5,
+        pixelType: pixelType,
+        pixelType2: pixelType2,
+        offset: offset,
+        amplitudes: amplitudes,
+        scales: scales,
+        generator: Array.from({length: amplitudes.length}, () => new Simple1DNoise()),
+        excludeRandom: true,
+        heightMap: true,
+        tick: function(pixel) {
+            let generator = this.generator;
+            for(let i = 0; i < generator.length; i++)
+            {
+                generator[i].setAmplitude(this.amplitudes[i]);
+                generator[i].setScale(this.scales[i]);
+            }
+            let value = generator.reduce((accumulator, val) => {
+                return accumulator + val.getVal(pixel.x/width);
+                console.log(accumulator);
+            },0);
+            if(value + this.offset + generateTerrainHeights() < pixel.y/height) {
+                let element = this.pixelType;
+                if(Array.isArray(element))
+                {
+                    element = element[Math.floor(Math.random() * element.length)];
+                }
+                if(element == null)
+                {
+                    deletePixel(pixel.x,pixel.y);
+                } else {
+                    changePixel(pixel,element);
+                    if(elements[element].heightMap)
+                    {
+                        elements[element].tick(pixel);
+                    }
+                }
+            } else {
+                let element = this.pixelType2;
+                if(Array.isArray(element))
+                {
+                    element = element[Math.floor(Math.random() * element.length)];
+                }
+                if(element == null)
+                {
+                    deletePixel(pixel.x,pixel.y);
+                } else {
+                    changePixel(pixel,element);
+                    if(elements[element].heightMap)
+                    {
+                        elements[element].tick(pixel);
+                    }
+                }
+            }
+        }
+    };
+}
+
+elements.dunes_height_map = newHeightMap("sand", null, 0.25, [0.75, 0.05, 0.02], [2.5, 20, 200]);
+
+elements.oasis = newHeightMap("water_height", "oasis_height_map", 0.5, [0.02], [200]);
+elements.oasis_height_map = newHeightMap("sand", null, 0.25, [0.75, 0.05, 0.02], [2.5, 20, 200]);
+elements.oasis_height_map2 = newHeightMap("sand", "packed_sand", 0.28, [0.75, 0.05, 0.02], [2.5, 20, 200]);
+elements.oasis_height_map2.generator = elements.oasis_height_map.generator;
+elements.water_height = newHeightMap("oasis_height_map2", "water", 0.25, [0.75, 0.05, 0.02], [2.5, 20, 200]);
+elements.water_height.generator = elements.oasis_height_map.generator;
+worldgentypes.dunes = {
+                fill: [
+                    [0, "dunes_height_map"]
+                ]
+            };
+worldgentypes.oasis = {
+                fill: [
+                    [0, "oasis"]
+                ]
+            };
+
+if (enabledMods.includes("mods/chem.js")) {
+    elements.ptfe_height_map = newHeightMap("polytetrafluoroethylene", "foof_height", 0.5, [0.5, 0.05, 0.02], [2.5, 20, 200]);
+    elements.foof_height = newHeightMap("foof", Array(100).fill(null).concat(["oxygen","fluorine"]), 0.5, [], []);
+    worldgentypes.FOOF_sea = {
+                fill: [
+                    [0, "ptfe_height_map"]
+                ],
+                temperature: -120
+            };
+    elements.francium_height_map = newHeightMap("tungsten", "francium_height", 0.375, [1, 0.2, 0.02], [2.5, 20, 200]);
+    elements.francium_height = newHeightMap("molten_francium", Array(100).fill(null).concat(["radon","radiation","radiation","radiation"]), 0.5, [], []);
+    worldgentypes.francium_lake = {
+                fill: [
+                    [0, "francium_height_map"]
+                ],
+                temperature: 30
+            };
+}
+
+if (enabledMods.includes("mods/structure_test.js")) {
+    elements.smooth_tungsten = {
+    color: "#bcbaae",
+    behavior: behaviors.WALL,
+    tempHigh: 3422,
+    stateHigh: "molten_tungsten",
+    category: "solids",
+    hidden: true,
+    density: 19300,
+    conduct: 0.65,
+    hardness: 0.75
+},
+    elements.francium_reactor = {
+		tick: function(pixel) {
+			for(cx = -4; cx <= 4; cx++) {
+				for(cy = -4; cy <= 4; cy++) {
+					if(cx === 0 && cy === 0) {
+						continue;
+					};
+					var finalCoords = [pixel.x+cx,pixel.y+cy];
+					if(isEmpty(...finalCoords,true)) {
+						continue;
+					} else {
+						var otherPixel = pixelMap[finalCoords[0]][finalCoords[1]];
+						if(otherPixel.element === pixel.element) {
+							deletePixel(...finalCoords);
+						};
+					};
+				};
+			};
+			if(!isEmpty(pixel.x,pixel.y-1,true)) {
+				swapPixels(pixel,pixelMap[pixel.x][pixel.y-1]);
+				return;
+			};
+			if(!tryMove(pixel,pixel.x,pixel.y+1)) {
+                let width = 10 + Math.floor(Math.random() * (8 + 1));
+                let randomHeight = 2 + Math.floor(Math.random() * (2 + 1));
+                var heights = [];
+                for(let i = 1; i <= randomHeight; i++)
+                {
+                    heights.push(Math.floor(i));
+                }
+				var currentHeight = pixel.y + 100;
+                while(currentHeight > pixel.y)
+                {
+                    loadPixelRowFromArray(Array((width)*2-1).fill("tungsten"),pixel.x,currentHeight,true,true);
+                    currentHeight--;
+                }
+                for(let i = 0; i < heights.length; i++)
+                {
+                    for(let j = 0; j < heights[i]; j++)
+                    {
+                        loadPixelRowFromArray(Array((width-i)*2+1).fill("smooth_tungsten"),pixel.x,currentHeight,true,true);
+                        currentHeight--;
+                    }
+                }
+                
+                for(let i = heights.length-1; i >= 0; i--)
+                {
+                    for(let j = 0; j < heights[i]; j++)
+                    {
+                        loadPixelRowFromArray(Array((width-i)*2+1).fill("smooth_tungsten"),pixel.x,currentHeight,true,true);
+                        currentHeight--;
+                    }
+                }
+			};
+		},
+		excludeRandom: true,
+		desc: "Creates a francium reactor for the francium lake worldgen.",
+		cooldown: 6,
+		state: "solid",
+		hardness: 1,
+		category: "structures",
+		color: ["#adadad", "#70b8ba", "#adadad", "#70b8ba", "#adadad"],
+	};
+    elements.francium_height_map = newHeightMap(Array(5000).fill("tungsten").concat(["francium_reactor"]), "francium_height", 0.125, 1, 0.2, 2.5, 20);
+}
+
+
+//override function until fix
+worldGen = function (worldtype) {
+    if(worldtype.fill) {
+        for (var x = 1; x < width; x++) {
+            for (var y = 0; y < height; y++) {
+                var element = null;
+                for (let i = 0; i < worldtype.fill.length; i++) {
+                    if((height-y)/height > worldtype.fill[i][0]) {
+                        element = worldtype.fill[i][1]
+                    } else {
+                        break;
+                    }
+                }
+                if (element) {
+                    createPixel(element,x,y);
+                    if (worldtype.temperature) {
+                        pixelMap[x][y].temp = worldtype.temperature;
+                    }
+                }
+            }
+        }
+    } else {
+    var complexity = worldtype.complexity || 20;
+    var heightVariance = worldtype.heightVariance || 0.5;
+    var baseHeight = height-(height*(worldtype.baseHeight || 0.5));
+    var layers = worldtype.layers || {0:"rock"};
+    var yoffsets = generateTerrainHeights(width,heightVariance,complexity);
+    // 2D world vertical generator
+    for (var x = 1; x < width; x++) {
+        var yoffset = yoffsets[x];
+        var worldHeight = baseHeight+yoffset;
+        for (var y = 0; y < height; y++) {
+            // Change element type based on y, from grass > dirt > rock > basalt
+            if (y > worldHeight) {
+                // distance from the bottom of worldHeight
+                var frombottom = worldHeight-(y-worldHeight);
+                var element = null;
+                for (var i in layers) {
+                    var layer = layers[i];
+                    if (layer[0] == 0 && yoffset < 0) {
+                        layer[0] = yoffset;
+                    }
+                    if (frombottom > worldHeight*layer[0] && Math.random() < (layer[2] || 1)) {
+                        if (elements[layer[1]]) {
+                            element = layer[1];
+                            break
+                        }
+                    }
+                }
+                if (element) {
+                    createPixel(element,x,y);
+                    if (worldtype.temperature) {
+                        pixelMap[x][y].temp = worldtype.temperature;
+                    }
+                }
+            }
+        }
+    }
+    // decor
+    if (worldtype.decor) {
+        for (var i = 0; i < worldtype.decor.length; i++) {
+            var decor = worldtype.decor[i];
+            var element = decor[0];
+            var chance = decor[1];
+            for (var x = 1; x < width; x++) {
+                var y = decor[2] || 5;
+                // add or subtract worldtype.decorVariance from y
+                y += Math.round(Math.random()*(worldtype.decorVariance||2) - (worldtype.decorVariance||2)/2);
+                if (Math.random() < chance && isEmpty(x,y)) {
+                    createPixel(element,x,y);
+                    if (worldtype.temperature) {
+                        pixelMap[x][y].temp = worldtype.temperature;
+                    }
+                    if (decor[3]) {
+                        pixelMap[x][y].color = pixelColorPick(pixelMap[x][y],decor[3])
+                    }
+                }
+            }
+        }
+    }
+    }
+}

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

@@ -0,0 +1,173 @@
+elements.worldgen_test = {
+	color: ["#787674", "#787674", "#787674", "#8c5923", "#8c5923", "#54c942", "#f7f0b0", "#5280eb"],
+	tick: function(pixel) {
+		for (var i = 1; i < width; i++) {
+
+			for (var j = 1; j < height; j++) {
+
+				if (isEmpty(i,j)) {
+
+					if(j >= Math.floor(6*height/7) && j < Math.floor(7*height/7)) {
+
+						if(Math.random() < 0.95) {
+
+							createPixel("rock",i,j)
+
+
+						}
+
+					}
+
+					if(j >= Math.floor(5*height/7) && j < Math.floor(6*height/7)) {
+
+						if(Math.random() < 0.95) {
+
+							if(Math.random() < 1/2) {
+
+								if(i >= Math.floor(11*width/14) && i < Math.floor(14*width/14)) {
+
+									createPixel("sand",i,j)
+
+								} else {
+
+									createPixel("dirt",i,j)
+
+								}
+
+							} else {
+
+								createPixel("rock",i,j)
+
+							}
+
+						}
+
+					}
+
+					if(j >= Math.floor(4*height/7) && j < Math.floor(5*height/7)) {
+
+						if(Math.random() < 0.95) {
+
+							if(i >= Math.floor(11*width/14) && i < Math.floor(14*width/14)) {
+
+								createPixel("sand",i,j)
+
+							} else {
+
+								createPixel("dirt",i,j)
+
+							}
+
+						}
+
+					}
+
+					if(j >= Math.floor(15*height/28) && j < Math.floor(4*height/7)) {
+
+						if(Math.random() < 0.95) {
+
+							if(i < Math.floor(11*width/14)) {
+
+								createPixel("grass",i,j)
+
+							}
+
+						}
+
+					}
+
+				}
+
+			}
+
+		}
+
+		explodeAt(Math.floor(51*width/56),Math.floor(9*height/14),Math.floor(1.8*height/7),fire="water")
+
+		deletePixel(pixel.x,pixel.y)
+
+	},
+	category: "machines",
+	insulate: true,
+	state: "solid",
+	excludeRandom: true,
+}
+
+runAfterLoad(function() {
+  if(enabledMods.includes("mods/minecraft.js")) {
+
+elements.nether_gen_test = {
+	color: ["#751318","#694a20","#f0771a"],
+	tick: function(pixel) {
+		for (var i = 1; i < width; i++) {
+
+			for (var j = 1; j < height; j++) {
+
+				if (isEmpty(i,j)) {
+
+					if(j >= Math.floor(5*height/7) && j < Math.floor(7*height/7)) {
+
+						if(Math.random() < 0.95) {
+
+							if(Math.random() < 2/3) {
+
+								if(i >= Math.floor(11*width/14) && i < Math.floor(14*width/14)) {
+
+									createPixel("soul_sand",i,j)
+
+								} else {
+
+									createPixel("netherrack",i,j)
+
+								}
+
+							} else {
+
+								createPixel("gravel",i,j)
+
+							}
+
+						}
+
+					}
+
+					if(j >= Math.floor(4*height/7) && j < Math.floor(5*height/7)) {
+
+						if(Math.random() < 0.95) {
+
+							if(i >= Math.floor(11*width/14) && i < Math.floor(14*width/14)) {
+
+								createPixel("soul_sand",i,j)
+
+							} else {
+
+								createPixel("netherrack",i,j)
+
+							}
+
+						}
+
+					}
+
+				}
+
+			}
+
+		}
+
+		explodeAt(Math.floor(51*width/56),Math.floor(10*height/14),Math.floor(1.8*height/7),fire="magma")
+
+		if(!isEmpty(Math.floor(51*width/56),Math.floor(10*height/14))) {
+			pixelMap[Math.floor(51*width/56)][Math.floor(10*height/14)].temp += 10**(3*(Math.floor(Math.log10(Math.sqrt((height**2)+(width**2))))))
+		}
+
+		deletePixel(pixel.x,pixel.y)
+
+	},
+	category: "machines",
+	insulate: true,
+	state: "solid",
+	excludeRandom: true,
+	}
+}
+});

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

@@ -0,0 +1,164 @@
+/*
+Version 1.1.0
+*/
+Array.prototype.getClosest = function(num){
+    let arr = [];
+    for(value of this){
+        arr[arr.length] = Math.abs(num-value);
+    };
+    return this[arr.indexOf(Math.min(...arr))];
+}
+function biasedNum(min, max, bias, strength = 0.75){
+    let num = (Math.random()*(max-min))+min;
+    num += Math.random()*1*Math.round((bias-num));
+    return num;
+}
+function generateSeed(min, max, base, bias){
+    let arr = [];
+    for(let i = 0; i <= width; i++){
+        arr[i] = Math.round(biasedNum(min, max, base, bias));
+        base = arr[i];
+    }
+    return arr;
+}
+let vChance = {
+    coal: 0.25,
+    copper: 0.25,
+    tin: 0.25,
+    aluminum: 0.2,
+    iron: 0.175,
+    zinc: 0.17,
+    lead: 0.14,
+    nickel: 0.13,
+    uranium: 0.12,
+    diamond: 0.06,
+    gold: 0.2,
+};
+let vMultipliers = {
+    dirt: 1,
+    sand: 0.25,
+}
+class biome {
+    constructor(layersArr, yLevels, vMulti = 1, afterFunc = false){
+        this.layers = layersArr;
+        this.yLevels = yLevels;
+        this.vMulti = vMulti;
+        this.generate = function(seed){
+            autoResizeCanvas();
+            if(!paused){togglePause();}
+            for(let x = 0; x <= width; x++){
+                for(let y = 0; y <= seed[width]; y++){
+                    let layerHeight = this.yLevels.getClosest(y), layerNum = this.yLevels.indexOf(layerHeight);
+                    let layer = this.layers[layerNum];
+                    let chance = (y-layerHeight)/11;
+                    let elem = layer[Math.round(Math.random()*layer.length)];
+                    if(chance < 0 && (this.layers[layerNum-1] != undefined) && Math.random() <= chance){
+                        layer = this.layers[layerNum-1];
+                        elem = layer[Math.round(Math.random()*layer.length)];
+                    } else if(chance > 0 && (this.layers[layerNum+1] != undefined) && Math.random() <= chance){
+                        layer = this.layers[layerNum+1];
+                        elem = layer[Math.round(Math.random()*layer.length)];
+                    }
+                    if(isEmpty(x,y) && !outOfBounds(x,y)){
+                        createPixel(elem, x, height-y);
+                        if(elem == "sapling"){
+                            if(this.wc){
+                                pixelMap[x][height-y].wc = this.wc;
+                            }
+                            if(this.lc){
+                                pixelMap[x][height-y].lc = this.lc;
+                            }
+                        }
+                    }
+                }
+            }
+            setTimeout(function(){
+                for(let i = 30; i > 0; i--){
+                    doFrame();
+                    focusGame();
+                }
+                for(let x = 0; x <= width; x++){
+                    for(let y = 0; y <= height; y++){
+                        if(!isEmpty(x,y) && !outOfBounds(x,y) && ["rock","sand"].includes(pixelMap[x][y].element)){
+                            for(let coords of squareCoords){
+                                let x2 = x + coords[0], y2 = y + coords[1];
+                                if(!isEmpty(x2,y2) && !outOfBounds(x2,y2) && vChance[pixelMap[x2][y2].element] != undefined){
+                                    let chance = (vChance[pixelMap[x2][y2].element]*vMultipliers[pixelMap[x][y].element])*(this.vMulti || 1);
+                                    if(Math.random() < chance){
+                                        changePixel(pixelMap[x][y], pixelMap[x2][y2].element);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                if(afterFunc != false){
+                    afterFunc();
+                }
+            togglePause();
+            }, 50);
+        };
+    }
+}
+let biomes = {
+    plains: new biome([["rock","dirt","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","diamond","charcoal", "gold", "charcoal", "copper", "copper", "tin", "tin", "aluminum", "iron", "zinc", "lead", "nickel", "uranium"],["dirt","gravel","clay","dirt","dirt","dirt","dirt","dirt","dirt","dirt","dirt","mud"], ["dirt","dirt","dirt","grass","grass","dirt","dirt","grass","dirt","sapling","pinecone","seeds"]], [13, 32, 35], 1, ()=>{for(i = 0; i < width; i++){if(isEmpty(i, 40) && !outOfBounds(i, 40) && Math.random() < 0.25){createPixel("grass",i,40);}}}),
+    desert: new biome([["rock","dirt","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","diamond","charcoal", "charcoal", "copper", "copper", "tin", "tin", "aluminum", "iron", "zinc", "lead", "nickel", "uranium", "gold"], ["sand","sand","sand","sand","sand","sand","sand","sand","sand","sand","sand","sand","sand","gold","iron","copper","tin","aluminum","zinc","charcoal"], ["sand"], ["sand","sand","sand","sand","sand","sand","sand","sand","sand","sand","sand","cactus"]], [4, 14, 27, 37], 1, ()=>{for(i = 0; i < width; i++){if(isEmpty(i, 40) && !outOfBounds(i, 40) && Math.random() < 0.0125){createPixel("cactus",i,40);}}}),
+    savanna: new biome([["rock","clay","clay","clay","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","diamond", "diamond", "charcoal", "charcoal", "gold", "charcoal", "copper", "copper", "copper", "tin", "tin", "aluminum", "iron", "zinc", "lead", "nickel", "uranium"],["dirt","clay","clay","clay","dirt","dirt","dirt","dirt","dirt","dirt","mud"], ["grass","dirt","dirt","sand","sand","sand","dirt","dirt","dirt","sapling","dirt"]], [13, 27, 35], 1.6, ()=>{
+        for(let i = 0; i <= width; i++){
+            let elemArr = ["grass","dirt","dirt","dirt","dirt","dirt","dirt","dirt","dirt","sapling","dirt"], elem = elemArr[Math.round(Math.random()*elemArr.length)];
+            createPixel(elem, i, 40);
+            if(elem == "sapling"){
+                pixelMap[i][40].wc = ["#bdab7e", "#b09c6a", "#ab996d", "#998a63", "#917959", "#877051"];
+                pixelMap[i][40].lc = ["#6fde26", "#8eed34", "#8cdb42", "#7bd12a", "#96e81c", "#a9e64e", "#a0d94c", "#a9d63e"];
+            }
+        }
+    }),
+    tundra: new biome([["rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","iron","tin","gold","diamond", "diamond", "charcoal", "charcoal", "gold", "charcoal", "copper", "copper", "copper", "tin", "tin", "aluminum", "iron", "zinc", "lead", "nickel", "uranium"],["permafrost","permafrost","permafrost","snow","ice","permafrost","permafrost","permafrost","permafrost","permafrost","permafrost"], ["dirt","dirt","mud","dirt","dirt","snow","dirt","mud","mud","dirt","dirt"]], [7, 16, 27], 1.65, ()=>{
+        for(let i = 0; i <= width; i++){
+            let elemArr = ["grass","dirt","dirt","dirt"], elem = elemArr[Math.round(Math.random()*elemArr.length)];
+            createPixel(elem, i, 40);
+        };
+    }),
+};
+biomes.savanna.wc = ["#bdab7e", "#b09c6a", "#ab996d", "#998a63", "#917959", "#877051"];
+biomes.savanna.lc = ["#6fde26", "#8eed34", "#8cdb42", "#7bd12a", "#96e81c", "#a9e64e", "#a0d94c", "#a9d63e"];
+elements.generate = {
+    category: "tools",
+    default: "plains",
+    onSelect: function(){
+        let b = [];
+        for(key in biomes){
+            if(!biomes[key].hide){
+                b[b.length] = key;
+            }
+        }
+        promptChoose("", b, (out)=>{
+            if(biomes[out] == undefined){
+                alert("Invalid Selection.");
+            } else {
+                let seed = generateSeed(27, Math.max(...biomes[out].yLevels)+4, Math.max(...biomes[out].yLevels)+1);
+                biomes[out].generate(seed);
+                elements.generate.default = out;
+                selectElement("dirt");
+            }
+        }, "Select a biome to generate: ");
+    }
+}
+for(item of enabledMods){
+    if(item.includes("plants.js")){
+        biomes.orchard = new biome([["rock","dirt","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","rock","diamond","charcoal", "gold", "charcoal", "copper", "copper", "tin", "tin", "aluminum", "iron", "zinc", "lead", "nickel", "uranium"],["dirt","gravel","clay","dirt","dirt","dirt","dirt","dirt","dirt","dirt","dirt","mud"], ["dirt","dirt","dirt","gravel","dirt","dirt","dirt","dirt","dirt"]], [13, 32, 33], 1, ()=>{
+            for(i = 0; i < width; i++){
+                if(isEmpty(i, 40) && !outOfBounds(i, 40)){
+                    let elemsArr = ["tree", "grass", "dirt", "dirt", "dirt", "dirt", "dirt"], elem = elemsArr[Math.round(Math.random()*elemsArr.length)];
+                    if(elem == "tree"){
+                        let type = plants.tree[Math.round(Math.random()*plants.tree.length)];
+                        let elem = (elements[`${type}_seed`] == undefined) ? "apple_seed" : `${type}_seed`;
+                        createPixel(elem, i, 40);
+                    } else {
+                        createPixel(elem, i, 40);
+                    }
+                }
+            }
+        });
+    }
+}

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

@@ -0,0 +1,34 @@
+function randomOfTwo(option1,option2,leftChance=0.5) {
+	if(Math.random() < leftChance) {
+		return option1;
+	} else {
+		return option2;
+	};
+};
+
+elements.xdct = {
+	name: "x-dependent change test",
+	color: "#cc33cc",
+	hardness: 0.5,
+	density: 2400,
+	behavior: behaviors.POWDER,
+	state: "solid",
+	category: "solids",
+	tick: function(pixel) {
+		var halfWidth = width / 2;
+		var halfHeight = height / 2;
+		var transitionLeftEdge = 4/5 * halfWidth;
+		var transitionRightEdge = 6/5 * halfWidth;
+		var x = pixel.x;
+		if(x < transitionLeftEdge) { //To the left
+			changePixel(pixel,"sand");
+		} else if(x > transitionRightEdge) { //To the right
+			changePixel(pixel,"dirt");
+		} else { //Other (e.g. equal to)
+			var distanceFromLeftEdge = x - transitionLeftEdge;
+			var distanceBetweenEdges = transitionRightEdge - transitionLeftEdge;
+			var relativePosition = distanceFromLeftEdge / distanceBetweenEdges;
+			changePixel(pixel,randomOfTwo("dirt","sand",relativePosition));
+		};
+	},
+};