Pasted

-- Defaults
local flags = {
    ["placing"] = false,
    ["placingDown"] = false,
    ["placingUp"] = false,
    ["placingLeft"] = false,
    ["placingRight"] = false,
    ["placingBack"] = false,
    ["digging"] = false,
    ["diggingUp"] = false,
    ["diggingDown"] = false,
    ["diggingLeft"] = false,
    ["diggingRight"] = false,
    ["attacking"] = true,
}
 
local fuelList = {
    "minecraft:coal",
    "minecraft:planks",
    "minecraft:log",
    "minecraft:stick",
    "minecraft:coal_block",
}
 
function contains(table, element)
    for _,v in ipairs(table) do
        if v == element then
            return true
        end
    end
    return false
end
 
function selectFromList(list)
    local selected = turtle.getItemDetail()
    if selected and contains(list, selected.name) then
        -- Already selected
        return true
    end
 
    for slot=16,1,-1 do
        local data = turtle.getItemDetail(slot)
 
        if data then
            if contains(list, data.name) then
                turtle.select(slot)
                return true
            end
        end
    end
    return false
end
 
function refuelIfLow(val, amt)
    val = val or 5
    amt = amt or 1
    if turtle.getFuelLevel() < val then
        if selectFromList(fuelList) then
            turtle.refuel(amt)
        end
    end
end
 
function select(slot)
    turtle.select(slot)
end
 
function togglePlace()
    flags["placing"] = not flags["placing"]
end
 
function togglePlaceDown()
    flags["placingDown"] = not flags["placingDown"]
end
 
function togglePlaceUp()
    flags["placingUp"] = not flags["placingUp"]
end
 
function togglePlaceLeft()
    flags["placingLeft"] = not flags["placingLeft"]
end
 
function togglePlaceRight()
    flags["placingRight"] = not flags["placingRight"]
end
 
function togglePlaceBack()
    flags["placingBack"] = not flags["placingBack"]
end
 
function toggleDig()
    flags["digging"] = not flags["digging"]
end
 
function toggleDigUp()
    flags["diggingUp"] = not flags["diggingUp"]
end
 
function toggleDigDown()
    flags["diggingDown"] = not flags["diggingDown"]
end
 
function toggleDigLeft()
    flags["diggingLeft"] = not flags["diggingLeft"]
end
 
function toggleDigRight()
    flags["diggingRight"] = not flags["diggingRight"]
end
 
function toggleAttack()
    flags["attacking"] = not flags["attacking"]
end
 
function turnRight(turns)
    turns = turns or 1
    for i=1,turns do
        turtle.turnRight()
    end
end
 
function turnLeft(turns)
    turns = turns or 1
    for i=1,turns do
        turtle.turnLeft()
    end
end
 
function move(func, blocks)
    blocks = blocks or 1
    local digFunc
    if func == "f" then
        func = turtle.forward
        digFunc = turtle.dig
    elseif func == "u" then
        func = turtle.up
        digFunc = turtle.digUp
    elseif func == "d" then
        func = turtle.down
        digFunc = turtle.digDown
    elseif func == "b" then
        func = turtle.back
        digFunc = turtle.dig
    end
 
    for block=1,blocks do
        if flags["placing"] and not turtle.detect() then
            turtle.place()
        end
 
        if flags["placingDown"] and not turtle.detectDown() then
            turtle.placeDown()
        end
 
        if flags["placingUp"] and not turtle.detectUp() then
            turtle.placeUp()
        end
 
        if flags["placingLeft"] then
            turnLeft()
            turtle.place()
            turnRight()
        end
 
        if flags["placingRight"] then
            turnRight()
            turtle.place()
            turnLeft()
        end
 
        if flags["placingBack"] then
            if math.random(2) == 1 then
                turnRight(2)
            else
                turnLeft(2)
            end
            turtle.place()
            if math.random(2) == 1 then
                turnRight(2)
            else
                turnLeft(2)
            end
        end
 
        local dug, digError
        if flags["digging"] then
            dug, digError = turtle.dig()
            if not dug and flags["attacking"] then
                repeat until not turtle.attack()
            end
        end
 
        if flags["diggingUp"] then
            turtle.digUp()
        end
 
        if flags["diggingDown"] then
            turtle.digDown()
        end
 
        if flags["diggingLeft"] then
            turnLeft()
            dug, digError = turtle.dig()
            if not dug and flags["attacking"] then
                repeat until not turtle.attack()
            end
            turnRight()
        end
 
        if flags["diggingRight"] then
            turnRight()
            dug, digError = turtle.dig()
            if not dug and flags["attacking"] then
                repeat until not turtle.attack()
            end
            turnLeft()
        end
 
        refuelIfLow()
        local moved = func()
        if not moved then
            repeat
                local dug,err
                if flags["digging"] then
                    dug,err = digFunc()
                end
 
                if flags["attacking"] and not dug then
                    if not turtle.attack() then
                        print("I think I hit bedrock, skipping to next command...")
                        return false
                    end
                end
            until func()
        end
    end
 
    return true
end
 
function forward(blocks)
    return move("f", blocks)
end
 
function right(blocks)
    turnRight()
    local result = move("f", blocks)
    turnLeft()
    return result
end
 
function left(blocks)
    turnLeft()
    local result = move("f", blocks)
    turnRight()
    return result
end
 
function back(blocks)
    if flags["attacking"] or flags["digging"] then
        if math.random(2) == 1 then
            turnRight(2)
        else
            turnLeft(2)
        end
    end
    local result = move((flags["attacking"] or flags["digging"]) and "f" or "b", blocks)
    if flags["attacking"] or flags["digging"] then
        if math.random(2) == 1 then
            turnRight(2)
        else
            turnLeft(2)
        end
    end
    return result
end
 
function up(blocks)
    return move("u", blocks)
end
 
function down(blocks)
    return move("d", blocks)
end
 
function place()
    return turtle.place()
end
 
function placeDown()
    return turtle.placeDown()
end
 
function placeUp()
    return turtle.placeUp()
end
 
function placeBack()
    if math.random(2) == 1 then
        turnRight(2)
    else
        turnLeft(2)
    end
    local result = turtle.place()
    if math.random(2) == 1 then
        turnRight(2)
    else
        turnLeft(2)
    end
    return result
end
 
function placeLeft()
    turnLeft()
    local result = turtle.place()
    turnRight()
    return result
end
 
function placeRight()
    turnRight()
    local result = turtle.place()
    turnLeft()
    return result
end
 
function dig()
    return turtle.dig()
end
 
function digUp()
    return turtle.digUp()
end
 
function digDown()
    return turtle.digDown()
end
 
function digRight()
    turnRight()
    local result = turtle.dig()
    turnLeft()
    return result
end
 
function digLeft()
    turnLeft()
    local result = turtle.dig()
    turnRight()
    return result
end
 
function digBack()
    if math.random(2) == 1 then
        turnRight(2)
    else
        turnLeft(2)
    end
    local result = turtle.dig()
    if math.random(2) == 1 then
        turnRight(2)
    else
        turnLeft(2)
    end
    return result
end
 
local commands = {
    ["f"] = forward, ["fd"] = forward, ["forward"] = forward,
    ["r"] = right, ["right"] = right,
    ["l"] = left, ["left"] = left,
    ["b"] = back, ["back"] = back,
    ["u"] = up, ["up"] = up,
    ["d"] = down, ["down"] = down,
    ["tr"] = turnRight, ["rt"] = turnRight, ["turnright"] = turnRight,
    ["tl"] = turnLeft, ["lt"] = turnLeft, ["turnleft"] = turnLeft,
    ["s"] = select, ["sl"] = select, ["sel"] = select, ["select"] = select,
    ["p"] = place, ["place"] = place,
    ["tp"] = togglePlace, ["toggleplace"] = togglePlace,
    ["pd"] = placeDown, ["placedown"] = placeDown,
    ["tpd"] = togglePlaceDown, ["toggleplacedown"] = togglePlaceDown,
    ["pu"] = placeUp, ["placeup"] = placeUp,
    ["tpu"] = togglePlaceUp, ["toggleplaceup"] = togglePlaceUp,
    ["pl"] = placeLeft, ["placeleft"] = placeLeft,
    ["tpl"] = togglePlaceLeft, ["toggleplaceleft"] = togglePlaceLeft,
    ["pr"] = placeRight, ["placeright"] = placeRight,
    ["tpr"] = togglePlaceRight, ["toggleplaceright"] = togglePlaceRight,
    ["pb"] = placeBack, ["placeback"] = placeBack,
    ["tpb"] = togglePlaceBack, ["tpb"] = togglePlaceBack,
    ["dig"] = dig,
    ["td"] = toggleDig, ["tdig"] = toggleDig, ["toggledig"] = toggleDig,
    ["du"] = digUp, ["digup"] = digUp,
    ["tdu"] = toggleDigUp, ["tdigup"] = toggleDigUp, ["toggledigup"] = toggleDigUp,
    ["dd"] = digDown, ["digdown"] = digDown,
    ["tdd"] = toggleDigDown, ["tdigdown"] = toggleDigDown, ["toggledigdown"] = toggleDigDown,
    ["dr"] = digRight, ["digright"] = digRight,
    ["tdr"] = toggleDigRight, ["tdigright"] = toggleDigRight, ["toggledigright"] = toggleDigRight,
    ["dl"] = digLeft, ["digleft"] = digLeft,
    ["tdl"] = toggleDigLeft, ["tdigleft"] = toggleDigLeft, ["toggledigleft"] = toggleDigLeft,
    ["db"] = digBack, ["digback"] = digBack,
    ["ta"] = toggleAttack, ["toggleattack"] = toggleAttack,
}
 
function shift(t)
    return table.remove(t, 1)
end
 
local queue = {}
 
function join(t, s)
    local result = ""
    for i,v in ipairs(t) do
        result = result .. v
        if i ~= #t then
            result = result .. s
        end
    end
    
    return result
end
 
function trim(s)
  return (s:gsub("^%s*(.-)%s*$", "%1"))
end
 
function capture(s)
    local p = "(%b()) (%d%d?)"
    local _,_,group,times = s:find(p)
 
    if not group then
        return false
    end
 
    local times = tonumber(times)
    local result = trim(
        s:gsub(p, (group:sub(2, -2) .. " "):rep(times))
    )
 
    return result
end
 
function parse(s)
    local result = s
    repeat
        result = capture(s) or result
    until not capture(result)
 
    return result
end
 
function validate(name)
    return name and (commands[name] or shell.resolveProgram(name))
end
 
local args = {...}
local joinedArgs = join(args, " ")
local unpackedArgs = {}
for word in parse(joinedArgs):gmatch("%S+") do table.insert(unpackedArgs, word) end
 
while #unpackedArgs ~= 0 do
    local name = shift(unpackedArgs)
    if not validate(name) then
        print(name .. " is not a valid program")
        return
    end
    local arg = tonumber(unpackedArgs[1])
    if arg ~= nil then
        shift(unpackedArgs)
    end
    table.insert(queue, { ["name"] = name, ["arg"] = arg })
end
 
for i,v in ipairs(queue) do
    local name, arg = v.name:lower(), v.arg
    local cmd = commands[name]
 
    if cmd then
        cmd(arg)
    elseif name then
        local resolved = shell.resolveProgram(name)
        if resolved then
            shell.run(resolved, arg)
        else
        end
    end
end