elements.human.tick = function(pixel) {
    if (isEmpty(pixel.x, pixel.y+1)) {
        createPixel("body", pixel.x, pixel.y+1);
        var color = pixel.color;
        changePixel(pixel,"head");
        pixel.color = color;
        if (pixel.bodyColor) {
            pixelMap[pixel.x][pixel.y+1].color = pixel.bodyColor;
        }
    }
    else if (isEmpty(pixel.x, pixel.y-1)) {
        createPixel("head", pixel.x, pixel.y-1);
        pixelMap[pixel.x][pixel.y-1].color = pixel.color;
        changePixel(pixel,"body");
        if (pixel.bodyColor) {
            pixel.color = pixel.bodyColor;
        }
    }
}

elements.body.tick = function(pixel) {
    if (tryMove(pixel, pixel.x, pixel.y+1)) { // Fall
        if (!isEmpty(pixel.x, pixel.y-2, true)) { // Drag head down
            var headpixel = pixelMap[pixel.x][pixel.y-2];
            if (headpixel.element === "head") {
                if (isEmpty(pixel.x, pixel.y-1)) {
                    movePixel(pixelMap[pixel.x][pixel.y-2], pixel.x, pixel.y-1);
                }
                else {
                    swapPixels(pixelMap[pixel.x][pixel.y-2], pixelMap[pixel.x][pixel.y-1]);
                }
            }
        }
    }
    doHeat(pixel);
    doBurning(pixel);
    doElectricity(pixel);
    if (pixel.dead) {
        // Turn into rotten_meat if pixelTicks-dead > 500
        if (pixelTicks-pixel.dead > 200 && Math.random() < 0.1) {
            changePixel(pixel,"rotten_meat");
        }
        return
    }

    // Find the head
    if (!isEmpty(pixel.x, pixel.y-1, true) && pixelMap[pixel.x][pixel.y-1].element == "head") {
        var head = pixelMap[pixel.x][pixel.y-1];
        if (head.dead) { // If head is dead, kill body
            pixel.dead = head.dead;
        }
        else if (head.panic > 0) {
            pixel.panic = head.panic;
            delete head.panic;
        }
    }
    else { var head = null }
    if (head && Math.random() < 0.25) {
        let y = Math.random() < 0.5 ? 0 : -1;
        for (let x = 1; x < 10; x++) {
            let x2 = pixel.x+(x*pixel.dir);
            let y2 = pixel.y+y;
            if (!isEmpty(x2,y2,true)) {
                let seenPixel = pixelMap[x2][y2];
                if (elements.human.reactions[seenPixel.element] && elements.human.reactions[seenPixel.element].attr1 && elements.human.reactions[seenPixel.element].attr1.panic) {
                    pixel.panic += elements.human.reactions[seenPixel.element].attr1.panic;
                    pixel.dir *= -1;
                    break;
                }
                else if (seenPixel.dead || seenPixel.temp > 200) {
                    pixel.panic += 5;
                    pixel.dir *= -1;
                    if (seenPixel.panic) delete seenPixel.panic;
                    break;
                }
            }
        }
    }
    if (pixel.burning) {
        pixel.panic += 0.1;
        if (head && pixelTicks-pixel.burnStart > 240) {
            pixel.color = head.color;
        }
    }
    if (pixel.charge) {
        pixel.panic += 1;
    }
    else if (pixel.panic > 0) {
        pixel.panic -= 0.1;
        if (pixel.panic < 0) { pixel.panic = 0; }
        else if (pixel.panic > 50) { pixel.panic = 50; }
    }

    if (isEmpty(pixel.x, pixel.y-1)) {
        // create blood if decapitated 10% chance
        if (Math.random() < 0.1 && !pixel.charge) {
            createPixel("blood", pixel.x, pixel.y-1);
            // set dead to true 15% chance
            if (Math.random() < 0.15) {
                pixel.dead = pixelTicks;
            }
        }
    }
    else if (head === null) { return }
    else if (Math.random() < 0.1*(isEmpty(pixel.x, pixel.y+1) ? 1 : pixel.panic+1)) { // Move 10% chance
        var movesToTry = [
            [1*pixel.dir,0],
            [1*pixel.dir,-1],
        ];
        let moved = false;
        // While movesToTry is not empty, tryMove(pixel, x, y) with a random move, then remove it. if tryMove returns true, break.
        while (movesToTry.length > 0) {
            var move = movesToTry.splice(Math.floor(Math.random() * movesToTry.length), 1)[0];
            if (isEmpty(pixel.x+move[0], pixel.y+move[1]-1)) {
                var origx = pixel.x+move[0];
                var origy = pixel.y+move[1];
                if (tryMove(pixel, pixel.x+move[0], pixel.y+move[1]) && pixel.x===origx && pixel.y===origy) {
                    movePixel(head, head.x+move[0], head.y+move[1]);
                    moved = true;
                    break;
                }
            }
            else if (!isEmpty(pixel.x+move[0], pixel.y+move[1], true)) {
                var hitPixel = pixelMap[pixel.x+move[0]][pixel.y+move[1]];
                if (hitPixel.element === "body" || hitPixel.element === "head" && hitPixel.panic < pixel.panic) {
                    // interact with other human
                    hitPixel.panic = pixel.panic;
                }
            }
        }
        // 15% chance to change direction
        if (Math.random() < 0.15 || !moved) {
            pixel.dir *= -1;
        }
        // homeostasis
        if (pixel.temp > 37) { pixel.temp -= 1; }
        else if (pixel.temp < 37) { pixel.temp += 1; }
    }

}

elements.portal_in.tick = function(pixel) {
    // if (Math.random() > 0.1) return;
    if (!ticktemp.portal_out) ticktemp.portal_out = {};
    let channel = parseInt(pixel.channel) || 0;
    if (!ticktemp.portal_out[channel]) {
        ticktemp.portal_out[channel] = currentPixels.filter((p) => {
            return elements[p.element].id === elements.portal_out.id && (
                isEmpty(p.x,p.y+1) || isEmpty(p.x,p.y-1) ||
                isEmpty(p.x+1,p.y) || isEmpty(p.x-1,p.y)
            ) &&
                (parseInt(p.channel) || 0) === parseInt(channel)
        });
    }
    if (ticktemp.portal_out[channel].length) {
        shuffleArray(squareCoordsShuffle);
        let r;
        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,true) && elements[pixelMap[x][y].element].movable) {
                r = pixelMap[x][y];
                break;
            }
        }
        if (r !== undefined || pixel.charge) {
            let portal_out = choose(ticktemp.portal_out[channel]);
            if (portal_out.del) return;
            if (r !== undefined) {
                shuffleArray(squareCoordsShuffle);
                for (var j = 0; j < squareCoordsShuffle.length; j++) {
                    var coord2 = squareCoordsShuffle[j];
                    var x2 = portal_out.x+coord2[0];
                    var y2 = portal_out.y+coord2[1];
                    if (isEmpty(x2,y2) && r.element !== "head" && r.element !== "body") {
                        tryMove(r,x2,y2);
                    }
                    else if (isEmpty(x2,y2) && (r.element === "head" || r.element === "body")) {
                        if (r.element === "head" && !isEmpty(r.x,r.y+1)) {
                            if (pixelMap[r.x][r.y+1].element === "body") {
                                r.element = "human"
                                r.bodyColor = pixelMap[r.x][r.y+1].color
                                deletePixel(r.x,r.y+1)
                                tryMove(r,x2,y2);
                            }
                            else {
                                tryMove(r,x2,y2);
                            }
                        }
                        else if (r.element === "body" && !isEmpty(r.x,r.y-1)) {
                            if (pixelMap[r.x][r.y-1].element === "head") {
                                r.element = "human"
                                r.bodyColor = r.color
                                r.color = pixelMap[r.x][r.y-1].color
                                deletePixel(r.x,r.y-1)
                                tryMove(r,x2,y2);
                            }
                            else {
                                tryMove(r,x2,y2);
                            }
                        }
                    }
                    break;
                }
            }
            if (pixel.charge && !portal_out.charge && !portal_out.chargeCD) {
                portal_out.charge = pixel.charge;
            }
        }
    };
    doElectricity(pixel);
}

elements.pipe.tick = function(pixel) {
    if (!pixel.stage && pixelTicks-pixel.start > 60) {
        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,true) && elements[pixelMap[x][y].element].movable) {
                deletePixel(x,y)
            }
            if (isEmpty(x,y)) {
                createPixel("pipe_wall",x,y);
            }
        }
        pixel.stage = 1;
    }
    else if (pixel.stage === 1 && pixelTicks-pixel.start > 70) { //uninitialized
        for (var i = 0; i < adjacentCoords.length; i++) {
            var coord = adjacentCoords[i];
            var x = pixel.x+coord[0];
            var y = pixel.y+coord[1];
            if (isEmpty(x,y)) {
                pixel.stage = 2; //blue
                pixel.color = pixelColorPick(pixel,"#000036");
                break;
            }
        }
    }
    else if (pixel.stage > 1 && pixelTicks % 3 === pixel.stage-2) { //initialized
        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,true) && pixelMap[x][y].element === "pipe") {
                var newPixel = pixelMap[x][y];
                if (newPixel.stage === 1) {
                    var newColor;
                    switch (pixel.stage) {
                        case 2: newPixel.stage = 3; newColor = "#003600"; break; //green
                        case 3: newPixel.stage = 4; newColor = "#360000"; break; //red
                        case 4: newPixel.stage = 2; newColor = "#000036"; break; //blue
                    }
                    newPixel.color = pixelColorPick(newPixel,newColor);
                }
            }
        }
        var moved = false;
        shuffleArray(squareCoordsShuffle);
        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,true)) {
                var newPixel = pixelMap[x][y];
                if (newPixel.element === "pipe") {
                    var nextStage;
                    switch (pixel.stage) {
                        case 2: nextStage = 4; break; //green
                        case 3: nextStage = 2; break; //red
                        case 4: nextStage = 3; break; //blue
                    }
                    if (pixel.con && !newPixel.con && newPixel.stage === nextStage) { //transfer to adjacent pipe
                        newPixel.con = pixel.con;
                        newPixel.con.x = newPixel.x;
                        newPixel.con.y = newPixel.y;
                        pixel.con = null;
                        moved = true;
                        break;
                    }
                }
                else if (!pixel.con && elements[newPixel.element].movable && newPixel.element !== "head" && newPixel.element !== "body") { //suck up pixel
                    pixel.con = newPixel;
                    deletePixel(newPixel.x,newPixel.y);
                    pixel.con.x = pixel.x;
                    pixel.con.y = pixel.y;
                    pixel.con.del;
                    moved = true;
                    break;
                }
                else if (!pixel.con && elements[newPixel.element].movable && (newPixel.element === "head" || newPixel.element === "body")) {
                    if (newPixel.element === "head") {
                        if (!isEmpty(newPixel.x,newPixel.y+1)) {
                        if (pixelMap[newPixel.x][newPixel.y+1].element === "body") {
                            newPixel.element = "human"
                            newPixel.bodyColor = pixelMap[newPixel.x][newPixel.y+1].color
                            deletePixel(newPixel.x,newPixel.y+1)
                            pixel.con = newPixel;
                            deletePixel(newPixel.x,newPixel.y);
                            pixel.con.x = pixel.x;
                            pixel.con.y = pixel.y;
                            pixel.con.del;
                            moved = true;
                            break;
                        }
                        else {
                            pixel.con = newPixel;
                            deletePixel(newPixel.x,newPixel.y);
                            pixel.con.x = pixel.x;
                            pixel.con.y = pixel.y;
                            pixel.con.del;
                            moved = true;
                            break;
                        }
                        }
                        else {
                            pixel.con = newPixel;
                            deletePixel(newPixel.x,newPixel.y);
                            pixel.con.x = pixel.x;
                            pixel.con.y = pixel.y;
                            pixel.con.del;
                            moved = true;
                            break;
                        }
                    }
                    else if (newPixel.element === "body") {
                        if (!isEmpty(newPixel.x,newPixel.y-1)) {
                        if (pixelMap[newPixel.x][newPixel.y-1].element === "head") {
                            newPixel.element = "human"
                            newPixel.bodyColor = newPixel.color
                            newPixel.color = pixelMap[newPixel.x][newPixel.y-1].color
                            deletePixel(newPixel.x,newPixel.y-1)
                            pixel.con = newPixel;
                            deletePixel(newPixel.x,newPixel.y);
                            pixel.con.x = pixel.x;
                            pixel.con.y = pixel.y;
                            pixel.con.del;
                            moved = true;
                            break;
                        }
                        else {
                            pixel.con = newPixel;
                            deletePixel(newPixel.x,newPixel.y);
                            pixel.con.x = pixel.x;
                            pixel.con.y = pixel.y;
                            pixel.con.del;
                            moved = true;
                            break;
                        }
                        }
                        else {
                            pixel.con = newPixel;
                            deletePixel(newPixel.x,newPixel.y);
                            pixel.con.x = pixel.x;
                            pixel.con.y = pixel.y;
                            pixel.con.del;
                            moved = true;
                            break;
                        }
                    }
                    else {
                        pixel.con = newPixel;
                        deletePixel(newPixel.x,newPixel.y);
                        pixel.con.x = pixel.x;
                        pixel.con.y = pixel.y;
                        pixel.con.del;
                        moved = true;
                        break;
                    }
                }
            }
        }
        if (pixel.con && !moved) { // move to same stage if none other
            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)) {
                    delete pixel.con.del;
                    pixel.con.x = x;
                    pixel.con.y = y;
                    pixelMap[x][y] = pixel.con;
                    currentPixels.push(pixel.con);
                    pixel.con = null;
                    break;
                }
                if (!isEmpty(x,y,true) && pixelMap[x][y].element === "pipe") {
                    var newPixel = pixelMap[x][y];
                    if (pixel.con && !newPixel.con && newPixel.stage === pixel.stage) {
                        newPixel.con = pixel.con;
                        newPixel.con.x = newPixel.x;
                        newPixel.con.y = newPixel.y;
                        pixel.con = null;
                        break;
                    }
                }
            }
        }
    }
    doDefaults(pixel);
}

elements.drag.tool = function(pixel) {
    if (dragStart === null) {
        dragStart = pixelTicks;
        draggingPixels = [];
    }
    if (pixelTicks === dragStart && !pixel.drag && (elements[pixel.element].movable || shiftDown) && pixel.element !== "head") {
        pixel.drag = true;
        draggingPixels.push(pixel);
    }
}

elements.drag.perTick = function() {
    if (!draggingPixels) { return; }
    for (var j = 0; j < (shiftDown ? 3 : 1); j++) {
    for (var i = 0; i < draggingPixels.length; i++) {
        var pixel = draggingPixels[i];
        if (pixel.del) { continue }
        const x = pixel.x;
        const y = pixel.y;
        const [mX, mY] = [mousePos.x, mousePos.y];
        const empty = checkForEmptyPixels(x, y);
        let bestVal = Math.sqrt(Math.pow(mX - x, 2) + Math.pow(mY - y, 2));
        let best = null;
        for (const pixelPair of empty) {
            const x_ = x + pixelPair[0];
            const y_ = y + pixelPair[1];
            const c = Math.sqrt(Math.pow(mX - x_, 2) + Math.pow(mY - y_, 2));
            if (c < bestVal) {
                bestVal = c;
                best = pixelPair;
            }
        }
        if (best) {
            if (pixel.element !== "body") {
                tryMove(pixel, x + best[0], y + best[1], undefined, true);
            }
            else if (pixel.element === "body") {
                if (!isEmpty(pixel.x,pixel.y-1)) {
                    var headPixel = pixelMap[pixel.x][pixel.y-1]
                    if (headPixel.element === "head") {
                        if (isEmpty(x + best[0], y + best[1] - 1)) {
                            tryMove(headPixel, x + best[0], y + best[1] - 1, undefined, true);
                            tryMove(pixel, x + best[0], y + best[1], undefined, true);
                        }
                    }
                }
                else {tryMove(pixel, x + best[0], y + best[1], undefined, true);}
            }
        }
    }
    }
}

mouse1Action = function(e,mouseX=undefined,mouseY=undefined,startPos) {
    if (currentElement === "erase") { mouse2Action(e,mouseX,mouseY,startPos); return; }
    else if (currentElement === "pick") { mouseMiddleAction(e,mouseX,mouseY); return; }
    // If x and y are undefined, get the mouse position
    if (mouseX === undefined && mouseY === undefined) {
        // var canvas = document.getElementById("game");
        // var ctx = canvas.getContext("2d");
        lastPos = mousePos;
        mousePos = getMousePos(canvas, e);
        var mouseX = mousePos.x;
        var mouseY = mousePos.y;
    }
    var cooldowned = false;
    if (mouseSize===1 && elements[currentElement].cooldown && !paused) {
        if (pixelTicks-lastPlace < elements[currentElement].cooldown) {
            return;
        }
        cooldowned = true;
    }
    lastPlace = pixelTicks;
    if (cooldowned && !startPos) {
        var coords = mouseRange(mouseX,mouseY);
    }
    else {
        startPos = startPos || lastPos
        var coords = lineCoords(startPos.x,startPos.y,mouseX,mouseY);
    }
    // if (!((cooldowned && startPos.x===lastPos.x && startPos.y===lastPos.y) || ((elements[currentElement].tool || elements[currentElement].category==="tools") && !elements[currentElement].canPlace))) {
    // }
    // else { var coords = mouseRange(mouseX,mouseY); }
    var element = elements[currentElement];
    var mixList = [];
    // For each x,y in coords
    var done = {};
    for (var i = 0; i < coords.length; i++) {
        var x = coords[i][0];
        var y = coords[i][1];
        if (!done[x]) {
            done[x] = {}
        }
        if (done[x][y]) { continue; }
        done[x][y] = true;

        if (mode === "replace" && (!elements[currentElement].tool || elements[currentElement].canPlace)) {
            if (outOfBounds(x,y)) {
                continue;
            }
            // Remove pixel at position from currentPixels
            if (!isEmpty(x,y,true)) {
                if (!(currentElement === pixelMap[x][y].element && pixelMap[x][y].start === pixelTicks-1)) {
                    deletePixel(x,y);
                }
            }
        }

        if (currentElement === "mix") {
            if (!isEmpty(x,y,true)) {
                var pixel = pixelMap[x][y];
                if (!(elements[pixel.element].movable !== true || elements[pixel.element].noMix === true) || shiftDown) {
                    mixList.push(pixel);
                }
            }
            continue;
        }
        else if (elements[currentElement].tool && !(elements[currentElement].canPlace && isEmpty(x,y))) {
            // run the tool function on the pixel
            if (!isEmpty(x,y,true)) {
                var pixel = pixelMap[x][y];
                // if the current element has an ignore property and the pixel's element is in the ignore property, don't do anything
                if (elements[currentElement].ignore && elements[currentElement].ignore.indexOf(pixel.element) !== -1) {
                    continue;
                }
                elements[currentElement].tool(pixel);
            }
            continue;
        }
        if (isEmpty(x, y)) {
            if (currentPixels.length < maxPixelCount) {
                createPixel(currentElement,x,y);
                if (pixelMap[x][y] && currentElement === pixelMap[x][y].element && (elements[currentElement].customColor || elements[currentElement].singleColor)) {
                    pixelMap[x][y].color = pixelColorPick(pixelMap[x][y],currentColorMap[currentElement]);
                }
                if (currentElementProp) {
                    for (var key in currentElementProp) {
                        pixelMap[x][y][key] = currentElementProp[key]
                    }
                }
            }
        }
        else if (!outOfBounds(x,y)) {
            if (elements[currentElement].extinguish) {
                var pixel = pixelMap[x][y];
                if (pixel.burning && elements[pixel.element].burning !== true) {
                    delete pixel.burning;
                    delete pixel.burnStart;
                }
            }
        }
    }
    if (currentElement === "mix") {
        // 1. repeat for each pixel in mixList
        // 2. choose 2 random pixels and swap their x and y
        // 3. remove pixel from mixList
        for (var i = 0; i < mixList.length; i++) {
            var pixel1 = mixList[Math.floor(Math.random()*mixList.length)];
            var pixel2 = mixList[Math.floor(Math.random()*mixList.length)];
            if (pixel1.element !== "head" && pixel2.element !== "head" && pixel1.element !== "body" && pixel2.element !== "body") {
                swapPixels(pixel1,pixel2);
            }
            else if (pixel1.element !== "head" && pixel2.element !== "head" && (pixel1.element === "body" || pixel2.element === "body")) {
                if (pixel1.element === "body") {
                    if (!isEmpty(pixel1.x,pixel1.y-1, true)) {
                        var headPixel1 = pixelMap[pixel1.x][pixel1.y-1]
                        if (headPixel1.element === "head") {
                            if (!isEmpty(pixel2.x,pixel2.y-1, true)) {
                                var headPixel2 = pixelMap[pixel2.x][pixel2.y-1]
                                if (headPixel2.element !== "body" && !(elements[headPixel2.element].movable !== true || elements[headPixel2.element].noMix === true)) {
                                    swapPixels(pixel1,pixel2);
                                    swapPixels(headPixel1,headPixel2);
                                }
                            }
                            else if (isEmpty(pixel2.x,pixel2.y-1)) {
                                swapPixels(pixel1,pixel2)
                                tryMove(headPixel1, pixel1.x, pixel1.y-1)
                            }
                        }
                    }
                }
                else if (pixel2.element === "body") {
                    if (!isEmpty(pixel2.x,pixel2.y-1, true)) {
                        var headPixel1 = pixelMap[pixel2.x][pixel2.y-1]
                        if (headPixel1.element === "head") {
                            if (!isEmpty(pixel1.x,pixel1.y-1, true)) {
                                var headPixel2 = pixelMap[pixel1.x][pixel1.y-1]
                                if (headPixel2.element !== "body" && !(elements[headPixel2.element].movable !== true || elements[headPixel2.element].noMix === true)) {
                                    swapPixels(pixel1,pixel2);
                                    swapPixels(headPixel1,headPixel2);
                                }
                            }
                            else if (isEmpty(pixel1.x,pixel1.y-1)) {
                                swapPixels(pixel1,pixel2);
                                tryMove(headPixel1, pixel2.x,pixel2.y-1)
                            }
                        }
                    }
                }
            }
            mixList.splice(mixList.indexOf(pixel1),1);
            mixList.splice(mixList.indexOf(pixel2),1);
            if (elements[pixel1.element].onMix) {
                elements[pixel1.element].onMix(pixel1,pixel2);
            }
            if (elements[pixel2.element].onMix) {
                elements[pixel2.element].onMix(pixel2,pixel1);
            }
        }

    }
}

pixelTick = function(pixel,custom=null) {
    if (pixel.start === pixelTicks) {return}
    btemp = {};
    if (elements[pixel.element] === undefined) {
        pixel.invalidElement = pixel.element;
        changePixel(pixel,"unknown");
        return;
    }
    var info = elements[pixel.element];
    btemp.info = info;
    btemp.pixel = pixel;
    if (custom) { var behavior = custom; }
    else if (pixel.charge && info.behaviorOn) { var behavior = info.behaviorOn; }
    else { var behavior = info.behavior; }
    if (pixel.flipX) { behavior = flipBehavior(behavior,"x"); }
    if (pixel.flipY) { behavior = flipBehavior(behavior,"y"); }
    if (pixel.r) { behavior = rotateBehavior(behavior,pixel.r); }
    var x = pixel.x;
    var y = pixel.y;
    var move1Spots = []; btemp.move1Spots = move1Spots;
    var move2Spots = []; btemp.move2Spots = move2Spots;
    var supportSpots = []; btemp.supportSpots = supportSpots;
    var swapSpots = []; btemp.swapSpots = swapSpots;
    btemp.mixSpots = [];
    btemp.move = true;
    // Parse behavior
var height = behavior.length;
for (var by = 0; by < behavior.length; by++) {
var behaviorby = behavior[by];
var width = behaviorby.length;
for (var bx = 0; bx < behaviorby.length; bx++) {
    var b0 = behaviorby[bx];
    if (b0 === "XX") {continue}
    //if (b.includes(" OR ")) {
    //    b = b.split(" OR ")[Math.floor(Math.random()*b.split(" OR ").length)];
    //}
    // Loop through b0.split(" AND ")
    if (b0.indexOf(" AND ") !== -1) { var andsplit = b0.split(" AND "); }
    else { var andsplit = [b0]; }
    for (var i = 0; i < andsplit.length; i++) {
        var b = andsplit[i];
        if (b.indexOf(":") !== -1) {
            var arg = b.split(":")[1].split(/[\:\%]/)[0];
            if (b.indexOf("%") === -1) {
                b = b.split(/[\:\%]/)[0];
            }
        }
        else { var arg = null;}
        btemp.arg = arg;
        // If b has "%" followed by a number in it, it's a chance to move
        if (b.indexOf("%") !== -1) {
            // Split the string at the "%" and use the second half as the chance (float)
            var chance = parseFloat(b.split("%")[1]);
            //console.log(b+": "+(Math.random()*100 < chance));
            b = b.split(/[\:\%]/)[0];
        }
        else { var chance = 100; }
        if (chance===100 || Math.random()*100 < chance) {
            var newCoords = behaviorCoords(x,y,bx,by,width,height);
            btemp.newCoords = newCoords;
            if (behaviorRules[b]) {
                behaviorRules[b]();
                continue;
            }
        }
    }
    }
    }
    if (btemp.deleted) {return;}
    if (supportSpots.length > 0) {
        var supportCount = 0;
        var allEmpty = true;
        for (var i = 0; i < supportSpots.length; i++) {
            var bx = supportSpots[i].x;
            var by = supportSpots[i].y;
            var arg = supportSpots[i].arg;
            if (!isEmpty(bx,by,true)) {
                if (info.ignore && info.ignore.indexOf(pixelMap[bx][by].element) !== -1) {continue;}
                if ((arg === null && !validDensitySwaps[info.state][elements[pixelMap[bx][by].element].state]) || pixelMap[bx][by].element == arg) {
                    supportCount++;
                }
            }
        }
        if (supportCount == supportSpots.length) {
            btemp.move = false;
        }
    }
    
    var moved = false;

    if (swapSpots.length > 0) {
        var coords = swapSpots[Math.floor(Math.random()*swapSpots.length)];
        if (pixelMap[coords.x][coords.y] !== undefined) {
            swapPixels(pixel,pixelMap[coords.x][coords.y]);
            btemp.move = false;
            moved = true;
        }
    }

    if (btemp.mixSpots.length > 0) {
        for (var i = 0; i < btemp.mixSpots.length; i++) {
            var coord1 = choose(btemp.mixSpots);
            var coord2 = choose(btemp.mixSpots);
            var exists1 = !isEmpty(coord1.x,coord1.y,true);
            var exists2 = !isEmpty(coord2.x,coord2.y,true);
            if (isEmpty(coord1.x,coord1.y) && exists2) {
                var pixel1 = pixelMap[coord2.x][coord2.y]
                if (pixel1.element !== "head" && pixel1.element !== "body") {
                    tryMove(pixel1,coord1.x,coord1.y);
                }
                else if (pixel1.element !== "head" && pixel1.element === "body") {
                        if (!isEmpty(pixel1.x,pixel1.y-1, true)) {
                            var headPixel1 = pixelMap[pixel1.x][pixel1.y-1]
                            if (headPixel1.element === "head") {
                                if (!isEmpty(coord1.x,coord1.y-1, true)) {
                                    var headPixel2 = pixelMap[coord1.x][coord1.y-1]
                                    if (headPixel2.element !== "body" && !(elements[headPixel2.element].movable !== true || elements[headPixel2.element].noMix === true)) {
                                        tryMove(pixel1,coord1.x,coord1.y);
                                        swapPixels(headPixel1,headPixel2);
                                    }
                                }
                                else if (isEmpty(coord1.x,coord1.y-1)) {
                                    tryMove(pixel1,coord1.x,coord1.y);
                                    tryMove(headPixel1, pixel1.x, pixel1.y-1)
                                }
                            }
                        }
                }
            }
            else if (exists1 && isEmpty(coord2.x,coord2.y)) {
                var pixel1 = pixelMap[coord1.x][coord1.y]
                if (pixel1.element !== "head" && pixel1.element !== "body") {
                    tryMove(pixel1,coord2.x,coord2.y);
                }
                else if (pixel1.element !== "head" && pixel1.element === "body") {
                        if (!isEmpty(pixel1.x,pixel1.y-1, true)) {
                            var headPixel1 = pixelMap[pixel1.x][pixel1.y-1]
                            if (headPixel1.element === "head") {
                                if (!isEmpty(coord2.x,coord2.y-1, true)) {
                                    var headPixel2 = pixelMap[coord2.x][coord2.y-1]
                                    if (headPixel2.element !== "body" && !(elements[headPixel2.element].movable !== true || elements[headPixel2.element].noMix === true)) {
                                        tryMove(pixel1,coord2.x,coord2.y);
                                        swapPixels(headPixel1,headPixel2);
                                    }
                                }
                                else if (isEmpty(coord2.x,coord2.y-1)) {
                                    tryMove(pixel1,coord2.x,coord2.y);
                                    tryMove(headPixel1, pixel1.x, pixel1.y-1)
                                }
                            }
                        }
                }
            }
            else if (exists1 && exists2) {
                var pixel1 = pixelMap[coord1.x][coord1.y];
                var pixel2 = pixelMap[coord2.x][coord2.y];
                if (pixel1.element !== "head" && pixel2.element !== "head" && pixel1.element !== "body" && pixel2.element !== "body") {
                    swapPixels(pixel1,pixel2);
                }
                else if (pixel1.element !== "head" && pixel2.element !== "head" && (pixel1.element === "body" || pixel2.element === "body")) {
                    if (pixel1.element === "body") {
                        if (!isEmpty(pixel1.x,pixel1.y-1, true)) {
                            var headPixel1 = pixelMap[pixel1.x][pixel1.y-1]
                            if (headPixel1.element === "head") {
                                if (!isEmpty(pixel2.x,pixel2.y-1, true)) {
                                    var headPixel2 = pixelMap[pixel2.x][pixel2.y-1]
                                    if (headPixel2.element !== "body" && !(elements[headPixel2.element].movable !== true || elements[headPixel2.element].noMix === true)) {
                                        swapPixels(pixel1,pixel2);
                                        swapPixels(headPixel1,headPixel2);
                                    }
                                }
                                else if (isEmpty(pixel2.x,pixel2.y-1)) {
                                    swapPixels(pixel1,pixel2)
                                    tryMove(headPixel1, pixel1.x, pixel1.y-1)
                                }
                            }
                        }
                    }
                    else if (pixel2.element === "body") {
                        if (!isEmpty(pixel2.x,pixel2.y-1, true)) {
                            var headPixel1 = pixelMap[pixel2.x][pixel2.y-1]
                            if (headPixel1.element === "head") {
                                if (!isEmpty(pixel1.x,pixel1.y-1, true)) {
                                    var headPixel2 = pixelMap[pixel1.x][pixel1.y-1]
                                    if (headPixel2.element !== "body" && !(elements[headPixel2.element].movable !== true || elements[headPixel2.element].noMix === true)) {
                                        swapPixels(pixel1,pixel2);
                                        swapPixels(headPixel1,headPixel2);
                                    }
                                }
                                else if (isEmpty(pixel1.x,pixel1.y-1)) {
                                    swapPixels(pixel1,pixel2);
                                    tryMove(headPixel1, pixel2.x,pixel2.y-1)
                                }
                            }
                        }
                    }
                }
                if (elements[pixel1.element].onMix) {
                    elements[pixel1.element].onMix(pixel1,pixel2);
                }
                if (elements[pixel2.element].onMix) {
                    elements[pixel2.element].onMix(pixel2,pixel1);
                }
            }
        }
    }

    if (btemp.sticking) {
        btemp.move = false;
    }
    
    // Move First Priority
    if (btemp.move) {
        if (move1Spots.length > 0) {
            // While move1Spots is not empty
            while (move1Spots.length > 0) {
                // coords = random item of move1Spots
                var j = Math.floor(Math.random()*move1Spots.length);
                var coords = move1Spots[j];
                var nx = coords.x;
                var ny = coords.y;
                moved = tryMove(pixel,nx,ny,btemp.leaveBehind1 || btemp.leaveBehind);
                if (moved) {
                    break;
                }
                else {
                    // remove coords from move1Spots
                    move1Spots.splice(j,1);
                }

                
            }
        }
        // Move Second Priority
        if (!moved && move2Spots.length > 0) {
            // While move2Spots is not empty
            while (move2Spots.length > 0) {
                // coords = random item of move2Spots
                var j = Math.floor(Math.random()*move2Spots.length);
                var coords = move2Spots[j];
                var nx = coords.x;
                var ny = coords.y;
                moved = tryMove(pixel,nx,ny,btemp.leaveBehind2 || btemp.leaveBehind);
                if (moved) {
                    if (btemp.C2 && elements[btemp.C2]) {
                        changePixel(pixel,btemp.C2);
                    }
                    break;
                }
                else {
                    // remove coords from move2Spots
                    move2Spots.splice(j,1);
                }
            }
        }
    }
    doAirDensity(pixel);


    // Change tempearture if needed (unused)
    /*if (info.tempChange != undefined) {
        pixel.temp += info.tempChange;
        pixelTempCheck(pixel);
    }*/

    // Burning
    doBurning(pixel);

    // Heat Transfer
    if (info.insulate !== true) {
        doHeat(pixel);
    }

    // Electricity Transfer
    doElectricity(pixel);

    // Staining
    if (info.stain) {
        doStaining(pixel);
    }

}