/* 
Use intellisense for sandboxels modding here:
    to show availavle functions and show global variables
    https://github.com/Cube14yt/sandboxels-types
*/


// Changelog
/*
V1
Solids: Aerogel, Nordic Gold, Nordic Gold coin, Pyrite
Machines: Disco Ball
Extras: Fire Extinguisher Powder

V2
Machines: Button, Disco Floor, Faulty Wire, Randomizer,
Tools: Press, Circle
Solids: Cardboard, Obsidian
Powders: Glow Stick, Obsidian Shard
Liquids: Glow Stick Liquid, Lighter fluid, Gasoline
Life: Mold, Moss, 
Gases: Lighter Fluid Gas
Food: Pie, Pie Crust

V3
Tools: RGB LED, Dice, Custom Bomb
Life: Pineapple Plants (seed, stem, fruit)
Hazards: Lithium Battery, Lithium, Rubidium, Asbestos
Minerals: Chalk, Chalk Powder, Lapis Lazuli
Light: UV Light, Phosphor, Neon Tube
Extras: Realistic Ball

V3.1
Bug Fixes
Chalk powder, Wet chalk poeder, and Obsidian shard can now be glued back as intended.
Dog can now be smashed correctly.
Steam support with promptInput() instead of prompt()

V3.2
Machines: Robot, Adjustable heater/cooler

Bug Fixes
Fixed compatibility issue with nousersthings.js

V4
Machines: Paper filter, Indestructable filter, and Note block
Life: Cacao Plants (seed, stem, fruit)
Tools: Polish
Extras: 2 ways to make an element with no name
Special: Black hole
Building Materials: Roman concrete/cement

V5
Machines: Random Teleporter
Life: Carrot seed and fruit
Minerals: Quartz and Quartz powder
Special: Random Word Generator, Fill all,
Element fill all, Pulsing Color, Element line, White hole

Changes:
    Moved sandstone to land category

Technical:
    New helpers for squareCoords and adjacentCoords
    Rainbow color preset
*/
let globals = {
    circleRad: 7,
    circleElem: "wood",
    red: randomIntInRange(0, 255),
    green: randomIntInRange(0, 255),
    blue: randomIntInRange(0, 255),
    explodeElem: "fire",
    adjusted_heater_temp: 100
}

const rainbowColor = ["#ff0000", "#ff8800", "#ffff00", "#00ff00", "#00ffff", "#0000ff", "#ff00ff"]

elements.button = {
    color: "#970000",
    conduct: 1,
    charge: 0,
    category: "machines",
    behavior: behaviors.WALL,
    state: "solid",
    onSelect: function () {
        logMessage("Click the button with no elements equipped to charge the button.")
    },
    properties: {
        clicked: false,
        clickTime: 1,
    },
    onClicked: function (pixel) {
        pixel.clicked = true
        pixel.clickTime = 1
    },
    tick: function (pixel) {
        if (pixel.clicked == true && pixel.clickTime > 0) {
            pixel.charge = 1
            pixel.clickTime--
        }
        else if (pixel.clicked == true && pixel.clickTime <= 0) {
            pixel.clicked = false
            pixel.charge = 0
        }
    }
}


function isPressable(pixel) {
    if (elements[pixel.element].pressInto !== undefined) return true;
}

elements.aerogel = {
    color: "#79ffff",
    category: "solids",
    behavior: behaviors.WALL,
    state: "solid",
    tempHigh: 1200,
    stateHigh: "ash",
    insulate: true,
    density: 0.2,
    hardness: 0.1,
    breakInto: "dust",
    onPlace: function (pixel) {
        if (pixel.alpha === undefined) { pixel.alpha = Math.random() * (0.5 - 0.4) + 0.4 }
    }
}

let oldCopperReactions = elements.copper.reactions
elements.molten_copper.reactions.molten_aluminum = { elem1: "molten_nordic_gold", elem2: null, chance: 0.5 }
elements.acid.ignore.push("nordic_gold")
elements.acid.ignore.push("nordic_gold_coin")

elements.nordic_gold = {
    color: ["#f1db7c", "#e5c34b", "#d2a742", "#b98c31", "#a47320"],
    tempHigh: 1060,
    behavior: behaviors.WALL,
    category: "solids",
    state: "solid",
    density: 8800,
    conduct: 0.90,
    breakInto: "nordic_gold_coin"
}

elements.nordic_gold_coin = {
    color: ["#f1db7c", "#e5c34b", "#d2a742", "#b98c31", "#a47320"],
    tempHigh: 1060,
    stateHigh: "molten_nordic_gold",
    behavior: behaviors.POWDER,
    category: "powders",
    state: "solid",
    density: 8800,
    conduct: 0.90,
    alias: "euro_coin",
    reactions: {
        "glue": { elem1: "nordic_gold", elem2: null }
    }
}

function randomColor() {
    const letters = "0123456789ABCDEF";
    let color = "#";
    for (let i = 0; i < 6; i++) {
        color += letters[Math.floor(Math.random() * 16)];
    }
    return color;
}

elements.disco_ball = {
    color: "#ebebc3",
    buttonColor: rainbowColor,
    renderer: renderPresets.LED,
    behavior: behaviors.WALL,
    category: "machines",
    tempHigh: 1500,
    stateHigh: ["molten_glass", "molten_glass", "molten_copper"],
    conduct: 1,
    breakInto: "glass_shard",
    forceSaveColor: true,
    tick: function (pixel) {
        if (!pixel.charge) {
            pixel.charge = 0
        }
        for (var i = 0; i < squareCoords.length; i++) {
            var coord = squareCoords[i];
            var x = pixel.x + coord[0];
            var y = pixel.y + coord[1];
            if (pixel.charge > 0) {
                pixel.color = randomColor()
                if (isEmpty(x, y)) {
                    createPixel("light", x, y)
                    let p = getPixel(x, y)
                    if (p !== null && p.element == "light") {
                        p.color = pixel.color
                    }
                }
            }
            else { pixel.color = "#ebebc3" }
        }
    },
    state: "solid"
}

elements.molten_iron.reactions.sulfur = { elem1: "pyrite", elem2: null, chance: 0.25 }
elements.molten_iron.reactions.molten_sulfur = { elem1: "pyrite", elem2: null, chance: 0.25 }
elements.molten_iron.reactions.sulfur_gas = { elem1: "pyrite", elem2: null, chance: 0.25 }

elements.pyrite = {
    color: ["#d8c25e", "#bbaa49", "#998f3e"],
    alias: ["fools_gold", "Iron Disulfide"],
    density: 5000,
    tempHigh: 1177,
    stateHigh: ["iron", "molten_sulfur"],
    grain: 0.4,
    state: "solid",
    behavior: behaviors.WALL,
    category: "solids"
}

elements.fire_extinguisher_powder = {
    color: "#ececec",
    behavior: [
        "XX|XX|XX",
        "XX|DL%1|XX",
        "M2%30|M1%30|M2%30"
    ],
    extinguish: true,
    tick: function (pixel) {
        for (var i = 0; i < adjacentCoords.length; i++) {
            var coords = adjacentCoords[i];
            var x = pixel.x + coords[0];
            var y = pixel.y + coords[1];
            if (getPixel(x, y)?.burning === true) {
                let elem = getPixel(x, y)
                elem.burning = false
            }
        }
    },
    tool: function (pixel) {
        if (pixel.burning === true) {
            delete pixel.burning;
            delete pixel.burnStart;
        }
    },
    canPlace: true,
    category: "powders",
    state: "solid"
}

elements.pie_crust = {
    color: "#f1f192",
    breakInto: "crumb",
    tempHigh: 500,
    stateHigh: "ash",
    burn: 5,
    burnTime: 400,
    burnInto: ["smoke", "smoke", "smoke", "ash"],
    category: "food",
    state: "solid",
    behavior: behaviors.STURDYPOWDER,
    isFood: true,
    hidden: true,
    density: 230,
    reactions: {
        "pumpkin": { elem1: "pie", elem2: null, tempMin: 200 },
        "cooked_meat": { elem1: "pie", elem2: null, tempMin: 200 },
        "meat": { elem1: "pie", elem2: null, tempMin: 200 },
        "potato": { elem1: "pie", elem2: null, tempMin: 200 },
        "mashed_potato": { elem1: "pie", elem2: null, tempMin: 200 },
        "baked_potato": { elem1: "pie", elem2: null, tempMin: 200 },
        "grape": { elem1: "pie", elem2: null, tempMin: 200, func: function (pixel) { pixel.originColor = "#8200fc" } },
        "pineapple": { elem1: "pie", elem2: null, tempMin: 200, func: function (pixel) { pixel.originColor = "#ffd900" } }
    }
}

elements.pie = {
    color: "#fac145",
    darkText: false,
    behavior: behaviors.STURDYPOWDER,
    category: "food",
    isFood: true,
    density: 240,
    burn: 5,
    burnTime: 400,
    burnInto: ["smoke", "smoke", "smoke", "ash"],
    state: "solid",
    tempHigh: 500,
    stateHigh: "ash",
    breakInto: "sauce",
    breakIntoColor: ["#ff822e", "#ff8c2e"],
    tick: function (pixel) {
        if (pixel.originColor) {
            pixel.breakIntoColor = pixel.originColor
        }
    }
}

elements.gasoline = {
    color: ["#ffff66", "#ffff55", "#ffff44"],
    behavior: behaviors.LIQUID,
    burn: 80,
    burnTime: 100,
    burnInto: ["fire", "fire", "fire", "explosion"],
    viscosity: 0.7,
    density: 750,
    category: "liquids",
    state: "liquid",
    conduct: 0.02,
    behaviorOn: [
        "XX|XX|XX",
        "XX|EX:10|XX",
        "XX|XX|XX"
    ]
}

// Make molten sulfur stinky
elements.molten_sulfur.tick = function (pixel) {
    for (var i = 0; i < adjacentCoords.length; i++) {
        var coords = adjacentCoords[i];
        var x = pixel.x + coords[0];
        var y = pixel.y + coords[1];
        if (isEmpty(x, y) && Math.random() <= 0.0005) {
            createPixel("stench", x, y)
            let p = getPixel(x, y)
            if (p !== null && p.element == "stench") {
                p.temp = pixel.temp
            }
        }
    }
}

elements.disco_floor = {
    color: rainbowColor,
    breakInto: "glass_shard",
    category: "machines",
    forceSaveColor: true,
    conduct: 1,
    behavior: behaviors.WALL,
    state: "solid",
    tick: function (pixel) {
        pixel.changeCd ??= 20;
        pixel.changeCd--;

        if (pixel.changeCd <= 0) {
            let colors = elements.disco_floor.color;
            pixel.color = colors[Math.floor(Math.random() * colors.length)];
            pixel.changeCd = 20;
        }
    }
};

elements.moss = {
    color: ["#007900", "#006000", "#008300"],
    behavior: behaviors.POWDER,
    tick: function (pixel) {
        for (var i = 0; i < squareCoords.length; i++) {
            var coords = squareCoords[i];
            var x = pixel.x + coords[0];
            var y = pixel.y + coords[1];
            if (isEmpty(x, y) && Math.random() <= 0.01 && getPixel(pixel.x, pixel.y + 1) && getPixel(pixel.x, pixel.y + 1).element !== "moss") {
                createPixel('moss', x, y)
            }
        }
    },
    tempHigh: 70,
    stateHigh: "dead_plant",
    extraTempHigh: {
        "100": ["dead_plant", "dead_plant", "steam"]
    },
    tempLow: -10,
    stateLow: "frozen_plant",
    burn: 50,
    burnTime: 30,
    reactions: {
        "carbon_dioxide": { elem2: "oxygen", chance: 0.1 },
        "rock": { elem2: "dirt", chance: 0.0025 },
        "rock_wall": { elem2: "dirt", chance: 0.0025 },
        "gravel": { elem2: "dirt", chance: 0.0025 },
    },
    category: "life",
    state: "solid"
}

elements.magma.extraTempLow = { "700": "obsidian" }

elements.obsidian = {
    color: ["#1f1f1f", "#1f1f1f", "#1f1f1f", "#1f1f1f", "#292929"],
    buttonColor: ["#1a1a1a", "#2b2b2b", "#3b3b3b"],
    colorPattern: textures.GLASS,
    colorKey: {
        "g": "#1f1f1f",
        "s": "#292929",
        "S": "#252525"
    },
    grain: 0,
    behavior: behaviors.WALL,
    category: "solids",
    tempHigh: 1200,
    stateHigh: "magma",
    state: "solid",
    density: 2500,
    breakInto: "obsidian_shard"
}

elements.obsidian_shard = {
    color: ["#1f1f1f", "#1f1f1f", "#1f1f1f", "#1f1f1f", "#292929"],
    behavior: behaviors.POWDER,
    grain: 0,
    category: "powders",
    tempHigh: 1200,
    stateHigh: "magma",
    state: "solid",
    density: 2500,
    reactions: {
        "glue": { elem1: "obsidian", elem2: null }
    }
}

elements.cardboard = {
    color: ["#9E6B34"],
    burn: 70,
    burnTime: 300,
    burnInto: ["fire", "fire", "fire", "fire", "fire", "ash"],
    behavior: behaviors.WALL,
    reactions: {
        "water": { elem1: "cellulose", elem2: null },
        "dirty_water": { elem1: "cellulose", elem2: null },
        "salt_water": { elem1: "cellulose", elem2: null },
        "sugar_water": { elem1: "cellulose", elem2: null },
        "seltzer": { elem1: "cellulose", elem2: null },
        "soda": { elem1: "cellulose", elem2: null },
        "blood": { elem1: "cellulose", elem2: null },
        "foam": { elem1: "cellulose", elem2: null },
        "bubble": { elem1: "cellulose", elem2: null },
        "oil": { elem1: "cellulose", elem2: null },
        "alcohol": { elem1: "cellulose", elem2: null },
        "vinegar": { elem1: "cellulose", elem2: null }
    },
    category: "solids",
    tempHigh: 248,
    stateHigh: ["fire", "fire", "fire", "fire", "fire", "ash"],
    state: "solid",
    density: 1200
}

elements.paper.pressInto = "cardboard"

function pressPixel(pixel) {
    if (elements[pixel.element].pressInto === undefined) { return; }
    // if it is an array, choose a random item, else just use the value
    let result;
    if (elements[pixel.element].pressInto !== undefined) {
        if (Array.isArray(elements[pixel.element].pressInto)) {
            result = elements[pixel.element].pressInto[Math.floor(Math.random() * elements[pixel.element].pressInto.length)];
        }
        else {
            result = elements[pixel.element].pressInto;
        }
    }
    // change the pixel to the result
    if (result === null) {
        deletePixel(pixel.x, pixel.y);
        return;
    }

    else if (result !== undefined) {
        changePixel(pixel, result);
    }
}

elements.press = {
    color: ["#999999", "#c0c0c0", "#999999"],
    category: "tools",
    tool: function (pixel) {
        // edited smash code
        if (isPressable(pixel)) {
            let old = pixel.element
            if (Math.random() < (1 - (elements[pixel.element].resistPress || 0)) / (shiftDown ? 1 : 4)) {
                pressPixel(pixel)
            }

            else if (old === pixel.element && elements[pixel.element].movable && !isEmpty(pixel.x, pixel.y + 1) && !paused) {
                let x = 0; let y = 0;
                if (Math.random() < 0.66) x = Math.random() < 0.5 ? 1 : -1;
                if (Math.random() < 0.66) y = Math.random() < 0.5 ? 1 : -1;
                tryMove(pixel, pixel.x + x, pixel.y + y)
            }
        }
        if (elements[pixel.element].onPress !== undefined) {
            elements[pixel.element].onPress(pixel)
        }
    }
}

elements.malware.reactions.wire = { elem2: [null, "faulty_wire"], chance: 0.01 };

elements.faulty_wire = {
    color: ["#4d0a03", "#4d0a03", "#4d0a03", "#4d0a03", "#4d0a03", "#4d0a03", "#4d0a03", "#4d0a03", "#4d0a03", "#a95232",],
    buttonColor: "#4d0a03",
    behavior: behaviors.WALL,
    behaviorOn: [
        "XX|CR:electric,flash%1|XX",
        "CR:electric,flash%1|XX|CR:electric,flash%1",
        "XX|CR:electric,flash%1|XX"
    ],
    category: "machines",
    insulate: true,
    conduct: 0.7,
    noMix: true,
    state: "solid"
}

elements.lighter_fluid = {
    color: "#f1e185",
    behavior: [
        "XX|XX|XX",
        "M2 AND SW:lighter_fluid_gas|XX|M2 AND SW:lighter_fluid_gas",
        "M1 AND SW:lighter_fluid_gas|M1 AND SW:lighter_fluid_gas|M1 AND SW:lighter_fluid_gas"
    ],
    category: "liquids",
    state: "liquid",
    density: 750,
    tick: function (pixel) {
        pixel.gasMade ??= 0
        for (var i = 0; i < squareCoordsShuffle.length; i++) {
            var coord = squareCoordsShuffle[i];
            var x = pixel.x + coord[0];
            var y = pixel.y + coord[1];
            if (isEmpty(x, y) && Math.random() >= 0.75) {
                createPixel("lighter_fluid_gas", x, y)
                pixel.gasMade += 1
            }
        }

        if (pixel.gasMade > 100 && Math.random() <= 0.01) {
            deletePixel(pixel.x, pixel.y)
        }
    }
}

elements.lighter_fluid_gas = {
    color: "#f1e185",
    alpha: 0.1,
    behavior: behaviors.GAS,
    category: "gases",
    state: "gas",
    burn: 100,
    isGas: true,
    hidden: true,
    density: 20,
    tick: function (pixel) {
        if (Math.random() <= 0.1) {
            deletePixel(pixel.x, pixel.y)
        }
    }
}

elements.mold = {
    color: "#054e05",
    category: "life",
    behavior: behaviors.POWDER,
    state: "solid",
    burn: 70,
    burnTime: 100,
    tempHigh: 200,
    stateHigh: "fire",
    tempLow: -10,
    stateLow: "frozen_plant",
    reactions: {
        "meat": { elem1: "rotten_meat", elem2: "rotten_meat" },
        "cheese": { elem1: "rotten_cheese", elem2: "rotten_cheese" }
    },
    tick: function (pixel) {
        let moldable = ["meat", "cheese", "rotten_meat", "rotten_cheese"]
        for (var i = 0; i < squareCoords.length; i++) {
            var coords = squareCoords[i];
            var x = pixel.x + coords[0];
            var y = pixel.y + coords[1];
            if (isEmpty(x, y) && Math.random() <= 0.01 && getPixel(pixel.x, pixel.y + 1) && moldable.includes(getPixel(pixel.x, pixel.y + 1).element)) {
                createPixel('mold', x, y)
            }
        }
    }
}

elements.glow_stick = {
    color: ["#00ff00", "#ea00ff", "#00eeff"],
    glow: true,
    behavior: behaviors.POWDER,
    breakInto: "glow_stick_liquid",
    category: "powders",
    tempHigh: 300,
    stateHigh: ["molten_plastic", "stench"],
    state: "solid"
}

elements.glow_stick_liquid = {
    color: ["#00ff00", "#ea00ff", "#00eeff"],
    glow: true,
    behavior: behaviors.LIQUID,
    category: "liquids",
    hidden: true,
    tempHigh: 300,
    stateHigh: "stench",
    tempLow: -5,
    stateLow: "glow_stick_ice",
    state: "solid"
}

elements.glow_stick_ice = {
    color: ["#00ff00", "#ea00ff", "#00eeff"],
    behavior: behaviors.WALL,
    category: "states",
    hidden: true,
    temp: -5,
    tempHigh: -5,
    stateHigh: "glow_stick_liquid",
    state: "solid"
}

// Add TPS keybind
keybinds["KeyT"] = function () {
    tpsPrompt()
}

function addRowWhenReady() {
    const table = document.getElementById("controlsTable");

    if (!table) {
        // Table not ready yet, try again in 100ms
        setTimeout(addRowWhenReady, 100);
        return;
    }

    // Table exists, add the row
    const rowCount = table.rows.length;
    const newRow = table.insertRow(rowCount - 1);

    const cell1 = newRow.insertCell(0);
    const cell2 = newRow.insertCell(1);

    cell1.textContent = "Change TPS";
    cell2.innerHTML = "<kbd>T</kbd>";

    console.log("Row added successfully!");
}

// Start the process
addRowWhenReady();


elements.randomizer = {
    buttonColor: rainbowColor,
    excludeRandom: true,
    onSelect: function () {
        logMessage("Warning: It can fill up the screen with random elements")
    },
    tick: function (pixel) {
        pixel.color = randomColor()
        for (var i = 0; i < adjacentCoords.length; i++) {
            var coords = adjacentCoords[i];
            var x = pixel.x + coords[0];
            var y = pixel.y + coords[1];
            let p = getPixel(x, y)
            if (!isEmpty(x, y) && !outOfBounds(x, y)) {
                if (p && p.element !== "randomizer") {
                    changePixel(p, "random")
                }
            }
        }
    },
    behavior: behaviors.WALL,
    insulate: true,
    hardness: 1,
    category: "special",
    state: "solid"
}

elements.cloner.ignore.push("randomizer")
elements.ecloner.ignore.push("randomizer")
elements.floating_cloner.ignore.push("randomizer")
elements.slow_cloner.ignore.push("randomizer")
elements.rocket.ignore.push("randomizer")

elements.antibomb.tick = function (pixel) {
    doDefaults(pixel)
    if (!tryMove(pixel, pixel.x, pixel.y + 1)) {
        if (!outOfBounds(pixel.x, pixel.y + 1)) {
            var elem = pixelMap[pixel.x][pixel.y + 1].element;
            if (elements[elem].isGas) { return }
        }
        else {
            var elem = "smoke";
        }
        if (elem !== "antibomb" && elem !== "randomizer") {
            explodeAt(pixel.x, pixel.y, 8, elem)
        }
    }
}

function drawCircle(x0, y0, radius, element) {
    for (let y = -radius; y <= radius; y++) {
        for (let x = -radius; x <= radius; x++) {
            if (x * x + y * y <= radius * radius) {
                let px = x0 + x;
                let py = y0 + y;
                if (isEmpty(px, py)) {
                    createPixel(element, px, py);
                }
            }
        }
    }
}

elements.circle = {
    color: "#ffffff",
    behavior: behaviors.WALL,
    category: "special",
    state: "solid",
    onSelect: function () {
        promptInput(
            "Select the radius you want your circle to be:",
            function (input1) {
                let ans1 = Number(input1)
                if (Number.isInteger(ans1) && ans1 > 0) {
                    globals.circleRad = ans1
                } else {
                    globals.circleRad = 7
                    logMessage("Invalid radius, using default size: " + globals.circleRad);
                }
                promptInput(
                    "Select the element you want your circle to be:",
                    function (ans2) {
                        let similar = mostSimilarElement(ans2);
                        if (similar && elements[similar]) {
                            globals.circleElem = similar;
                        } else {
                            globals.circleElem = "wood"
                            logMessage("Invalid element, using default element: " + globals.circleElem);
                        }
                    },
                    "Element prompt",
                    "wood"
                );
            },
            "Radius prompt",
            "7"
        );
    },
    onPlace: function (pixel) {
        drawCircle(pixel.x, pixel.y, globals.circleRad, globals.circleElem);
        changePixel(pixel, globals.circleElem);
        pixel.temp = (elements[globals.circleElem].temp || 20)
    },
    maxSize: 1,
    excludeRandom: true
};

runAfterReset(function () {
    if (globals.rCircle) {
        globals.circleRad = 7;
        globals.circleElem = "wood";
    }
})

/**
 * gets a random int in a range
 * @param {number} min 
 * @param {number} max 
 * @returns {number}
 */
function randomIntInRange(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}



elements.rgb_led = {
    buttonColor: rainbowColor,
    behavior: behaviors.WALL,
    desc: "Input the red, green, and blue value (not exceeding 255) and get the color.",
    renderer: renderPresets.LED,
    conduct: 1,
    state: "solid",
    breakInto: "glass_shard",
    forceSaveColor: true,
    reactions: {
        "light": { charge1: 1, elem2: null },
        "liquid_light": { charge1: 1, elem2: null }
    },
    category: "machines",
    tempHigh: 1500,
    stateHigh: ["molten_glass", "molten_glass", "molten_glass", "molten_gallium"],

    onSelect: () => {
        promptInput("Enter red value (0-255):", function (r_inp) {
            r_inp = parseInt(r_inp);
            if (r_inp > 255 || r_inp < 0 || isNaN(r_inp)) {
                logMessage("Red value is invalid, using default/last red value: " + globals.red);
            } else {
                globals.red = r_inp;
            }

            promptInput("Enter green value (0-255):", function (g_inp) {
                g_inp = parseInt(g_inp);
                if (g_inp > 255 || g_inp < 0 || isNaN(g_inp)) {
                    logMessage("Green value is invalid, using default/last green value: " + globals.green);
                } else {
                    globals.green = g_inp;
                }

                promptInput("Enter blue value (0-255):", function (b_inp) {
                    b_inp = parseInt(b_inp);
                    if (b_inp > 255 || b_inp < 0 || isNaN(b_inp)) {
                        logMessage("Blue value is invalid, using default/last blue value: " + globals.blue);
                    } else {
                        globals.blue = b_inp;
                    }
                }, "Blue Value", globals.blue); // optional default input
            }, "Green Value", globals.green);
        }, "Red Value", globals.red);
    },

    onPlace: (pixel) => {
        var ledColor = RGBToHex([globals.red, globals.green, globals.blue]);
        pixel.color = ledColor;
    }
};


runAfterReset(() => {
    if (globals.rRGBLed) {
        globals.red = 100;
        globals.greed = 100;
        globals.blue = 100;
    }
})

if (!elements.malware.reactions) { elements.malware.reactions = {} }
elements.malware.reactions.rgb_led = { elem2: ["led_r", "led_g", "led_b"], chance: 0.01 }
elements.malware.reactions.led_r = { elem2: ["rgb_led", "led_g", "led_b"], chance: 0.01 }
elements.malware.reactions.led_g = { elem2: ["rgb_led", "led_r", "led_b"], chance: 0.01 }
elements.malware.reactions.led_b = { elem2: ["rgb_led", "led_g", "led_r"], chance: 0.01 }

elements.dice = {
    color: "#d5d5d5",
    state: "solid",
    onClicked(pixel) {
        pixel.clicked = true;
    },

    tick(pixel) {
        if (pixel.rolled === undefined) {
            pixel.rolled = false;
        }

        if (pixel.clicked && !pixel.rolled) {
            const roll = randomIntInRange(1, 6);
            clearLog()
            logMessage("Dice roll: " + roll);
            pixel.rolled = true;
        }

        if (!pixel.clicked) {
            pixel.rolled = false;
        }

        pixel.clicked = false;
    },
    behavior: behaviors.WALL,
    density: 500,
    category: "special",
    onSelect: () => {
        logMessage("Click The Dice to Roll")
        logMessage("It is reccomended to roll only one dice at a time as it will only show one value")
    }
}

elements.wood.pressInto = "plank";
elements.wood.resistPress = 0.5;

elements.plank = {
    color: "#98633B",
    behavior: behaviors.WALL,
    renderer: renderPresets.WOODCHAR,
    tempHigh: 400,
    stateHigh: ["ember", "charcoal", "fire", "fire", "fire"],
    category: "solids",
    burn: 5,
    burnTime: 300,
    burnInto: ["ember", "charcoal", "fire"],
    state: "solid",
    hardness: 0.50,
    breakInto: "sawdust",
    forceSaveColor: true
}

elements.sand.pressInto = "packed_sand";
elements.sand.resistPress = 0.2
elements.snow.pressInto = "packed_snow";
elements.snow.resistPress = 0.2

elements.asbestos = {
    color: "#f1f5f1",
    behavior: [
        "SP|XX|SP",
        "XX|XX|XX",
        "SA AND M2|M1|SP AND M2"
    ],
    category: "powders",
    state: "solid",
    tempHigh: 800,
    stateHigh: ["dust", "ash", "fire"],
    breakInto: ["gravel", "sand", "dust"],
    reactions: {
        "body": { elem2: "cancer", chance: 0.5 },
        "head": { elem2: "cancer", chance: 0.5 }
    },
    nocheer: true
}

elements.lithium_battery = {
    color: "#616161",
    behavior: [
        "XX|SH|XX",
        "SH|XX|SH",
        "XX|SH|XX"
    ],
    tempHigh: 1400,
    stateHigh: ["explosion", "lithium", "acid_gas"],
    hardness: 0.8,
    breakInto: ["lithium", "acid"],
    category: "machines",
    alias: "lithium-ion battery",
    state: "solid"
}

elements.lithium = {
    color: "#acacac",
    behavior: behaviors.POWDER,
    reactions: {
        "water": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "salt_water": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "pool_water": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "sugar_water": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "seltzer": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "dirty_water": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "primordial_soup": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "nut_milk": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 }
    },
    density: 533.4,
    tempHigh: 180.5,
    conduct: 0.45,
    category: "powders",
    state: "solid"
}

elements.molten_lithium = {
    tempHigh: 1344,
    stateHigh: 'lithium_gas',
    reactions: {
        "water": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "salt_water": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "pool_water": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "sugar_water": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "seltzer": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "dirty_water": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "primordial_soup": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 },
        "nut_milk": { elem1: ["pop", "pop", "pop", "hydrogen"], chance: 0.01, temp2: 200 }
    },
    state: "liquid"
}

elements.lithium_gas = {
    color: "#cccccc",
    behavior: behaviors.GAS,
    isGas: true,
    tempLow: 1334,
    stateLow: "molten_lithium",
    density: 533.4,
    conduct: 0.45,
    temp: 1334,
    category: "states",
    hidden: true,
    state: "gas"
}

elements.chalk = {
    color: "#fff3ac",
    behavior: behaviors.WALL,
    stain: 0.25,
    category: "land",
    breakInto: "chalk_powder",
    tempHigh: 1000,
    density: 2700,
    reactions: {
        "water": { elem1: "wet_chalk", elem2: null, chance: 0.5 },
        "salt_water": { elem1: "wet_chalk", elem2: null, chance: 0.5 },
        "seltzer": { elem1: "wet_chalk", elem2: null, chance: 0.5 },
        "dirty_water": { elem1: "wet_chalk", elem2: null, chance: 0.5 },
        "sugar_water": { elem1: "wet_chalk", elem2: null, chance: 0.5 },
        "pool_water": { elem1: "wet_chalk", elem2: null, chance: 0.5 },
        "primordial_soup": { elem1: "wet_chalk", elem2: null, chance: 0.5 },
        "nut_milk": { elem1: "wet_chalk", elem2: null, chance: 0.5 }
    },
    alias: "calcite",
    state: "solid"
}

elements.chalk_powder = {
    color: "#fff3ac",
    behavior: behaviors.POWDER,
    stain: 0.25,
    category: "powders",
    tempHigh: 1000,
    stateHigh: "molten_chalk",
    density: 2700,
    reactions: {
        "water": { elem1: "wet_chalk_powder", elem2: null, chance: 0.5 },
        "salt_water": { elem1: "wet_chalk_powder", elem2: null, chance: 0.5 },
        "seltzer": { elem1: "wet_chalk_powder", elem2: null, chance: 0.5 },
        "dirty_water": { elem1: "wet_chalk_powder", elem2: null, chance: 0.5 },
        "sugar_water": { elem1: "wet_chalk_powder", elem2: null, chance: 0.5 },
        "pool_water": { elem1: "wet_chalk_powder", elem2: null, chance: 0.5 },
        "primordial_soup": { elem1: "wet_chalk_powder", elem2: null, chance: 0.5 },
        "nut_milk": { elem1: "wet_chalk_powder", elem2: null, chance: 0.5 },
        "glue": { elem1: "chalk", elem2: null }
    },
    state: "solid"
}

elements.wet_chalk = {
    color: "#bbb17b",
    behavior: behaviors.WALL,
    stain: 0.25,
    category: "land",
    breakInto: "wet_chalk_powder",
    tempHigh: 100,
    stateHigh: "chalk",
    density: 2300,
    onStateHigh: (pixel) => {
        releaseElement(pixel, "steam")
    },
    state: "solid"
}

elements.wet_chalk_powder = {
    color: "#bbb17b",
    behavior: behaviors.POWDER,
    stain: 0.25,
    category: "powders",
    tempHigh: 100,
    stateHigh: "chalk_powder",
    density: 2000,
    onStateHigh: (pixel) => {
        releaseElement(pixel, "steam")
    },
    state: "solid",
    reactions: {
        "glue": { elem1: "chalk", elem2: null }
    }
}

elements.lapis_lazuli = {
    color: ["#0000df", "#1212cc", "#120A8F", "#060080"],
    behavior: behaviors.WALL,
    breakInto: "lapis_lazuli_powder",
    tempHigh: 1100,
    stateHigh: 'magma',
    state: "solid",
    category: "solids"
}

elements.lapis_lazuli_powder = {
    color: "#120A8F",
    behavior: behaviors.POWDER,
    tempHigh: 1100,
    stateHigh: "magma",
    alias: "Ultramarine",
    category: "powders",
    state: "solid"
}

elements.uv_light = {
    color: "#440088",
    behavior: [
        "XX|XX|XX",
        "XX|DL%1|XX",
        "XX|XX|XX"
    ],
    glow: true,
    tick: behaviors.BOUNCY,
    temp: 35,
    tempLow: -273,
    stateLow: ["liquid_light", null],
    stateLowColorMultiplier: 0.8,
    breakInto: "light",
    breakIntoColor: "#ffcfcf",
    category: "energy",
    state: "gas",
    density: 0.00001,
    ignoreAir: true,
    reactions: {
        "ozone": { elem1: null, chance: 0.9 },
    }
};

if (!settings.cheerful) {
    elements.uv_light.reactions.cell = { elem2: "cancer", chance: 0.05 },
        elements.uv_light.reactions.skin = { elem2: "cancer", chance: 0.005 }
}
else {
    if (elements.uv_light.reactions.cell) {
        delete elements.uv_light.reactions.cell
    }
    if (elements.uv_light.reactions.skin) {
        delete elements.uv_light.reactions.skin
    }
}

function fadeColor(base, glow, ratio) {
    // ratio 1 = full glow, 0 = base color
    let r1 = parseInt(glow.substr(1, 2), 16);
    let g1 = parseInt(glow.substr(3, 2), 16);
    let b1 = parseInt(glow.substr(5, 2), 16);
    let r2 = parseInt(base.substr(1, 2), 16);
    let g2 = parseInt(base.substr(3, 2), 16);
    let b2 = parseInt(base.substr(5, 2), 16);
    let r = Math.round(r1 * ratio + r2 * (1 - ratio));
    let g = Math.round(g1 * ratio + g2 * (1 - ratio));
    let b = Math.round(b1 * ratio + b2 * (1 - ratio));
    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
}


elements.phosphor = {
    color: "#fffbe7",
    behavior: behaviors.POWDER,
    tick: function (pixel) {
        let nearUV = false;
        for (let i = 0; i < adjacentCoords.length; i++) {
            let x = pixel.x + adjacentCoords[i][0];
            let y = pixel.y + adjacentCoords[i][1];
            let p = getPixel(x, y);
            if (p && p.element == "uv_light") {
                nearUV = true;
                break;
            }
        }

        if (nearUV) {
            pixel.colorStay = 60; // longer for realism
        }

        if (pixel.colorStay > 0) {
            let ratio = pixel.colorStay / 60; // exponential fade would be even better
            pixel.color = fadeColor("#fffbe7", "#00c500", ratio);
            pixel.colorStay--;
        } else {
            pixel.color = "#fffbe7"
        }
        if (enabledMods.includes("mods/glow.js")) {
            if (pixel.color !== "#fffbe7") {
                pixel.emit = pixel.colorStay / 10
            }
        }
    },
    category: "powders",
    state: "solid",
};

elements.packed_sand.pressInto = "sandstone"
elements.packed_sand.resistPress = 0.7
elements.packed_snow.pressInto = "ice"
elements.packed_snow.resistPress = 0.7

elements.sandstone = {
    color: "#d3bc56",
    behavior: behaviors.WALL,
    breakInto: "sand",
    hardness: 0.5,
    state: "solid",
    stateHigh: "glass",
    tempHigh: 1700,
    category: "land"
}

// Glow.js integrtion
if (enabledMods.includes("mods/glow.js")) {
    elements.uv_light.emit = true
    elements.glow_stick.emit = true
    delete elements.glow_stick.glow
    elements.glow_stick_liquid.emit = true
    delete elements.glow_stick_liquid.glow
}


let neonTubeChoice = "#00ff00"; // default color

elements.neon_tube = {
    color: "#d1d1b5",
    renderer: renderPresets.BORDER,
    alpha: 0.25,
    conduct: 1,
    behavior: behaviors.WALL,
    breakInto: ["neon", "glass_shard"],
    grain: 0,
    category: "machines",
    state: "solid",
    tick: (pixel) => {
        pixel.def_color ??= pixel.color;
        pixel.glow_color ??= neonTubeChoice;

        if (pixel.charge) {
            pixel.alpha = 1;
            pixel.color = pixel.glow_color;
        } else {
            pixel.alpha = 0.25;
            pixel.color = pixel.def_color;
        }

        if (enabledMods.includes("mods/glow.js")) {
            if (pixel.charge) {
                pixel.emit = true;
                pixel.emitColor = pixel.glow_color;
            } else {
                delete pixel.emit;
                delete pixel.emitColor;
            }
        }
    },
    // Broken since yellow stacks above color
    // only green is good
    /*
    onSelect() {
        promptChoose(
            "Pick a color for your neon tube:",
            ["Red", "Green", "Blue", "Pink"],
            function(choice) {
                let colors = {
                    "Red": "#ff0000",
                    "Green": "#00ff00",
                    "Blue": "#0000ff",
                    "Pink": "#ff66cc"
                };
                neonTubeChoice = colors[choice] || "#00ff00";
                logMessage("Neon tube color set to " + choice);
            },
            "Neon Tube Setup"
        );
    }
    */
};

elements.realistic_ball = {
    color: "#e35693",
    tempHigh: 250,
    stateHigh: "molten_plastic",
    category: "special",
    state: "solid",
    density: 1052,
    hidden: true,
    tick: function (pixel) {
        // initialize velocity
        if (pixel.vy === undefined) {
            pixel.vy = 0;
        }

        // gravity
        pixel.vy += 0.3;

        // predict next position
        let nextY = pixel.y + Math.sign(pixel.vy);

        if (isEmpty(pixel.x, nextY)) {
            // free space → move
            tryMove(pixel, pixel.x, pixel.y + Math.sign(pixel.vy));
        } else {
            // collision: reverse velocity (bounce)
            pixel.vy *= -0.7;

            // stop very small bounces
            if (Math.abs(pixel.vy) < 0.5) {
                pixel.vy = 0;
            }
        }
    }
}

elements.custom_bomb = {
    color: "#49443b",
    category: "weapons",
    state: "solid",
    density: 1300,
    excludeRandom: true,
    cooldown: defaultCooldown,
    behavior: behaviors.STURDYPOWDER,
    onSelect: function () {
        promptInput(
            "Input the element you want your bomb to explode into",
            function (input) {
                let pr1 = mostSimilarElement(input)
                if (pr1 && elements[pr1]) {
                    if (pr1 === "custom_bomb") {
                        promptConfirm("Are you sure you want custom bomb to create itself as it will spread", (a) => { if (!a) { globals.explodeElem = 'fire' } else globals.explodeElem = 'custom_bomb' }, "Warning")
                    }
                    else { globals.explodeElem = pr1 }
                }
                else {
                    globals.explodeElem = 'fire'
                    logMessage("Invalid element. Using default: fire")
                }
            },
            "Element prompt",
            "fire"
        )
    },
    tick: function (pixel) {
        let belowPixel = getPixel(pixel.x, pixel.y + 1);

        // If pixel is at the bottom or resting on a solid
        if (outOfBounds(pixel.x, pixel.y + 1) || (belowPixel && belowPixel.element !== "custom_bomb" && !isEmpty(pixel.x, pixel.y + 1) && belowPixel.element !== "fire" && belowPixel.element !== "smoke")) {
            explodeAt(pixel.x, pixel.y, 10, globals.explodeElem);
            deletePixel(pixel.x, pixel.y);
        }
    }
}

runAfterReset(() => {
    if (globals.rCustomBomb) {
        globals.explodeElem = 'fire'
    }
})

elements.pineapple = {
    color: "#ffd900",
    isFood: true,
    behavior: behaviors.STURDYPOWDER,
    breakInto: ["juice", "juice", "juice", "juice", "juice", "pineapple_seed"],
    breakIntoColor: "#fffc00",
    category: "food",
    state: "solid",
    seed: "pineapple_seed"
}

elements.pineapple_seed = {
    color: "#695531",
    behavior: behaviors.STURDYPOWDER,
    cooldown: defaultCooldown,
    category: "life",
    tempHigh: 400,
    stateHigh: "fire",
    tempLow: -2,
    stateLow: "frozen_plant",
    burn: 50,
    burnTime: 20,
    state: "solid",
    tick: function (pixel) {
        let belowPixel = getPixel(pixel.x, pixel.y + 1)
        if (
            !isEmpty(pixel.x, pixel.y + 1) &&
            belowPixel &&
            Math.random() <= 0.05
        ) {
            changePixel(pixel, "pineapple_stem")
            pixel.growthState = 1
            pixel.growDiagLeft = true
            pixel.growDiagRight = true
        }
    },
    seed: true
}

eListAdd("SEEDS", "pineapple_seed")

elements.pineapple_stem = {
    color: "#3aab11",
    behavior: behaviors.WALL,
    movable: false,
    category: "life",
    tempHigh: 100,
    stateHigh: "dead_plant",
    tempLow: -1.66,
    stateLow: "frozen_plant",
    burn: 15,
    burnTime: 60,
    burnInto: "dead_plant",
    breakInto: "dead_plant",
    tick: function (pixel) {
        let left = pixel.x - 1
        let right = pixel.x + 1
        let up = pixel.y - 1
        let down = pixel.y + 1
        let belowPixel = getPixel(pixel.x, down)
        pixel.fruitCD ??= 60
        if (!outOfBounds(pixel.x, down) && belowPixel && eLists.SOIL.includes(belowPixel.element) && pixel.growthState === 1) {
            changePixel(belowPixel, "root")
        }
        if (pixel.growthState === 1 && Math.random() <= 0.05) {
            if (isEmpty(left, up) && pixel.growDiagLeft === true) {
                createPixel("pineapple_stem", left, up)
                let newPixel = getPixel(left, up)
                if (newPixel) {
                    newPixel.growthState = 2
                    newPixel.growDiagLeft = true
                    delete newPixel.growDiagRight
                }
            }
            else {
                delete pixel.growDiagLeft
            }
            if (isEmpty(right, up) && pixel.growDiagRight === true) {
                createPixel("pineapple_stem", right, up)
                let newPixel = getPixel(right, up)
                if (newPixel) {
                    newPixel.growthState = 2
                    newPixel.growDiagRight = true
                    delete newPixel.growDiagLeft
                }
            }
            else {
                delete pixel.growDiagRight
            }
        }
        if (!pixel.growDiagLeft && !pixel.growDiagRight && pixel.growthState === 1) {
            if (Math.random() <= 0.05 && isEmpty(pixel.x, up) && !pixel.fruitCD && !pixel.pineappleGrown) {
                createPixel("pineapple", pixel.x, up)
                pixel.fruitCD = 60
                pixel.pineappleGrown = true
            }
            if (pixel.fruitCD && !pixel.pineappleGrown) {
                pixel.fruitCD--
            }
        }
        if (isEmpty(pixel.x, up)) {
            pixel.pineappleGrown = false
        }
        if (pixel.growthState === 2 && Math.random() <= 0.05) {
            if (isEmpty(left, up) && pixel.growDiagLeft === true) {
                createPixel("pineapple_stem", left, up)
            }
            if (isEmpty(right, up) && pixel.growDiagRight === true) {
                createPixel("pineapple_stem", right, up)
            }
        }
    }
}

// making redstone conductive bc idk why its not
if (enabledMods.includes("mods/minecraft.js")) {
    runAfterLoad(() => {
        elements.redstone_dust.conduct = 1
    })
}

elements.rubidium = {
    color: "#c0c0c0",
    state: "solid",
    behavior: behaviors.POWDER,
    tempHigh: 39.30,
    stateHigh: "liquid_rubidium",
    density: 1534,
    conduct: 0.6,
    reactions: {
        "water": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "salt_water": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "sugar_water": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "pool_water": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "dirty_water": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "seltzer": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "primordial_soup": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "nut_milk": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 }
    },
    category: "powders"
}

elements.liquid_rubidium = {
    color: "#d0d0d0",
    state: "liquid",
    behavior: behaviors.LIQUID,
    tempHigh: 688,
    density: 1460,
    conduct: 0.6,
    tempLow: 39.30,
    stateLow: "rubidium",
    temp: 40,
    reactions: {
        "water": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "salt_water": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "sugar_water": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "pool_water": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "dirty_water": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "seltzer": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "primordial_soup": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 },
        "nut_milk": { elem1: ["explosion", "explosion", "hydrogen"], temp2: 200 }
    },
    category: "states",
    hidden: true
}

elements.dog = {
    color: ["#221d0c", "#5c4300", "#7c5b00", "#fcfceb"],
    behavior: [
        "XX|XX|M2%3",
        "XX|FX%5|M2%5",
        "XX|M1|XX"
    ],
    tempHigh: 100,
    stateHigh: "cooked_meat",
    tempLow: -10,
    stateLow: "frozen_meat",
    category: "life",
    state: "solid",
    burn: 30,
    burnTime: 50,
    burnInto: ["cooked_meat", "smoke"],
    breakInto: ["meat", "blood"],
    reactions: {
        "meat": { elem2: null, chance: 0.5, func: behaviors.FEEDPIXEL },
        "egg": { elem2: null, chance: 0.5, func: behaviors.FEEDPIXEL },
        "yolk": { elem2: null, chance: 0.5, func: behaviors.FEEDPIXEL },
        "cheese": { elem2: null, chance: 0.5, func: behaviors.FEEDPIXEL },
        "cooked_meat": { elem2: null, chance: 0.5, func: behaviors.FEEDPIXEL },
        "chocolate": { elem2: null, chance: 0.2, func: behaviors.FEEDPIXEL, elem1: "rotten_meat" },
        "grape": { elem2: null, chance: 0.2, func: behaviors.FEEDPIXEL, elem1: "rotten_meat" },
        "rat": { elem2: null, chance: 0.3, func: behaviors.FEEDPIXEL },
        "nut_butter": { elem2: null, chance: 0.5, func: behaviors.FEEDPIXEL },
    },
    egg: "dog",
}

// Keyboard state tracking
const robotKeys = {
    left: false,
    right: false,
    jump: false
};

// Set up keyboard listeners
window.addEventListener('keydown', (e) => {
    const key = e.key.toLowerCase();
    if (key === 'a' || key === 'arrowleft') robotKeys.left = true;
    if (key === 'd' || key === 'arrowright') robotKeys.right = true;
    if (key === 'w' || key === 'arrowup') robotKeys.jump = true;
});

window.addEventListener('keyup', (e) => {
    const key = e.key.toLowerCase();
    if (key === 'a' || key === 'arrowleft') robotKeys.left = false;
    if (key === 'd' || key === 'arrowright') robotKeys.right = false;
    if (key === 'w' || key === 'arrowup') robotKeys.jump = false;
});

// Helper function for movement
function tryMoveRobot(headPixel, direction) {
    const newX = headPixel.x + direction;
    const body = getPixel(headPixel.x, headPixel.y + 1);

    if (body && body.element === "robot_body" &&
        isEmpty(newX, headPixel.y) &&
        isEmpty(newX, body.y)) {
        movePixel(body, newX, body.y);
        movePixel(headPixel, newX, headPixel.y);
        return true;
    }
    return false;
}

function tryJump(headPixel) {
    const body = getPixel(headPixel.x, headPixel.y + 1);
    if (!body || body.element !== "robot_body") return false;

    // Check if grounded (on solid surface or bottom of screen)
    const underBody = getPixel(body.x, body.y + 1);
    const isGrounded = (!isEmpty(body.x, body.y + 1) || outOfBounds(body.x, body.y + 1));

    if (isGrounded) {
        // Check space above
        if (isEmpty(headPixel.x, headPixel.y - 1) &&
            isEmpty(headPixel.x, headPixel.y - 2)) {

            // Two-stage jump animation
            pixelTicks = 0;
            headPixel.jumping = true;

            // First frame - small hop
            movePixel(headPixel, headPixel.x, headPixel.y - 1);
            movePixel(body, body.x, headPixel.y + 1);

            // Second frame - complete jump (after small delay)
            setTimeout(() => {
                if (headPixel.jumping) {  // Only if still jumping
                    movePixel(headPixel, headPixel.x, headPixel.y - 1);
                    movePixel(body, body.x, headPixel.y + 1);
                    headPixel.jumping = false;
                }
            }, 100);  // 100ms delay for smoother animation
            return true;
        }
    }
    return false;
}
// Robot elements
elements.robot_head = {
    color: "#d9d9d9",
    category: "machines",
    state: "solid",
    tick(pixel) {
        const body = getPixel(pixel.x, pixel.y + 1);

        if (body && body.element === "robot_body") {
            pixel.connected = true;
            body.connected = true;

            // Controlled movement
            if (pixel.mode === "Controlled") {
                if (robotKeys.left) {
                    tryMoveRobot(pixel, -1);
                }
                else if (robotKeys.right) {
                    tryMoveRobot(pixel, 1);
                }

                if (robotKeys.jump && !pixel.jumping) {
                    tryJump(pixel);
                }
            }
            // Aimless wandering
            else if (pixel.mode === "Aimless" && Math.random() < 0.02) {
                pixel.dir = pixel.dir || (Math.random() < 0.5 ? -1 : 1);
                if (!tryMoveRobot(pixel, pixel.dir)) {
                    pixel.dir *= -1;
                }
            }
        }
        else {
            pixel.connected = false;
            tryMove(pixel, pixel.x, pixel.y + 1);
        }
    }
};

elements.robot_body = {
    color: "#b1b1b1",
    category: "machines",
    state: "solid",
    tick(pixel) {
        const head = getPixel(pixel.x, pixel.y - 1);

        if (head && head.element === "robot_head") {
            pixel.connected = true;
            head.connected = true;

            // Gravity - move down if space below
            if (isEmpty(pixel.x, pixel.y + 1)) {
                let oldY = pixel.y;
                movePixel(pixel, pixel.x, pixel.y + 1);
                movePixel(head, head.x, oldY);
            }
        }
        else {
            pixel.connected = false;
            tryMove(pixel, pixel.x, pixel.y + 1);
        }
    }
};

// Robot creator element
globals.mode = "Aimless"
elements.robot = {
    color: "#b1b1b1",
    category: "machines",
    state: "solid",
    onSelect() {
        promptChoose(
            "Choose robot mode",
            ["Aimless", "Controlled"],
            (choice) => {
                if (choice === "Controlled" && isMobile) {
                    logMessage("Controlled mode doesn't work on mobile");
                    globals.mode = "Aimless";
                } else {
                    globals.mode = choice || "Aimless";
                    if (globals.mode === "Controlled") {
                        logMessage("Controls: A/D to move and W to jump or (Not reccomended) ←/→ to move, and ↑ to jump");
                    }
                }
            },
            "Robot Mode"
        );
    },
    onPlace(pixel) {
        // Try to create head above
        if (isEmpty(pixel.x, pixel.y - 1)) {
            createPixel("robot_head", pixel.x, pixel.y - 1);
            const head = getPixel(pixel.x, pixel.y - 1);
            head.mode = globals.mode;
            changePixel(pixel, "robot_body");
            pixel.mode = globals.mode;
        }
        // Try to create body below if above is blocked
        else if (isEmpty(pixel.x, pixel.y + 1)) {
            createPixel("robot_body", pixel.x, pixel.y + 1);
            const body = getPixel(pixel.x, pixel.y + 1);
            body.mode = globals.mode;
            changePixel(pixel, "robot_head");
            pixel.mode = globals.mode;
        }
        // Delete if no space
        else {
            deletePixel(pixel.x, pixel.y);
        }
    },
    cooldown: defaultCooldown
};

elements.mercury_gas.behaviorOn = [
    "M2|CR:uv_light%10 AND M1|M2",
    "CR:uv_light%10 AND M1|XX|CR:uv_light%10 AND M1",
    "M2|CR:uv_light%10 AND M1|M2"
]


elements.broken_adjustable_heater = {
    color: "#ff0000",
    category: "extras",
    insulate: true,
    behavior: behaviors.WALL,

    onSelect() {
        promptInput(
            "Select the temperature you want to adjust to",
            function (choice) {
                if (choice && !isNaN(Number(choice))) {
                    globals.adjusted_heater_temp = Number(choice)
                    logMessage("Occasionally creates superheated pixels")
                }
            },
            "Temperature Prompt", `${globals.adjusted_heater_temp}`
        )
    },
    tick(pixel) {
        pixel.heat_temp ??= globals.adjusted_heater_temp
        for (let i = 0; i < adjacentCoords.length; i++) {
            let x = pixel.x + adjacentCoords[i][0];
            let y = pixel.y + adjacentCoords[i][1];
            let current_pixel = getPixel(x, y);

            if (
                current_pixel &&
                !elements[current_pixel.element]?.insulate
                && current_pixel.temp < pixel.heat_temp
            ) {
                current_pixel.temp = Math.min(current_pixel.temp + 2, pixel.heat_temp);
            }
        }
    }
};

globals.adjusted_temp = 100
globals.heatAmount = 2

elements.adjustable_heater = {
    color: "#ff0000",
    category: "machines",
    insulate: true,
    behavior: behaviors.WALL,

    onSelect() {
        promptInput(
            "Select the temperature you want to adjust to",
            function (choice) {
                if (choice && !isNaN(Number(choice))) {
                    globals.adjusted_temp = Number(choice);
                }
            },
            "Temperature Prompt", `${globals.adjusted_temp}`
        );
    },

    tick(pixel) {
        for (let i = 0; i < adjacentCoords.length; i++) {
            let x = pixel.x + adjacentCoords[i][0];
            let y = pixel.y + adjacentCoords[i][1];
            let current_pixel = getPixel(x, y);

            if (
                current_pixel &&
                !elements[current_pixel.element]?.insulate
            ) {
                // Heat or cool toward the adjusted temp
                if (current_pixel.temp < globals.adjusted_temp) {
                    current_pixel.temp = Math.min(current_pixel.temp + globals.heatAmount, globals.adjusted_temp);
                } else if (current_pixel.temp > globals.adjusted_temp) {
                    current_pixel.temp = Math.max(current_pixel.temp - globals.heatAmount, globals.adjusted_temp);
                }
                pixelTempCheck(current_pixel)
            }
        }
    }
};

globals.adjusted_cooler_temp = 0; // default cooling target

elements.broken_adjustable_cooler = {
    color: "#0000ff",
    category: "extras",
    insulate: true,
    behavior: behaviors.WALL,

    onSelect() {
        promptInput(
            "Select the temperature you want to cool to",
            function (choice) {
                if (choice && !isNaN(Number(choice))) {
                    globals.adjusted_cooler_temp = Number(choice);
                    logMessage("Occasionally creates supercooled pixels");
                }
            },
            "Temperature Prompt", `${globals.adjusted_cooler_temp}`
        );
    },

    tick(pixel) {
        pixel.cool_temp ??= globals.adjusted_cooler_temp;
        for (let i = 0; i < adjacentCoords.length; i++) {
            let x = pixel.x + adjacentCoords[i][0];
            let y = pixel.y + adjacentCoords[i][1];
            let current_pixel = getPixel(x, y);

            if (
                current_pixel &&
                !elements[current_pixel.element]?.insulate &&
                current_pixel.temp > pixel.cool_temp
            ) {
                // Cool the pixel toward the target
                current_pixel.temp = Math.max(current_pixel.temp - 2, pixel.cool_temp);
            }
        }
    }
};

globals.adjusted_cool_temp = 0; // default cooling target
globals.coolAmount = 2; // adjustable step

elements.adjustable_cooler = {
    color: "#0000ff",
    category: "machines",
    insulate: true,
    behavior: behaviors.WALL,

    onSelect() {
        promptInput(
            "Select the temperature you want to cool to",
            function (choice) {
                if (choice && !isNaN(Number(choice))) {
                    globals.adjusted_cool_temp = Number(choice);
                }
            },
            "Temperature Prompt", `${globals.adjusted_cool_temp}`
        );
    },

    tick(pixel) {
        for (let i = 0; i < adjacentCoords.length; i++) {
            let x = pixel.x + adjacentCoords[i][0];
            let y = pixel.y + adjacentCoords[i][1];
            let current_pixel = getPixel(x, y);

            if (
                current_pixel &&
                !elements[current_pixel.element]?.insulate
            ) {
                // Cool or heat toward target (mirrors fixed heater logic)
                if (current_pixel.temp > globals.adjusted_cool_temp) {
                    current_pixel.temp = Math.max(current_pixel.temp - globals.coolAmount, globals.adjusted_cool_temp);
                } else if (current_pixel.temp < globals.adjusted_cool_temp) {
                    current_pixel.temp = Math.min(current_pixel.temp + globals.coolAmount, globals.adjusted_cool_temp);
                }

                pixelTempCheck(current_pixel)
            }
        }
    }
};


globals.polishedList = new Set()
elements.polish = {
    desc: "Polishes textured elements",
    category: "tools",
    color: ["#a0dff0", "#c0e8f8", "#e0f5ff"],
    tool(pixel) {
        let element = pixel.element
        if ((elements[pixel.element].colorPattern && !globals.polishedList.has(`${pixel.x}, ${pixel.y}`)) || shiftDown) {
            deletePixel(pixel.x, pixel.y)
            createPixel(element, pixel.x, pixel.y)
            globals.polishedList.add(`${pixel.x}, ${pixel.y}`)
        }
    },
    onUnselect() {
        globals.polishedList.clear()
    }
}

elements[" "] = {
    category: "extras",
    onSelect() {
        logMessage("This Element has weird properties since its a space ' '")
    },
    alias: "space"
}

elements.paper_filter = {
    desc: "Filters solids from liquids",
    color: "#ececec",
    behavior: behaviors.WALL,
    reactions: {
        "light": { stain1: "#ebdfa7" },
        "oxygen": { stain1: "#ebdfa7" }
    },
    tempHigh: 248,
    stateHigh: ["fire", "fire", "fire", "fire", "fire", "ash"],
    burn: 70,
    burnTime: 300,
    burnInto: ["fire", "fire", "fire", "fire", "fire", "ash"],
    category: "machines",
    density: 1201,
    breakInto: "confetti",
    breakIntoColor: ["#ffffff", "#e6e6e6", "#dbdbdb"],
    tick(pixel) {
        let upPixel = getPixel(pixel.x, pixel.y - 1)

        if (upPixel && elements[upPixel.element].state == "liquid" && !pixel.con) {
            deletePixel(pixel.x, pixel.y - 1)
            pixel.con = upPixel
        }

        if (upPixel && (upPixel.element === "paper_filter" || upPixel.element === "indestructable_filter") && upPixel.con && !pixel.con) {
            let liquid = upPixel.con
            let viscMove = true

            let visc = elements[liquid.element].viscosity
            if (visc) {
                viscMove = (Math.random() * 100) < (100 / Math.pow(visc, 0.5))
            }

            if (viscMove) {
                pixel.con = liquid
                delete upPixel.con
            }
        }

        if (isEmpty(pixel.x, pixel.y + 1) && !outOfBounds(pixel.x, pixel.y + 1) && pixel.con) {
            let liquid = pixel.con
            let viscExit = true

            let visc = elements[liquid.element].viscosity
            if (visc) {
                viscExit = (Math.random() * 100) < (100 / Math.pow(visc, 0.5))
            }

            if (viscExit) {
                createPixel(liquid.element, pixel.x, pixel.y + 1)
                delete pixel.con
            }
        }
    }
}

elements.indestructable_filter = {
    desc: "Filters solids from liquids",
    color: "#aaaaaa",
    behavior: behaviors.WALL,
    category: "machines",
    state: "solid",
    movable: false,
    tick(pixel) {
        let upPixel = getPixel(pixel.x, pixel.y - 1)
        let belowPixel = getPixel(pixel.x, pixel.y + 1)

        if (upPixel && elements[upPixel.element].state == "liquid" && !pixel.con) {
            deletePixel(pixel.x, pixel.y - 1)
            pixel.con = upPixel
        }

        if (upPixel && (upPixel.element === "indestructable_filter" || upPixel.element === "paper_filter") && upPixel.con && !pixel.con) {
            let liquid = upPixel.con
            let viscMove = true

            let visc = elements[liquid.element].viscosity
            if (visc) {
                viscMove = (Math.random() * 100) < (100 / Math.pow(visc, 0.5))
            }

            if (viscMove) {
                pixel.con = liquid
                delete upPixel.con
            }
        }

        if (isEmpty(pixel.x, pixel.y + 1) && !outOfBounds(pixel.x, pixel.y + 1) && pixel.con) {
            let liquid = pixel.con
            let viscExit = true

            let visc = elements[liquid.element].viscosity
            if (visc) {
                viscExit = (Math.random() * 100) < (100 / Math.pow(visc, 0.5))
            }

            if (viscExit) {
                createPixel(liquid.element, pixel.x, pixel.y + 1)
                delete pixel.con
            }
        }
    }
}

globals.blackHoleExpand = false
elements.black_hole = {
    color: "#111111",
    hardness: 1,
    category: "special",
    properties: {
        absorbed: 0
    },
    renderer: function (pixel, ctx) {
        if (!viewInfo[view].colorEffects) { drawDefault(ctx, pixel); return }
        renderPresets.HEATGLOW(pixel, ctx);
        if (pixel.alpha === 0) return;

        let edge = false;
        pixel.edge = false;
        pixel.color = "#111111";

        for (var i = 0; i < adjacentCoords.length; i++) {
            var coords = adjacentCoords[i];
            var x = pixel.x + coords[0];
            var y = pixel.y + coords[1];
            if (!outOfBounds(x, y)) {
                let neighbor = getPixel(x, y);
                if (!neighbor || elements[neighbor.element].movable !== elements[pixel.element].movable) {
                    edge = true;
                    break;
                }
            }
        }
        if (edge) { pixel.color = "#ffae00"; pixel.edge = true }
    },
    tick(pixel) {
        // Glow effect
        if (pixel.edge) {
            pixel.glow = true;
            if (enabledMods.includes("mods/glow.js")) {
                pixel.emit = 10;
            }
        }
        else {
            pixel.glow = false;
            if (enabledMods.includes("mods/glow.js")) {
                pixel.emit = 0;
            }
        }

        // Suction physics
        let radius = 20; // how far the suction reaches
        for (let dx = -radius; dx <= radius; dx++) {
            for (let dy = -radius; dy <= radius; dy++) {
                if (dx === 0 && dy === 0) continue;

                let x = pixel.x + dx;
                let y = pixel.y + dy;

                if (!outOfBounds(x, y)) {
                    let other = getPixel(x, y);
                    if (other && other !== pixel) {
                        let elemDef = elements[other.element];

                        // Skip if indestructible
                        if (elemDef.hardness === 1) continue;

                        // Distance to black hole
                        let dist = Math.sqrt(dx * dx + dy * dy);

                        if (dist <= radius) {
                            // Suction chance: closer = stronger pull
                            let chance = 1 / dist;
                            if (Math.random() < chance) {
                                let stepX = Math.sign(pixel.x - x);
                                let stepY = Math.sign(pixel.y - y);

                                let newX = x + stepX;
                                let newY = y + stepY;

                                if (isEmpty(newX, newY) && !outOfBounds(newX, newY)) {
                                    movePixel(other, newX, newY);
                                }
                                else if (dist <= 1.5) {
                                    deletePixel(x, y); // absorb it
                                    pixel.absorbed++
                                }
                            }
                        }
                    }
                }
            }
            if (globals.blackHoleExpand) {
                for (var i = 0; i < adjacentCoords.length; i++) {
                    var x = pixel.x + adjacentCoords[i][0];
                    var y = pixel.y + adjacentCoords[i][1];
                    if (pixel.absorbed >= 30 && isEmpty(x, y)) {
                        createPixel("black_hole", x, y)
                        pixel.absorbed = 0
                    }
                }
            }
        }
    },
    forceSaveColor: true,
    onSelect() {
        promptChoose(
            "Do you want the black hole to grow?",
            ["Yes", "No"],
            (choice) => {
                if (!choice) {
                    choice = "No"
                }
                if (choice == "Yes") {
                    globals.blackHoleExpand = true
                }
                else {
                    globals.blackHoleExpand = false
                }
            }
        )
    }
};

elements.white_hole = {
    color: "#ffffff",
    renderer: function (pixel, ctx) {
        if (!viewInfo[view].colorEffects) { drawDefault(ctx, pixel); return }
        renderPresets.HEATGLOW(pixel, ctx);
        if (pixel.alpha === 0) return;
        let edge = false;
        for (var i = 0; i < adjacentCoords.length; i++) {
            var coords = adjacentCoords[i];
            var x = pixel.x + coords[0];
            var y = pixel.y + coords[1];
            if (isEmpty(x, y) || (!outOfBounds(x, y) && elements[pixelMap[x][y].element].movable !== elements[pixel.element].movable)) {
                edge = true;
                break;
            }
        }
        if (edge) { drawSquare(ctx, "rgba(0,0,0," + (pixel.alpha || 1) / 4 + ")", pixel.x, pixel.y) }
    },
    tick(pixel) {
        for (var i = 0; i < squareCoords.length; i++) {
            var coord = squareCoords[i];
            var x = pixel.x + coord[0];
            var y = pixel.y + coord[1];
            if (isEmpty(x, y) && !outOfBounds(x, y) && Math.random() <= 0.0005) {
                createPixel(
                    ["proton", "neutron", "electric",
                        "proton", "neutron", "electric",
                        "proton", "neutron", "electric",
                        "proton", "neutron", "electric",
                        "random"], x, y)
            }
        }
        let radius = 20;
        for (let dx = -radius; dx <= radius; dx++) {
            for (let dy = -radius; dy <= radius; dy++) {
                if (dx === 0 && dy === 0) continue;

                let x = pixel.x + dx;
                let y = pixel.y + dy;

                if (!outOfBounds(x, y)) {
                    let other = getPixel(x, y);
                    if (other && other !== pixel) {
                        let elemDef = elements[other.element];

                        if (elemDef.hardness === 1) continue;

                        let dist = Math.sqrt(dx * dx + dy * dy);

                        if (dist <= radius) {
                            let chance = 1 / (dist * 0.75);
                            if (Math.random() < chance) {
                                let stepX = Math.sign(pixel.x - x);
                                let stepY = Math.sign(pixel.y - y);

                                let newX = x - stepX;
                                let newY = y - stepY;

                                if (isEmpty(newX, newY) && !outOfBounds(newX, newY)) {
                                    movePixel(other, newX, newY);
                                }
                            }
                        }
                    }
                }
            }
        }
    },
    hardness: 1,
    behavior: behaviors.WALL,
    category: "special"
}

elements.cacao_fruit = {
    color: "#854700",
    behavior: [
        "XX|ST:cacao_stem|XX",
        "ST:cacao_stem|XX|ST:cacao_stem",
        "XX|ST:cacao_stem AND M1|XX"
    ],
    isFood: true,
    burn: 10,
    burnTime: 100,
    burnInto: "ash",
    breakInto: "cacao_bean",
    category: "food",
    state: "solid",
    density: 1000
}

elements.cacao_bean = {
    color: "#ffe7ba",
    isFood: true,
    behavior: [
        "XX|XX|XX",
        "XX|XX|XX",
        "M2%10|M1|M2%10"
    ],
    tempHigh: 100,
    stateHigh: "dried_cacao_bean",
    onStateHigh(pixel) { releaseElement(pixel, "steam") },
    state: "solid",
    category: "food",
    density: 1000
}

elements.dried_cacao_bean = {
    color: "#61321e",
    behavior: behaviors.POWDER,
    reactions: {
        "sugar_water": { elem2: "melted_chocolate", tempMin: 65 },
        "water": { elem2: "melted_chocolate", tempMin: 65 }
    },
    tempHigh: 400,
    stateHigh: "ash",
    isFood: true,
    category: "food",
    state: "solid",
    density: 1000
}

elements.coffee_bean.reactions.sugar_water = { elem2: "coffee", tempMin: 80 }
elements.coffee.reactions.sugar_water = { elem2: "coffee", tempMin: 70, chance: 0.2 }
elements.coffee_ground.reactions.sugar_water = elements.coffee_ground.reactions.water
elements._ = {
    category: "extras",
    onSelect() {
        logMessage("Another way to make an element with no name \"_\"")
    },
    alias: ["underscore"]
}

elements.cacao_seed = {
    color: "#8b3f00",
    behavior: behaviors.STURDYPOWDER,
    cooldown: defaultCooldown,
    category: "life",
    tempHigh: 400,
    stateHigh: "fire",
    tempLow: -2,
    stateLow: "frozen_plant",
    burn: 50,
    burnTime: 20,
    state: "solid",
    tick(pixel) {
        let belowPixel = getPixel(pixel.x, pixel.y + 1)
        if ((!isEmpty(pixel.x, pixel.y + 1) && belowPixel) || outOfBounds(pixel.x, pixel.y + 1) && Math.random() <= 0.005) {
            changePixel(pixel, "cacao_stem")
            pixel.stage = 1
        }
    }
}

elements.cacao_stem = {
    color: "#916a00",
    renderer: renderPresets.WOODCHAR,
    movable: false,
    tempHigh: 100,
    stateHigh: "wood",
    tempLow: -30,
    stateLow: "wood",
    category: "life",
    burn: 2,
    burnTime: 300,
    burnInto: ["sap", "ember", "charcoal", "smoke"],
    state: "solid",
    density: 1500,
    hardness: 0.15,
    breakInto: ["sap", "sawdust"],
    seed: "cacao_seed",
    forceSaveColor: true,
    stateHighColorMultiplier: 0.95,
    onPlace(pixel) {
        pixel.stage = 1
    },
    hoverStat(pixel) {
        if (pixel.stage) return pixel.stage;
        else return 0;
    },
    tick(pixel) {
        // 1 = trunk
        // 2 = spread
        // 3 = stop
        if (pixel.stage === 1 && isEmpty(pixel.x, pixel.y - 1) && Math.random() <= 0.05) {
            tryMove(pixel, pixel.x, pixel.y - 1, "cacao_stem")
            let oldPixel = getPixel(pixel.x, pixel.y + 1)
            if (oldPixel) {
                delete oldPixel.stage
            }
            if (Math.random() <= 0.3) {
                pixel.stage = 2
            }
        }
        if (pixel.stage === 2) {
            let rand = Math.random()
            let nx;
            if (rand < 0.4) {
                nx = 1
            }
            else if (rand < 0.8) {
                nx = -1
            }
            else nx = 0;
            if (isEmpty(pixel.x + nx, pixel.y - 1) && Math.random() <= 0.05) {
                createPixel(["cacao_stem", "plant"], pixel.x + nx, pixel.y - 1)
                let newPixel = getPixel(pixel.x + nx, pixel.y - 1)
                if (Math.random() <= 0.2 && newPixel) {
                    newPixel.stage = 3
                }
                else if (newPixel) newPixel.stage = 2;
            }
            if (!isEmpty(pixel.x + 1, pixel.y - 1) && !isEmpty(pixel.x, pixel.y - 1) && !isEmpty(pixel.x - 1, pixel.y - 1) && Math.random() <= 0.005) {
                shuffleArray(adjacentCoordsShuffle)
                for (var i = 0; i < adjacentCoordsShuffle.length; i++) {
                    var x = pixel.x + adjacentCoordsShuffle[i][0];
                    var y = pixel.y + adjacentCoordsShuffle[i][1];
                    if (isEmpty(x, y) && !pixel.fruitMade) {
                        createPixel("cacao_fruit", x, y)
                        pixel.fruitMade = true
                        pixel.fruitCoordsx = x
                        pixel.fruitCoordsy = y
                        break
                    }
                }
            }
        }
        if (pixel.fruitCoordsx && pixel.fruitCoordsy) {
            if (getPixel(pixel.fruitCoordsx, pixel.fruitCoordsy) && getPixel(pixel.fruitCoordsx, pixel.fruitCoordsy).element === "cacao_fruit") return;
            pixel.fruitMade = false
            delete pixel.fruitCoordsx
            delete pixel.fruitCoordsy
        }
    }
}


// --- audio setup ---
const audioCtx = new (window.AudioContext || window.webkitAudioContext)();

function playNote(frequency, duration = 1, type = "sine", volume = 0.1) {
    if (!Number.isFinite(frequency)) {
        console.error("Invalid frequency:", frequency);
        return;
    }

    const osc = audioCtx.createOscillator();
    const gain = audioCtx.createGain();

    osc.type = type;
    osc.frequency.value = frequency;

    gain.gain.setValueAtTime(volume, audioCtx.currentTime);
    osc.connect(gain);
    gain.connect(audioCtx.destination);

    gain.gain.exponentialRampToValueAtTime(0.001, audioCtx.currentTime + duration);

    osc.start();
    osc.stop(audioCtx.currentTime + duration);
}


const pianoFrequencies = {
    "A0": 27.500, "A#0": 29.135, "BB0": 29.135, "B0": 30.868,
    "C1": 32.703, "C#1": 34.648, "DB1": 34.648, "D1": 36.708,
    "D#1": 38.891, "EB1": 38.891, "E1": 41.203, "F1": 43.654,
    "F#1": 46.249, "GB1": 46.249, "G1": 48.999, "G#1": 51.913,
    "AB1": 51.913, "A1": 55.000, "A#1": 58.270, "BB1": 58.270,
    "B1": 61.735,

    "C2": 65.406, "C#2": 69.296, "DB2": 69.296, "D2": 73.416,
    "D#2": 77.782, "EB2": 77.782, "E2": 82.407, "F2": 87.307,
    "F#2": 92.499, "GB2": 92.499, "G2": 97.999, "G#2": 103.826,
    "AB2": 103.826, "A2": 110.000, "A#2": 116.541, "BB2": 116.541,
    "B2": 123.471,

    "C3": 130.813, "C#3": 138.591, "DB3": 138.591, "D3": 146.832,
    "D#3": 155.563, "EB3": 155.563, "E3": 164.814, "F3": 174.614,
    "F#3": 184.997, "GB3": 184.997, "G3": 195.998, "G#3": 207.652,
    "AB3": 207.652, "A3": 220.000, "A#3": 233.082, "BB3": 233.082,
    "B3": 246.942,

    "C4": 261.626, "C#4": 277.183, "DB4": 277.183, "D4": 293.665,
    "D#4": 311.127, "EB4": 311.127, "E4": 329.628, "F4": 349.228,
    "F#4": 369.994, "GB4": 369.994, "G4": 391.995, "G#4": 415.305,
    "AB4": 415.305, "A4": 440.000, "A#4": 466.164, "BB4": 466.164,
    "B4": 493.883,

    "C5": 523.251, "C#5": 554.365, "DB5": 554.365, "D5": 587.330,
    "D#5": 622.254, "EB5": 622.254, "E5": 659.255, "F5": 698.456,
    "F#5": 739.989, "GB5": 739.989, "G5": 783.991, "G#5": 830.609,
    "AB5": 830.609, "A5": 880.000, "A#5": 932.328, "BB5": 932.328,
    "B5": 987.767,

    "C6": 1046.502, "C#6": 1108.731, "DB6": 1108.731, "D6": 1174.659,
    "D#6": 1244.508, "EB6": 1244.508, "E6": 1318.510, "F6": 1396.913,
    "F#6": 1479.978, "GB6": 1479.978, "G6": 1567.982, "G#6": 1661.219,
    "AB6": 1661.219, "A6": 1760.000, "A#6": 1864.655, "BB6": 1864.655,
    "B6": 1975.533,

    "C7": 2093.005, "C#7": 2217.461, "DB7": 2217.461, "D7": 2349.318,
    "D#7": 2489.016, "EB7": 2489.016, "E7": 2637.020, "F7": 2793.826,
    "F#7": 2959.955, "GB7": 2959.955, "G7": 3135.963, "G#7": 3322.438,
    "AB7": 3322.438, "A7": 3520.000, "A#7": 3729.310, "BB7": 3729.310,
    "B7": 3951.066,

    "C8": 4186.009
};


globals.note = 261.626; // default C4
globals.notesToPlay = [];

function flushNotes() {
    if (globals.notesToPlay.length === 0) return;


    let baseVolume = 0.2;
    let volume = baseVolume / Math.sqrt(globals.notesToPlay.length);

    for (let f of globals.notesToPlay) {
        playNote(f, 1, "sine", volume);
    }

    globals.notesToPlay = [];
}

elements.note_block = {
    color: "#965500",
    behavior: behaviors.WALL,
    onSelect() {
        promptInput(
            "Select the note this note block should be",
            function (choice) {
                if (!choice) {
                    if (!globals.note) { globals.note = 261.626; }
                    return;
                }
                let key = choice.toUpperCase();
                if (key in pianoFrequencies) {
                    globals.note = pianoFrequencies[key];
                } else {
                    globals.note = 261.626; // fallback = C4
                }
            },
            "Note prompt"
        );
    },
    onPlace(pixel) {
        pixel.note = globals.note;
    },
    tick(pixel) {
        if (pixel.charge) {
            globals.notesToPlay.push(Number(pixel.note));
        }
    },
    conduct: 1,
    category: "machines"
};

runEveryTick(function () { flushNotes() });

/*
elements.uncook = {
    color: ["#4dcdff", "#70ddff", "#bcddff", "#ffffff"],
    category: "tools",
    tool(pixel) {
        if (!pixel || !pixel.element) return;

        // 1) If the current element itself defines stateLow, use it (common case)
        const cur = elements[pixel.element];
        if (cur && cur.stateLow !== undefined) {
            const low = cur.stateLow;
            pixel.element = Array.isArray(low) ? low[Math.floor(Math.random() * low.length)] : low;
            if (typeof pixel.temp === "number") pixel.temp = Math.max(0, pixel.temp - 1);
            return; // done
        }

        // 2) Otherwise search for an element whose stateHigh === the current element
        for (const key in elements) {
            const el = elements[key];
            if (!el) continue;
            if (el.stateHigh === pixel.element) {
                // 'key' is the low-state element name
                changePixel(pixel, key)
                if (typeof pixel.temp === "number") pixel.temp = Math.max(0, pixel.temp - 1);
                return; // done
            }
            // If el.stateHigh can be an array of high-state names:
            if (Array.isArray(el.stateHigh) && el.stateHigh.includes(pixel.element)) {
                changePixel(pixel, key)
                if (typeof pixel.temp === "number") pixel.temp = Math.max(0, pixel.temp - 1);
                return;
            }
        }
    }
};
*/

elements.roman_cement = {
    color: "#b8b8b8",
    behavior: behaviors.LIQUID,
    category: "liquids",
    viscosity: 1000,
    density: 1400,
    state: "solid",
    tempLow: -10,
    stateLow: "roman_concrete",
    tempHigh: 1550,
    stateHigh: "magma",
    tick(pixel) {
        if (pixelTicks - pixel.start > 100 && Math.random() <= 0.1) {
            changePixel(pixel, "roman_concrete")
        }
    }
}

elements.roman_concrete = {
    color: "#ababab",
    behavior: behaviors.SUPPORT,
    tempHigh: 1500,
    stateHigh: "magma",
    category: "powders",
    state: "solid",
    density: 2400,
    hardness: 0.5,
    breakInto: "dust",
    darkText: true
}

/**
 * 
 * @param {string} element 
 * @param {object} reaction 
 * @returns {void}
 */
function doWaterReactions(element, reaction) {
    if (!elements[element].reactions) {
        elements[element].reactions = {}
    }
    elements[element].reactions.water = reaction
    elements[element].reactions.salt_water = reaction
    elements[element].reactions.pool_water = reaction
    elements[element].reactions.sugar_water = reaction
    elements[element].reactions.dirty_water = reaction
    elements[element].reactions.selter = reaction
    elements[element].reactions.primordial_soup = reaction
    elements[element].reactions.nut_milk = reaction
}

doWaterReactions("slaked_lime", { elem1: "roman_cement", elem2: null, chance: 0.25 })

globals.cachedWords = [];
globals.otherCachedWords = [];
globals.filteredCachedWords = [];
globals.loadingLogged = false;


async function getWordList() {
    if (globals.cachedWords) return globals.cachedWords;
    try {
        const response = await fetch("https://raw.githubusercontent.com/first20hours/google-10000-english/refs/heads/master/google-10000-english-no-swears.txt");
        if (!response.ok) throw new Error('Network error');
        const text = await response.text();
        globals.cachedWords = text.split("\n");
        return globals.cachedWords;
    } catch (err) {
        console.error(err);
        return [];
    }
}


async function getCleanWordList() {
    if (globals.otherCachedWords) return globals.otherCachedWords;
    try {
        const response = await fetch("https://raw.githubusercontent.com/dwyl/english-words/refs/heads/master/words.txt");
        if (!response.ok) throw new Error('Network error');
        const text = await response.text();
        globals.otherCachedWords = text.split("\n");
        return globals.otherCachedWords;
    } catch (err) {
        console.error(err);
        return [];
    }
}

async function filterWordList() {
    if (!globals.cachedWords) await getWordList();
    if (!globals.otherCachedWords) await getCleanWordList();

    if (globals.filteredCachedWords) return globals.filteredCachedWords;

    const cleanSet = new Set(globals.otherCachedWords);
    globals.filteredCachedWords = [];

    const chunkSize = 1000;
    for (let i = 0; i < globals.cachedWords.length; i += chunkSize) {
        const chunk = globals.cachedWords.slice(i, i + chunkSize);
        globals.filteredCachedWords.push(...chunk.filter(word => cleanSet.has(word)));
        await new Promise(requestAnimationFrame);
    }
    console.log("Finished filtering")
    return globals.filteredCachedWords;
}

filterWordList()

// getting myself familiar with async functions
elements.random_word_generator = {
    color: "#ffffff",
    behavior: behaviors.WALL,
    desc: "When shocked logs a random word",
    conduct: 1,
    category: "special",
    tick: function (pixel) {
        pixel.cd ??= 0;

        if (pixel.charge === 1 && pixel.cd <= 0) {
            if (!globals.filteredCachedWords && !globals.loadingLogged) {
                logMessage("Loading...");
                globals.loadingLogged = true;
            }

            const words = globals.filteredCachedWords ?? []

            if (words.length > 0) {
                const word = words[Math.floor(Math.random() * words.length)];
                logMessage("Your word is: " + word);
                pixel.cd = 10;
            } else {
                logMessage("Failed to load words.");
            }
        } else if (pixel.cd > 0) {
            pixel.cd--;
        }
    }
};

globals.paint_color = "#ff0000";

elements.paint_using_hex = {
    color: elements.paint.color,
    onSelect() {
        promptInput(
            "Select the color you want in hex. If you pass an array, make sure each hex value is wrapped with quotes.",
            (choice) => {
                if (!choice) return;

                const regex = /^#([a-fA-F0-9]{6})$/;

                if (regex.test(choice)) {
                    globals.paint_color = choice;
                    return;
                }

                try {
                    const converted = choice.replace(/'/g, '"')
                    const parsed = JSON.parse(converted);

                    if (Array.isArray(parsed)) {
                        let valid = true;
                        for (let value of parsed) {
                            if (!regex.test(value)) {
                                valid = false;
                                break;
                            }
                        }
                        if (valid) {
                            globals.paint_color = parsed;
                            return;
                        }
                    }
                } catch (e) {
                    logMessage("Parse failed")
                    console.log(e)
                }

                logMessage("Invalid color or array of colors");
                console.log(`${choice}`)
            }
        );
    },
    tool(pixel) {
        if (!shiftDown) {
            pixel.color = pixelColorPick(pixel, globals.paint_color);
        }
        else if (Array.isArray(globals.paint_color)) {
            pixel.color = choose(globals.paint_color)
        }
        else {
            pixel.color = globals.paint_color
        }
    },
    category: "tools"
};

globals.rCircle = false
globals.rRGBLed = false
globals.rCustomBomb = false
dependOn("betterSettings.js", () => {
    var Reset = new SettingsTab("Reset");
    var resetCircle = new Setting("Reset circle value and radius on reset", "Reset circle", settingType.BOOLEAN, false, defaultValue = false);
    var resetRGBLed = new Setting("Reset RGB Led value on reset", "Reset RGB Led", settingType.BOOLEAN, false, defaultValue = false);
    var resetCustomBomb = new Setting("Reset Custom Bomb value on reset", "Reset Custom Bomb", settingType.BOOLEAN, false, defaultValue = false);
    Reset.registerSettings("Reset", resetRGBLed)
    Reset.registerSettings("Reset", resetCircle)
    Reset.registerSettings("Reset", resetCustomBomb)
    settingsManager.registerTab(Reset);
    runEveryTick(() => {
        if (resetCircle.value == true) {
            globals.rCircle = true
        } else globals.rCircle = false
        if (resetCustomBomb.value == true) {
            globals.rCustomBomb = true
        } else globals.rCustomBomb = false
        if (resetRGBLed.value == true) {
            globals.rRGBLed = true
        } else globals.rRGBLed = false
    })
}, true)

elements.quartz = {
    color: ["#f0f0f0", "#ebebeb", "#f8f8f8"],
    grain: 0,
    conduct: 0.3,
    behavior: behaviors.WALL,
    onBreak(pixel) {
        if (Math.random() <= 0.2) {
            pixel.charge = 1
        }
    },
    onPress(pixel) {
        if (Math.random() <= 0.2) {
            pixel.charge = 1
        }
    },
    density: 2650,
    hardness: 0.7,
    breakInto: "quartz_powder",
    category: "solids"
}

elements.quartz_powder = {
    color: ["#dddddd", "#e0e0e0", "#f0f0f0"],
    grain: 0,
    conduct: 0.3,
    behavior: behaviors.POWDER,
    onBreak(pixel) {
        if (Math.random() <= 0.2) {
            pixel.charge = 1
        }
    },
    density: 2650,
    hardness: 0.7,
    category: "powders"
}

elements.carrot_seed = {
    color: '#925420',
    behavior: behaviors.STURDYPOWDER,
    cooldown: defaultCooldown,
    category: "life",
    tempHigh: 400,
    stateHigh: "fire",
    tempLow: -2,
    stateLow: "frozen_plant",
    burn: 50,
    burnTime: 20,
    state: "solid",
    tick(pixel) {
        let belowPixel = getPixel(pixel.x, pixel.y + 1)
        if (belowPixel && eLists.SOIL.includes(belowPixel.element) && Math.random() <= 0.05) {
            changePixel(belowPixel, "carrot")
            belowPixel.stage = 1
            belowPixel.connected = true
            changePixel(pixel, "plant")
        }
    }
}


elements.carrot = {
    color: ["#ec9a00", "#d67200"],
    behavior: behaviors.STURDYPOWDER,
    category: "food",
    density: 700,
    isFood: true,
    breakInto: "juice",
    breakIntoColor: "#ffa600",
    hoverStat(pixel) {
        if (pixel.stage) return pixel.stage
        else return 0;
    },
    tick(pixel) {
        let belowPixel = getPixel(pixel.x, pixel.y + 1)
        if (getPixel(pixel.x, pixel.y - 1) && getPixel(pixel.x, pixel.y - 1).element != "carrot" && getPixel(pixel.x, pixel.y - 1).element != "plant") {
            pixel.connected = false;
        }
        if (!getPixel(pixel.x, pixel.y - 1)) {
            pixel.connected = false
        }
        if (pixel.stage == 1 && Math.random() <= 0.05 && belowPixel && eLists.SOIL.includes(belowPixel.element) && pixel.connected) {
            changePixel(belowPixel, "carrot");
            let newStage;
            if (Math.random() <= 0.3) newStage = 1; else newStage = 2;
            belowPixel.stage = newStage
            belowPixel.connected = true
        }
        else if (pixel.stage == 2) {
            if (Math.random() <= 0.1 && belowPixel && eLists.SOIL.includes(belowPixel.element) && pixel.connected) {
                changePixel(belowPixel, "root")
            }
        }
    }
}

function factorial(n) {
    if (n < 0) throw new Error("Factorial not defined for negative numbers");
    let result = 1;
    for (let i = 2; i <= Number(n); i++) {
        result *= i;
    }
    return result;
}

function parseEquation(eq) {
    eq = eq.replace(/\s+/g, "");

    let tokens = [];
    let current_num = "";

    for (let i = 0; i < eq.length; i++) {
        // Multi-character constants
        if (eq.startsWith("pi", i)) {
            if (current_num !== "") { tokens.push(parseFloat(current_num)); current_num = ""; }
            tokens.push(Math.PI);
            i++;
            continue;
        }
        if (eq.startsWith("phi", i)) {
            if (current_num !== "") { tokens.push(parseFloat(current_num)); current_num = ""; }
            tokens.push(1.6180339887);
            i += 2;
            continue;
        }
        // Multi-character functions
        if (eq.startsWith("sqrt", i)) {
            if (current_num !== "") { tokens.push(parseFloat(current_num)); current_num = ""; }
            tokens.push("sqrt");
            i += 3; // skip 'qrt'
            continue;
        }

        let char = eq[i];

        if (/[0-9.]/.test(char)) {
            current_num += char;
        } else {
            if (current_num !== "") { tokens.push(parseFloat(current_num)); current_num = ""; }

            if (char === "-" && (i === 0 || /[+\-*/(]/.test(eq[i - 1]))) {
                current_num = "-";
            }
            else if (char === "e") { tokens.push(Math.E); }
            else if (char === "π") { tokens.push(Math.PI); }
            else if (char === "φ") { tokens.push(1.6180339887); }
            else if (char === "×") { tokens.push("*"); }
            else if (char === "÷") { tokens.push("/"); }
            else { tokens.push(char); }
        }
    }

    if (current_num !== "") { tokens.push(parseFloat(current_num)); }

    // Implicit multiplication
    let fixed = [];
    for (let i = 0; i < tokens.length; i++) {
        fixed.push(tokens[i]);
        let curr = tokens[i];
        let next = tokens[i + 1];

        if (
            (typeof curr === "number" && next === "(") ||
            (curr === ")" && typeof next === "number") ||
            (curr === ")" && next === "(") ||
            (typeof curr === "number" && next === "sqrt") // implicit multiplication with functions
        ) {
            fixed.push("*");
        }
    }

    return fixed;
}


function evaluate(tokens) {
    function helper(start = 0) {
        let stack = [];
        let i = start;

        while (i < tokens.length) {
            let token = tokens[i];

            if (typeof token === "number") {
                stack.push(token);

                // Check for factorial
                if (tokens[i + 1] === "!") {
                    stack[stack.length - 1] = factorial(stack[stack.length - 1]);
                    i++; // skip the '!' token
                }
            }
            else if (token === "sqrt") {
                let [val, nextIndex] = helper(i + 1);
                stack.push(Math.sqrt(val));

                // Check for factorial after function
                if (tokens[nextIndex + 1] === "!") {
                    stack[stack.length - 1] = factorial(stack[stack.length - 1]);
                    nextIndex++;
                }

                i = nextIndex;
            }
            else if (token === "(") {
                let [val, nextIndex] = helper(i + 1);
                stack.push(val);

                // Factorial for parentheses
                if (tokens[nextIndex + 1] === "!") {
                    stack[stack.length - 1] = factorial(stack[stack.length - 1]);
                    nextIndex++;
                }

                i = nextIndex;
            }
            else if (token === ")") {
                break;
            }
            else {
                // operator
                stack.push(token);
            }
            i++;
        }


        // First handle * and /
        for (let j = 0; j < stack.length; j++) {
            if (stack[j] === "*" || stack[j] === "/") {
                let left = stack[j - 1];
                let right = stack[j + 1];
                let result = stack[j] === "*" ? left * right : left / right;
                stack.splice(j - 1, 3, result);
                j--;
            }
        }

        // Then handle + and -
        for (let j = 0; j < stack.length; j++) {
            if (stack[j] === "+" || stack[j] === "-") {
                let left = stack[j - 1];
                let right = stack[j + 1];
                let result = stack[j] === "+" ? left + right : left - right;
                stack.splice(j - 1, 3, result);
                j--;
            }
        }

        return [stack[0], i];
    }

    return helper(0)[0];
}

function calculate(expr) {
    let tokens = parseEquation(expr);
    return evaluate(tokens);
}

elements.calculator = {
    canPlace: false,
    onSelect() {
        promptInput("Input your equation", (eq) => {
            try {
                let ans = calculate(eq)
                if (ans == Infinity) {
                    logMessage("Division by 0 error")
                    return;
                }
                if (isNaN(ans)) {
                    logMessage("Error")
                    return;
                }
                logMessage(Number(ans.toFixed(10)))
            }
            catch (e) {
                logMessage("Invalid Characters Detected")
                console.log(e)
            }
        })
    },
    category: "tools"
}

elements.random_teleporter = {
    buttonColor: ["#5fdaff", "#dd8500"],
    color: "#5fdaff",
    grain: 0,
    tick(pixel) {
        // Color fading
        pixel.fadeTo ??= "orange"
        pixel.colorStay ??= 30
        if (pixel.fadeTo === "orange") {
            if (pixel.colorStay > 0) {
                let ratio = pixel.colorStay / 30
                pixel.color = fadeColor("#dd8500", "#5fdaff", ratio)
                pixel.colorStay--
            } else pixel.fadeTo = "blue";
        } else {
            if (30 - pixel.colorStay > 0) {
                let ratio = (30 - pixel.colorStay) / 30
                pixel.color = fadeColor("#5fdaff", "#dd8500", ratio)
                pixel.colorStay++
            } else pixel.fadeTo = "orange";
        }

        for (var i = 0; i < squareCoords.length; i++) {
            let coord = squareCoords[i];
            let x = pixel.x + coord[0];
            let y = pixel.y + coord[1];
            if (!isEmpty(x, y)) {
                let p = getPixel(x, y)
                if (!p) return;
                if (elements[p.element]?.hardness === 1) return;
                let availableCoords = [];
                for (let j = 0; j <= width; j++) {
                    for (let k = 0; k <= height; k++) {
                        if (isEmpty(j, k)) {
                            availableCoords.push([j, k])
                        }
                    }
                }
                if (availableCoords.length > 0) {
                    let newCoords = choose(availableCoords)
                    tryMove(p, newCoords[0], newCoords[1])
                }
            }
        }
    },
    hardness: 1,
    behavior: behaviors.WALL,
    renderer: renderPresets.BORDER,
    category: "machines"
}

elements.fill_all = {
    color: "#ae4cd9",
    behavior: behaviors.WALL,
    category: "special",
    reactions: {
        "neutron": { elem1: "lattice" },
        "proton": { elem1: "vertical" },
        "electric": { elem1: "horizontal" },
        "positron": { elem1: "vertical" },
        "plasma": { elem1: "armageddon", tempMin: 500, charged: true }
    },
    density: 1834,
    tick(pixel) {
        for (let x = 0; x <= width; x++) {
            for (let y = 0; y <= height; y++) {
                tryCreate("filler", x, y)
            }
        }
        changePixel(pixel, "filler")
    },
    maxSize: 1,
    excludeRandom: true
}

globals.elemFillAll = "sand"
elements.element_fill_all = {
    color: "#ae4cd9",
    behavior: behaviors.WALL,
    category: "special",
    excludeRandom: true,
    reactions: {
        "neutron": { elem1: "lattice" },
        "proton": { elem1: "vertical" },
        "electric": { elem1: "horizontal" },
        "positron": { elem1: "vertical" },
        "plasma": { elem1: "armageddon", tempMin: 500, charged: true }
    },
    onSelect() {
        promptInput("What element should this filler fill", (elem) => {
            let el = mostSimilarElement(elem)
            if (el) {
                globals.elemFillAll = el
            }
        }, "Element Prompt")
    },
    tick(pixel) {
        for (let x = 0; x <= width; x++) {
            for (let y = 0; y <= height; y++) {
                tryCreate(globals.elemFillAll, x, y)
            }
        }
        changePixel(pixel, globals.elemFillAll)
    },
    maxSize: 1,
}

globals.pulsecol1 = "#ffffff"
globals.pulsecol2 = "#000000"
elements.pulsing_color = {
    buttonColor: rainbowColor,
    behavior: behaviors.WALL,
    category: "special",
    onSelect() {
        promptInput("Input the starting color of the pulse in hex", (col1) => {
            if (col1) {
                if (/^#([A-Fa-f0-9]{6})$/.test(col1)) {
                    globals.pulsecol1 = col1
                    promptInput("Input the second color that it should pulse to", (col2) => {
                        if (col2) {
                            if (/^#([A-Fa-f0-9]{6})$/.test(col2)) {
                                globals.pulsecol2 = col2
                            }
                        }
                    })
                }
            }
        })
    },
    onPlace(pixel) {
        pixel.color = globals.pulsecol1
    },
    tick(pixel) {
        // 1 = fade to color 2, 0 = fade to color 1
        let frames = 30
        pixel.fadeTo ??= 1
        pixel.colorStay ??= frames
        pixel.col1 ??= globals.pulsecol1
        pixel.col2 ??= globals.pulsecol2
        if (pixel.fadeTo === 1) {
            if (pixel.colorStay > 0) {
                let ratio = pixel.colorStay / frames
                pixel.color = fadeColor(pixel.col2, pixel.col1, ratio)
                pixel.colorStay--
            } else pixel.fadeTo = 0;
        } else {
            if (frames - pixel.colorStay > 0) {
                let ratio = (frames - pixel.colorStay) / frames
                pixel.color = fadeColor(pixel.col1, pixel.col2, ratio)
                pixel.colorStay++
            } else pixel.fadeTo = 1;
        }
    }
}

globals.createElemWDir = "wood"
globals.lineDir = 0
elements.element_line = {
    color: "#d9d9d9",
    behavior: behaviors.WALL,
    category: "special",
    hidden: true,
    excludeRandom: true,
    insulate: true,
    movable: false,
    onSelect() {
        promptInput("Input the element it should use", (input) => {
            if (!input) return;
            let elem = mostSimilarElement(input)
            if (elem) {
                globals.createElemWDir = elem
            }
            promptDir("Choose The direction the line should draw in", (dir) => {
                globals.lineDir = dir
            }, "Direction Input")
        }, "Element Input")
    },
    onPlace(pixel) {
        pixel.clone ??= globals.createElemWDir
        pixel.dir ??= globals.lineDir
    },
    tick(pixel) {
        if (pixel.dir === 0) {
            if (!tryMove(pixel, pixel.x + 1, pixel.y, pixel.clone)) {
                changePixel(pixel, pixel.clone, true)
            }
        }
        if (pixel.dir === 1) {
            if (!tryMove(pixel, pixel.x, pixel.y + 1, pixel.clone)) {
                changePixel(pixel, pixel.clone, true)
            }
        }
        if (pixel.dir === 2) {
            if (!tryMove(pixel, pixel.x + 1, pixel.y, pixel.clone)) {
                changePixel(pixel, pixel.clone, true)
            }
        }
        if (pixel.dir === 3) {
            if (!tryMove(pixel, pixel.x, pixel.y - 1, pixel.clone)) {
                changePixel(pixel, pixel.clone, true)
            }
        }
    }
}

function getSquareCoords(pixel) {
    let x, y;
    for (let i = 0; i < squareCoords.length; i++) {
        let coord = squareCoords[i];
        x = pixel.x + coord[0];
        y = pixel.y + coord[1];
    }
    return { x, y }
}

function getAdjacentCoords(pixel) {
    let x, y;
    for (let i = 0; i < adjacentCoords.length; i++) {
        x = pixel.x + adjacentCoords[i][0];
        y = pixel.y + adjacentCoords[i][1];
    }
    return { x, y }
}

function getSquareCoordsShuffle(pixel) {
    shuffleArray(squareCoordsShuffle);
    let x, y;
    for (var i = 0; i < squareCoordsShuffle.length; i++) {
        var coord = squareCoordsShuffle[i];
        x = pixel.x + coord[0];
        y = pixel.y + coord[1];
    }
    return { x, y }
}

function getAdjacentCoordsShuffle(pixel) {
    shuffleArray(adjacentCoordsShuffle)
    let x, y
    for (var i = 0; i < adjacentCoordsShuffle.length; i++) {
        x = pixel.x + adjacentCoordsShuffle[i][0];
        y = pixel.y + adjacentCoordsShuffle[i][1];
    }
    return { x, y }
}

function getScreenCoords() {
    let coords = []
    for (let x = 0; x <= width; x++) {
        for (let y = 0; y <= height; y++) {
            coords.push([x, y])
        }
    }
    return coords
}

globals.replaceElem = "wood"
elements.replace_all_of_element = {
    color: ["#35008a", "#000000"],
    category: "tools",
    onSelect() {
        promptInput("What should it change into?", (input) => {
            if (!input) return;
            let elem = mostSimilarElement(input)
            if (elem) {
                globals.replaceElem = elem
            }
        }, "Element Prompt")
    },
    tool(pixel) {
        let elem = pixel.element
        if (elem === globals.replaceElem) return

        for (let row of pixelMap) {
            for (let p of row) {
                if (p?.element === elem) {
                    changePixel(p, globals.replaceElem)
                }
            }
        }
    }
}