studyup 0.0.0-stage → 1.0.1

package/sandboxels-package/sandboxels-1.13.2/mods/1.10example.js

@@ -0,0 +1,118 @@
+
+
+
+/* == Custom View Modes == */
+
+viewInfo[4] = { // Small Pixels
+    name: "grid",
+    pre: function(ctx) {
+        // run any code before pixels are rendered
+        drawSquare(ctx,"#00ff00",20,20,5);
+    },
+    pixel: function(pixel,ctx) {
+        // run any code when each individual pixel is rendered
+        drawSquare(ctx,pixel.color,pixel.x,pixel.y,0.66)
+    },
+    post: function(ctx) {
+        // run any code after pixels are rendered
+        drawPlus(ctx,"#ff0000",10,10) // Like a gas
+    }
+};
+
+// Number keys will automatically switch views.
+
+
+
+/* == Custom Element Renderers == */
+
+elements.ball.renderer = function(pixel,ctx) {
+    // Draw three horizontal squares
+    drawSquare(ctx,"#00ff00",pixel.x-1,pixel.y);
+    drawSquare(ctx,"#00ff00",pixel.x,pixel.y);
+    drawSquare(ctx,"#00ff00",pixel.x+1,pixel.y);
+};
+
+
+
+/* == Custom Global Renderers == */
+
+renderEachPixel(function(pixel,ctx) {
+    // run any code when each individual pixel is rendered
+    if (pixel.element === "rock") {
+        drawSquare(ctx,"#00ff00",pixel.x,pixel.y-1);
+    }
+})
+renderPrePixel(function(ctx) {
+    // run any code before pixels are rendered
+    drawSquare(ctx,"#ff00ff",10,40);
+})
+renderPostPixel(function(ctx) {
+    // run any code after pixels are rendered
+    drawSquare(ctx,"#ffff00",30,40);
+})
+
+runPerPixel(function(pixel) {
+    // run any code on each pixel every tick
+    tryMove(pixel,pixel.x+1,pixel.y);
+})
+
+runEveryTick(function() {
+    // run any code after pixels are simulated per tick
+    if (pixelTicks % 90 === 0) {
+        logMessage("tick"+pixelTicks);
+    }
+})
+
+
+// If you NEED to overwrite drawPixels(), which is NOT RECOMMENDED, you must return true.
+/*
+oldDrawPixels = drawPixels;
+drawPixels = function(forceTick=false) {
+    oldDrawPixels(forceTick);
+    // ...
+    return true;
+};
+*/
+
+
+
+/* == Custom canvas layers == */
+
+// WARNING: Performance may decrease. Use canvasLayers.pixels unless necessary.
+addCanvasLayer("effects");
+// One of the following is required to have the layer render automatically.
+canvasLayersPost.push(canvasLayers["effects"]); // Render after pixels
+// canvasLayersPre.push(canvasLayers["effects"]); // Render before pixels
+
+effectsCtx = canvasLayers["effects"].getContext("2d");
+
+
+
+/* == Custom Keybinds == */
+
+keybinds["Digit7"] = function(e) {
+    console.log(e);
+}
+
+// Override existing keybind
+keybinds["KeyH"] = function() {
+    logMessage("H was pressed!");
+}
+
+
+
+/* == New Element Events == */
+
+elements.slime.onPlace = function(pixel) {
+    logMessage(pixel.element+" placed")
+}
+elements.slime.onDelete = function(pixel) {
+    logMessage(pixel.element+" deleted at "+pixelTicks)
+}
+elements.slime.onChange = function(pixel,element) {
+    logMessage(pixel.element+" changed into "+element)
+}
+elements.slime.onBreak = function(pixel) {
+    // breakInto property not necessary to fire
+    logMessage(pixel.element+" broken")
+}

package/sandboxels-package/sandboxels-1.13.2/mods/10kelements.js

@@ -0,0 +1,172 @@
+var elementslist = []
+for (elementi in elements){
+    elementslist.push(elementi)
+}
+async function _GNPrompt(message, title = "Prompt", defaultValue = "") { // thanks to ggod
+    return new Promise(resolve => {
+        promptInput(message, (result) => {
+            resolve(result);
+        }, title, defaultValue);
+    })
+}
+elements.change_count = {
+  color: "#34eb86",
+  canPlace: false,
+  behavior: behaviors.SELFDELETE,
+  onSelect: async function() {
+    var cans = await _GNPrompt("Please input how many elements you would like to be generared each time.", "10kelements.js is asking you...", 10000);
+    if (!cans) { return }
+    if (cans == "skin"){settings.randomcount = 10000; settings.skineasteregg = true; settings.sandeasteregg = false; saveSettings(); promptText("skin", () => {}); return}
+    if (cans == "sand"){settings.randomcount = 10000; settings.skineasteregg = false; settings.sandeasteregg = true; promptText("sand", () => {console.log("alert code is ran")}); console.log("log code is ran"); saveSettings(); return}
+    if (cans > 100000){promptText("You have put too big of a number! This would surely crash your browser or eat up all your RAM! Element count will remain unchanged.", () => {}); return}
+    if (cans < 1 && (parseInt(cans) > -1) ){promptText("You have either put a decimal or zero. Why? Element count will remain unchanged.", () => {}); return}
+    if (isNaN(parseInt(cans))){promptText("Apparently your input isnt even a number. Try again. Element count will remain unchanged.", () => {}); return}
+    settings.randomcount = parseInt(cans)
+    settings.skineasteregg = false;
+    settings.sandeasteregg = false;
+    saveSettings()
+  }, 
+  category: "random"
+}
+var choosebehaviors = behaviors
+delete choosebehaviors.KILLPIXEL2
+delete choosebehaviors.KILLPIXEL1
+if (!settings.randomcount || settings.randomcount > 100000){settings.randomcount = 10000; saveSettings()}
+var color = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "a", "b", "c", "d", "e","f"]
+var states = ["solid", "liquid", "gas"]
+var essentialelements = ["molten_gallium", "gallium", "gallium_gas", "change_count"]
+var sandelements = ["erase", "sand", "change_count"]
+var total = 0
+var dangerouselements = ["supernova", "n_explosion", "pn_explosion", "armageddon", "nuke", "h_bomb"]
+function randomIntFromInterval(min, max) { // min and max included 
+    return Math.floor(Math.random() * (max - min + 1) + min)
+  }
+var randomProperty = function (obj) {
+    var keys = Object.keys(obj);
+    return obj[keys[ keys.length* Math.random() << 0]];
+};
+if (Math.abs(settings.randomcount) == settings.randomcount && !settings.sandeasteregg){
+  if (!settings.skineasteregg){
+  for (var i = 1; i <= settings.randomcount; i++){
+      var canHeat = Math.random() < 0.2
+      var canCold = Math.random() < 0.2
+      elements["element_"+i] = {
+          color:  "#" + color[Math.floor(Math.random()*color.length)] + color[Math.floor(Math.random()*color.length)] + color[Math.floor(Math.random()*color.length)] + color[Math.floor(Math.random()*color.length)] + color[Math.floor(Math.random()*color.length)] + color[Math.floor(Math.random()*color.length)],
+          category: "random",
+          behavior: randomProperty(choosebehaviors),
+          state: states[Math.floor(Math.random()*states.length)],
+          reactions: {},
+          density: randomIntFromInterval(1, 10000)
+      }
+      total = i
+      if (canHeat){
+          elements["element_"+i].tempHigh = 20 + randomIntFromInterval(10, 6000)
+          elements["element_"+i].stateHigh = elementslist[Math.floor(Math.random()*elementslist.length)]
+      }
+      if (canCold){
+          elements["element_"+i].tempLow = 20 - randomIntFromInterval(10, 270)
+          elements["element_"+i].stateLow = elementslist[Math.floor(Math.random()*elementslist.length)]
+      }
+      for (r = 0; r < 10; r++){
+          elements["element_"+i].reactions[elementslist[Math.floor(Math.random()*elementslist.length)]] = { elem1: elementslist[Math.floor(Math.random()*elementslist.length)], elem2: elementslist[Math.floor(Math.random()*elementslist.length)]}
+      }
+    //  console.log(i + " is done!")
+    //  console.log(i)
+    //  console.log(elements["element_"+i].behavior)
+    if (elements["element_" + i].density == i){
+      console.log(i + "is unique because its density is the same as its id!")
+    }
+    for (var reaction in elements["element_" + i].reactions){
+      if (dangerouselements.includes(elements["element_" + i].reactions[reaction].elem1)|| dangerouselements.includes(elements["element_" + i].reactions[reaction].elem2)){
+          console.log(i + " is scary due to its reaction with " + reaction)
+          if (!elements["element_"+i].desc){
+          elements["element_" + i].desc = "This is scary! Don't let it touch " + reaction
+          }else(elements["element_"+i].desc += (" or " + reaction))
+      }
+    }
+    for (var reaction in elements["element_" + i].reactions){
+      if (elements[elements["element_"+i].reactions[reaction].elem1].category == "tools" || elements[elements["element_"+i].reactions[reaction].elem2].category == "tools"){
+          console.log(i + " makes a tool...? when it touches " + reaction)
+          if (!elements["element_"+i].desc){
+          elements["element_" + i].desc = "This breaks the laws of physics if it touches " + reaction
+          }else(elements["element_"+i].desc += (" or " + reaction))
+      }
+    }
+  }
+} else {
+  for (var i = 1; i <= settings.randomcount; i++){
+    elements["skin_" + i] = {
+      color: elements.skin.color,
+      category: "skin",
+      tick: function(pixel){
+        changePixel(pixel, "skin", false)
+      },
+      density: elements.skin.color,
+      behavior: behaviors.WALL,
+      state: "solid",
+      name: "skin"
+    }
+  }
+}
+} else if (!(settings.sandeasteregg)) {
+  window.addEventListener('load', function() {
+    elementslist = []
+    for (elementi in elements){
+      elementslist.push(elementi)
+  }
+  var eLen = elementslist.length
+    const p = document.createElement("p");
+p.innerText = `v${currentversion} • ` +(eLen - Math.abs(settings.randomcount)) +` elements, with 0 hidden`;
+document.getElementById("extraInfo").querySelectorAll("small")[1].replaceChildren(p);
+  if (Math.abs(settings.randomcount) > elementslist.length){
+    console.log("mode 1")
+    for (var elementi in elements){
+      if(!essentialelements.includes(elementi)){
+      document.getElementById("elementButton-" + elementi)?.remove()
+      console.log(elementi)
+      }
+    }
+  } else for (var i = 1; i <= Math.abs(settings.randomcount); i++){
+    var elementi = elementslist[Math.floor(Math.random()*elementslist.length)]
+    if(!essentialelements.includes(elementi)){
+      elementslist.splice(elementslist.indexOf(elementi), 1)
+    document.getElementById("elementButton-" + elementi)?.remove()
+    console.log(elementi)
+    }
+  }
+})
+} else {
+  runAfterAutogen(
+    function(){
+      for (elementi in elements){
+        elements[elementi].category = "sand"
+      }
+    }
+  )
+    window.addEventListener('load', function() {
+    elementslist = []
+    for (elementi in elements){
+      elementslist.push(elementi)
+  }
+  var eLen = elementslist.length
+    const p = document.createElement("p");
+p.innerText = `v${currentversion} • ` +3 +` elements, with 0 hidden`;
+document.getElementById("extraInfo").querySelectorAll("small")[1].replaceChildren(p);
+  if (Math.abs(settings.randomcount) > elementslist.length){
+    console.log("mode 1")
+    for (var elementi in elements){
+      if(!sandelements.includes(elementi)){
+      document.getElementById("elementButton-" + elementi)?.remove()
+      console.log(elementi)
+      }
+    }
+  } else for (var i = 1; i <= eLen; i++){
+    var elementi = elementslist[Math.floor(Math.random()*elementslist.length)]
+    if(!(sandelements.includes(elementi))){
+      elementslist.splice(elementslist.indexOf(elementi), 1)
+    document.getElementById("elementButton-" + elementi)?.remove()
+    console.log(elementi)
+    }
+  }
+})
+}

package/sandboxels-package/sandboxels-1.13.2/mods/3pms_mod.js

@@ -0,0 +1,144 @@
+// made by 3pm
+
+version = "0.0.2"
+subversion = "0.0.21"
+versionname = "Let's take a look..."
+
+console.log("3pms_mod.js " + version + " \"" + versionname + "\"")
+console.log("3pms_mod.js | Initiating...")
+
+// bypassing the tps limit
+
+function tpsPrompt() {
+    promptInput("Enter the new simulation Ticks Per Second (TPS). This is how many updates per second the simulation will run.\n\nThe default is 30.\n\nThe current TPS is " + tps + ".\n\nNOTE: 3pms_mod.js removes the TPS limit.\nAny TPS higher than 1000 isn't recommended.\n\n",
+        (r) => {
+            var newtps = parseInt(r);
+            if (r !== null) {
+                if (isNaN(newtps) || newtps == "") logMessage("You did not enter a valid TPS.");
+                else {
+                    newtps = parseInt(newtps);
+                    if (isNaN(newtps) || newtps <= 0) {
+                        logMessage("You did not enter a valid TPS.");
+                    }
+                    else {
+                        tps = newtps;
+                        delete currentSaveData.oldTps;
+                    }
+                }
+                resetInterval(tps);
+            }
+            focusGame();
+        },
+        "Change TPS"
+    )
+}
+
+// more settings
+
+function showMoreSettings() {
+    showingMenu="moresettings"
+    console.log("3pms_mod.js | Opening More Settings....")
+    var moresettingsParent = document.getElementById("moresettingsParent");
+    moresettingsParent.style.display = "block";
+}
+
+setTimeout(() => {
+    const gamediv = document.getElementById("gameDiv")
+    gamediv.insertAdjacentHTML("beforeend", `
+        <div id="moresettingsParent" style="display: none" class="menuParent">
+            <div id="moresettingsMenu">
+                <button class="XButton" onclick="closeMenu();showSettings();">-</button>
+                <span class="menuTitle">More Settings</span>
+                <div class="menuText" style="padding-top:1em">
+                    <p>Nothing to see here ;3</p>
+                </div>
+            </div>
+        </div>`);
+    const menuText = document.getElementsByClassName("menuText")[9]
+    const newButton = document.createElement("button")
+    newButton.innerText = "More Settings"
+    newButton.className = "settingsButton"
+    newButton.onclick = () => {
+        closeMenu();
+        showMoreSettings()
+    }
+    menuText.appendChild(newButton)
+}, 1000);
+
+// elements
+
+elements.calcium_oxide = {
+    color: ["#544E45","#6A635E","#6E6A61","#756F62","#918A7B"],
+    tick: function(pixel) {
+        behaviors.POWDER(pixel);
+        for (var i = 0; i < adjacentCoords.length; i++) {
+            var x = pixel.x+adjacentCoords[i][0];
+            var y = pixel.y+adjacentCoords[i][1];} },
+    tempHigh: 842,
+    reactions: {
+        water: {elem1:"calcium_oxide", elem2:"steam"},
+        salt_water: {elem1:"calcium_oxide", elem2:"steam"},
+        sugar_water: {elem1:"calcium_oxide", elem2:"steam"},
+        dirty_water: {elem1:"calcium_oxide", elem2:"steam"}
+    },
+    category: "powders",
+    state: "solid",
+    density: 1550,
+    conduct: 0.40,
+    hardness: 0.2,
+    fireColor: "#ff6b21"
+}
+
+elements.eeraser = {
+    color: "#FFFF00",
+    behaviorOn: [
+        "DL|XX|DL",
+        "DL|XX|DL",
+        "DL|DL|DL",
+    ],
+    behavior: [
+        "XX|XX|XX",
+        "XX|XX|XX",
+        "XX|XX|XX"
+    ],
+    conduct: 0.5,
+    category: "machines",
+    state: "solid",
+};
+
+// tools
+elements.replace_all_of_element = {
+    color: ["#ff3030", "#800000"],
+    name: "replace all of element",
+    onSelect: async function() {
+        promptInput(
+            "Enter the element to be replaced.",
+            (r) => {
+                if (r in elements) {
+                    elements.replace_all_of_element.tool = function(pixel) {
+                        elementbefore = pixel.element
+                        for (var i = 0; i <= width; i++) {
+                            for (var j = 0; j <= height; j++) {
+                                if (!isEmpty(i,j,true)) {
+                                    if(pixelMap[i][j].element == elementbefore) {
+                                        changePixel(pixelMap[i][j], r)
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    logMessage("You did not enter an existing element.");
+                }
+            },
+            "3pms_mod.js"
+        );
+    },
+    category: "tools",
+};
+
+
+
+setTimeout(() => {
+    console.log("3pms_mod.js | Initiated. Thank you.")
+}, 1000);

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

@@ -0,0 +1,55 @@
+// AnonymousWorldgenLibrary.js \\
+// A useful mod that provides a function to generate terrain when placing an element, could not be used a lot but can be useful \\
+
+
+
+    function generateWorld(pixel, layers = [], startX = -500, endX = 500, baseY = 82) {
+    deletePixel(pixel.x, pixel.y); // Deletes the pixel that triggered the generation
+    for (let x = startX; x <= endX; x++) {
+        layers.forEach((layer, layerIndex) => {
+            const y = baseY - layerIndex; // Each layer is placed one row above the previous
+
+            // Check if the spot is empty and passes the chance check
+            if (Math.random() < layer.chance) {
+                tryCreate(layer.element, x, y); // Creates the pixel
+            }
+        });
+    }
+    selectElement(null);
+}
+
+
+// ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+//  generateWorld Function Reference:
+// pixel: The generateWorld function is used in onPlace(pixel), the reason of including pixel is to delete it.
+// layers: An array of layer objects like this:
+//         [{element: "yourElement", chance: 0.5}, {...}, ...]
+//         Each layer is placed one row above the previous.
+//         'chance' must be between 0 and 1 — higher means more likely to generate.
+// startX / endX: Horizontal range to generate across. Default is -500 to 500.
+// baseY: Vertical starting point for the bottom layer. Default is 82 (bottom of medium canvas).
+//
+//  Tip: To insert empty space between layers, use an empty object: {}
+// Example: [layer1, {}, layer3] will skip one row between layer1 and layer3.
+// Fact: The index 0 layer will be placed at the baseY, and the index 1 layer will be placed in baseY - 1, so when looking at the code, it looks upside down.
+// Note: If someone is using tinier or bigger canvas size then this may not work as needed, you should make a case for each canvas size
+// ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+
+
+// Example usage of generateWorld
+elements.generateWorldExample = {
+    color: "#808080",
+    category: "World Generator",
+    onPlace: (pixel) => {
+        generateWorld(pixel, [
+            {element: "dirt", chance: 0.65},
+            {element: "dirt", chance: 0.65},
+            {element: "dirt", chance: 0.65},
+            {element: "dirt", chance: 0.65},
+            {element: Math.random() < 0.1 ? "grass_seed" : "grass", chance: 0.6},
+            {}/* Space between grass/grass_seed and sapling */,
+            {element: "sapling", chance: 1 / 6}
+        ]);
+    },
+    maxSize: 1
+};