Fancy new Move API

--NEW ALL SINGING ALL DANCING MOVE API--

os.loadAPI("API/draw") --I know you shouldn't do this =)

--CONSTANTS

N = 0
E = 1
S = 2
W = 3
FUEL = 1
FUELMIN = 80

--VARIABLES

digging = false
building = false
refuel = false
unloading = false

--LOADED INIT

function init()
    if fs.exists("Tables/myTab") then
        data = fs.open("Tables/myTab", "r")
        myTab = textutils.unserialize(data.readLine())
        data.close()
    else
        local x, y = term.getSize()
        draw.clear()
        draw.centerText(1, x, (y / 2) - 1, draw.black, draw.lime, "Hi there! I'm your new turtle friend")
        sleep(2)
        draw.centerText(1, x, (y / 2) + 1, draw.black, draw.lime, ".;,;.")
        sleep(2)
        draw.clear()
        draw.centerText(1, x, (y / 2), draw.black, draw.lime, "Main thing really, what is my name?")
        sleep(1)
        draw.centerText(1, x, (y / 2) + 1, draw.black, draw.lime, "try to keep it under 7 letters,")
        sleep(1)
        draw.centerText(1, x, (y / 2) + 2, draw.black, draw.lime, "I get scared by long words.")
        sleep(1)
        draw.centerText(1, x, (y / 2) + 3, draw.black, draw.lightBlue, "I shall call you ")
        tName = tostring(read())
        os.setComputerLabel(tName)
        sleep(1)
        draw.clear()
        draw.centerText(1, x, (y / 2) - 1, draw.black, draw.lime, "Hmmm, "..tName..".")
        sleep(2)
        draw.centerText(1, x, (y / 2), draw.black, draw.lime, "Hi there, I'm "..tName..".")
        sleep(2)
        draw.centerText(1, x, (y / 2) + 1, draw.black, draw.lime, "Good work "..tName)
        sleep(2)
        draw.centerText(1, x, (y / 2) + 2, draw.black, draw.lime, "That's what you'll be saying.")
        sleep(2)
        draw.centerText(1, x, (y / 2) + 3, draw.black, draw.lime, "Yeah, "..tName.." good choice boss. .;,;.")
        sleep(2)
        draw.clear()
        draw.centerText(1, x, (y / 2) - 1, draw.black, draw.lime, "So, what is my X co-ordinate?")
        sleep(1)
        draw.centerText(1, x, (y / 2), draw.black, draw.lightBlue, "You're at ")
        startX = tonumber(read())
        sleep(1)
        draw.clear()
        draw.centerText(1, x, (y / 2) - 1, draw.black, draw.lime, "So, what is my Y co-ordinate?")
        sleep(1)
        draw.centerText(1, x, (y / 2), draw.black, draw.lightBlue, "You're at ")
        startY = tonumber(read())
        sleep(1)
        draw.clear()
        draw.centerText(1, x, (y / 2) - 1, draw.black, draw.lime, "So, what is my Z co-ordinate?")
        sleep(1)
        draw.centerText(1, x, (y / 2), draw.black, draw.lightBlue, "You're at ")
        startZ = tonumber(read())
        sleep(1)
        while true do
            draw.clear()
            draw.centerText(1, x, (y / 2) - 1, draw.black, draw.lime, "So, what direction am I facing?")
            sleep(1)
            draw.centerText(1, x, (y / 2), draw.black, draw.lightBlue, "You're facing ")
            startH = read()
            if startH == "north" or startH == "North" or startH == "n" or startH == "N" then
                startH = N
                break
            elseif startH == "east" or startH == "East" or startH == "e" or startH == "E" then
                startH = E
                break
            elseif startH == "south" or startH == "South" or startH == "s" or startH == "S" then
                startH = S
                break
            elseif startH == "west" or startH == "West" or startH == "w" or startH == "W" then
                startH = W
                break
            end
            sleep(1)
        end
        draw.clear()
        draw.centerText(1, x, (y / 2) - 1, draw.black, draw.lime, "What's the Id of the server?")
        sleep(1)
        draw.centerText(1, x, (y / 2), draw.black, draw.lightBlue, "The server Id is ")
        startServer = tonumber(read())
        sleep(1)
        draw.clear()
        draw.centerText(1, x, (y / 2) - 1, draw.black, draw.lime, "And finally,")
        sleep(1)
        draw.centerText(1, x, (y / 2), draw.black, draw.lime, "what is my safe move height?")
        sleep(1)
        draw.centerText(1, x, (y / 2) + 1, draw.black, draw.lightBlue, "The safezone is ")
        startSafe = tonumber(read())
        sleep(1)
        draw.clear()
        myTab = {
            xPos = startX;
            yPos = startY;
            zPos = startZ;
            hPos = startH;
            name = tName;
            home = true;
                        homeX = startX;
            homeY = startY;
            homeZ = startZ;
            homeH = startH;
            state = "Initialised.";
            server = startServer;
            safezone = startSafe;
            curSlot = 1;
            lastSlot = 1;
            targetSlot = 2;
        }
    end
    saveMyData()
    loadLocData()
    loadOnboardData()
end

--TABLE FUNCTIONS

function addLoc(label, locX, locY, locZ, locH)
    loadLocData()
    if locTab[1] ~= nil then
        locMax = #locTab + 1
    else
        locMax = 1
    end
    if locMax > 1 then
        for i = 1, #locTab do
            if locTab[i][1] == label then
                report("Amending old data...")
                locTab[i][1] = label
                locTab[i][2] = locX
                locTab[i][3] = locY
                locTab[i][4] = locZ
                locTab[i][5] = locH
                report("Location "..label.." updated.")
                saveLocs()
                return
            end
        end
    end
    locTab[locMax] = {}
    locTab[locMax][1] = label
    locTab[locMax][2] = locX
    locTab[locMax][3] = locY
    locTab[locMax][4] = locZ
    locTab[locMax][5] = locH
    report("Location "..label.." added.")
    saveLocs()
end

function setReturnPoint(label)
    addLoc(label, myTab.xPos, myTab.yPos, myTab.zPos, myTab.hPos)
end

function resetHome()
    loadData()
    myTab.homeX = myTab.xPos
    myTab.homeY = myTab.yPos
    myTab.homeZ = myTab.zPos
    myTab.homeH = myTab.hPos
    saveMyData()
end

--REDNET FUNCTIONS

function report(text, refresh)
    if refresh ~= nil then
        draw.clear()
    end
    myTab.state = text
    saveMyData()
    print(text)
    transmit()
end

function listen()
    rednet.open("right")
    while true do
        id, msg = rednet.receive()
        if id == myTab.server then
            if msg == "recall" then
                goHome()
                os.reboot()
            elseif string.sub(msg, 1, 6) == "travel" then
                moveToLoc(string.sub(msg, 8, #msg))
                return
            end
        end
    end
end

function transmit()
    rednet.open("right")
    rednet.send(myTab.server, textutils.serialize(myTab))
end

--FILE FUNCTIONS

function saveMyData()
    data = fs.open("Tables/myTab", "w")
    data.writeLine(textutils.serialize(myTab))
    data.close()
end

function loadData()
    data = fs.open("Tables/myTab", "r")
    myTab = textutils.unserialize(data.readLine())
    data.close()
end

function saveOnboardData()
    datafile = fs.open("Tables/onboardTab", "w")
    datafile.writeLine(textutils.serialize(obTab))
    datafile.close()
end

function loadOnboardData()
    if fs.isDir("Tables") then
        if fs.exists("Tables/onboardTab") then
            data = fs.open("Tables/onboardTab", "r")
            obTab = textutils.unserialize(data.readLine())
            data.close()
            return true
        end
    else
        shell.run("mkDir Tables")
    end
    clearOnboardData()
end

function saveLocs()
    data = fs.open("Tables/locTab", "w")
    data.writeLine(textutils.serialize(locTab))
    data.close()
end

function loadLocData()
    if fs.isDir("Tables") then
        if fs.exists("Tables/locTab") then
            data = fs.open("Tables/locTab", "r")
            locTab = textutils.unserialize(data.readLine())
            data.close()
            return true
        end
    else
        shell.run("mkDir Tables")
    end
    locTab = {}
    saveLocs()
end

function loadChestData()
    if fs.exists("Tables/chests") then
        data = fs.open("Tables/chests", "r")
        chestTab = textutils.unserialize(data.readLine())
        data.close()
    else
        chestTab = {}
    end
end

--USEFUL FUNCTIONS

function clear()
    term.clear()
    term.setCursorPos(1, 1)
end

function clearOnboardData()
    obTab = nil
    obTab = {}
    for i = 1, 16 do
        obTab[i] = {}
        if i == FUEL then
            obTab[i][1] = "Fuel"
            obTab[i][2] = turtle.getItemCount(FUEL)
        else
            obTab[i][1] = "Nowt"
            obTab[i][2] = 0
        end
    end
    saveOnboardData()
end

function checkOnboardData()
    for i = 1, 16 do
        if obTab[i][1] ~= "Nowt" then
            obTab[i][2] = turtle.getItemCount(i)
        else
            if turtle.getItemCount(i) > 0 then
                obTab[i][1] = "Unknown"
                obTab[i][2] = turtle.getItemCount(i)
            end
        end
    end
    saveOnboardData()
end

function getFreeSlot()
    for i = 1, 16 do
        if turtle.getItemCount(i) == 0 then
            return(i)
        end
    end
    return false
end

function slotSelect(slot)
        turtle.select(slot)
        myTab.lastSlot = myTab.curSlot
        myTab.curSlot = slot
end

function emptySlot(slot)
    slotSelect(slot)
    turtle.drop()
end

function emptyAll()
    for i = 2, 16 do
        turtle.select(i)
        turtle.drop()
    end
    clearOnboardData()
end

function readChest()
    chest = peripheral.wrap("front")
    chest.condenseItems()
    invSize = chest.getInventorySize()
    chkTab = {}
    for i = 1, invSize do
        chkTab[i] = {}
        items = chest.getStackInSlot(i)
        if items ~= nil then
            for key, value in pairs(items) do
                if key == "name" then
                    chkTab[i][1] = value
                end
                if key == "qty" then
                    chkTab[i][2] = value
                end
            end
        else
            chkTab[i][1] = "Nowt"
            chkTab[i][2] = 0
        end
    end
end

function fillSlot(slot)
    while turtle.getItemCount(slot) < 64 do
        slotSelect(slot)
        turtle.suck()
    end
end

function fillFrom()
    readChest()
    obTab = {}
    for i = 2, 16 do
        turtle.select(i)
        for j = 1, 54 do
            if chkTab[j][1] ~= "Nowt." then
                turtle.suck()
                obTab[i] = {}
                obTab[i][1] = chkTab[j][1]
                obTab[i][2] = turtle.getItemCount(i)
                chkTab[j][1], chkTab[j][2] = "Nowt.", 0
                print(i..". "..obTab[i][1]..": "..obTab[i][2])
                break
            end
        end
        if turtle.getItemCount(i) == 0 then
            obTab[i] = {}
            obTab[i][1] = "Nowt."
            obTab[i][2] = 0
        end
    end
end

function getItem(item, slot, amt)
    if amt == nil then
        amt = 64
    end
    itemFound = false
    while turtle.getItemCount(slot) < amt do
        readChest()
        if itemFound then
            slotSelect(slot)
            turtle.suck()
            if turtle.getItemCount(slot) >= amt then
                break
            else
                itemFound = false
            end
        else
            while not itemFound do
                readChest()
                for i = 1, #chkTab do
                    if chkTab[i][1] == item then
                        chest.swapStacks(i, 1)
                        itemFound = true
                        break
                    end
                end
                if itemFound then
                    break
                else
                    sleep(.2)
                end
            end
        end
    end
    if turtle.getItemCount(slot) > amt then
        dropCount = turtle.getItemCount(slot) - amt
        slotSelect(slot)
        turtle.drop(dropCount)
    end
    obTab[slot][1] = item
    obTab[slot][2] = amt
    saveOnboardData()
end

function checkBuild(item)
        for i = 1, 16 do
                if obTab[i][1] == item then
                        turtle.select(i)
                        turtle.placeDown()
            return true
                end
        end
    return false
end

function checkFull()
    if turtle.getItemCount(16) > 0 then
        unloading = true
        addLoc("whereIWas", myTab.xPos, myTab.yPos, myTab.zPos, myTab.hPos)
        moveToLoc("digSiteEntry", "l")
        goHome()
        unload()
        moveToLoc("digSiteEntry")
        moveToLoc("whereIWas", "l")
    end
end

function unload()
    unloading = true
    rt()
    emptyAll()
    report("Need sort")
    spin()
    fillSlot(FUEL)
    emptyAll()
    rt()
    unloading = false
    refuel = false
end

--MOVEMENT FUNCTIONS

function checkFuel()
        slotSelect(FUEL)
        fuelLevel = turtle.getFuelLevel()
        if not refuel then
                if turtle.getItemCount(FUEL) > 16 then
                        while fuelLevel < FUELMIN do
                                turtle.refuel(1)
                                fuelLevel = turtle.getFuelLevel()
                        end
                else
                        refuel = true
            addLoc("whereIWas", myTab.xPos, myTab.yPos, myTab.zPos, myTab.hPos)
            if digging then
                moveToLoc("digSiteEntry", "l")
            end
                        goHome()
            unload()
            if digging then
                moveToLoc("digSiteEntry", "l")
                moveToLoc("whereIWas", "l")
            else
                moveToLoc("whereIWas")
            end
                end
        else
                if turtle.getItemCount(FUEL) > 0 and fuelLevel < FUELMIN then
                        turtle.refuel(1)
                else
                        report("Out of Fuel.")
                end
        end
        slotSelect(myTab.lastSlot)
end

function fd(dist, modi)
    loadData()
        checkFuel()
    if dist == nil then dist = 1 end
    if unloading == false and refuel == false then
        if digging then checkFull() end
    end
    for i = 1, dist do
        while true do
            if modi == "dig" or modi == "d" then
                turtle.dig()
            elseif modi == "tunnel" or modi == "t" then
                turtle.digUp()
                turtle.digDown()
                turtle.dig()
            end
            if turtle.forward() then
                if myTab.hPos == 0 then
                    myTab.zPos = myTab.zPos - 1
                    report("Moving N", "c")
                elseif myTab.hPos == 1 then
                    myTab.xPos = myTab.xPos + 1
                    report("Moving E", "c")
                elseif myTab.hPos == 2 then
                    myTab.zPos = myTab.zPos + 1
                    report("Moving S", "c")
                elseif myTab.hPos == 3 then
                    myTab.xPos = myTab.xPos - 1
                    report("Moving W", "c")
                end
                saveMyData()
                break
            else
                report("Blocked F", "c")
                if not digging then
                    unblock()
                end
            end
        end
    end
end

function bk(dist, modi)
    loadData()
        checkFuel()
    if dist == nil then dist = 1 end
    for i = 1, dist do
        while true do
            if modi == "build" or modi == "b" then
                checkBuild(myTab.targetSlot)
            end
            if turtle.back() then
                if myTab.hPos == 0 then
                    myTab.zPos = myTab.zPos + 1
                    report("Reversing S", "c")
                elseif myTab.hPos == 1 then
                    myTab.xPos = myTab.xPos - 1
                    report("Reversing W", "c")
                elseif myTab.hPos == 2 then
                    myTab.zPos = myTab.zPos - 1
                    report("Reversing N", "c")
                elseif myTab.hPos == 3 then
                    myTab.xPos = myTab.xPos + 1
                    report("Reversing E", "c")
                end
                saveMyData()
                break
            else
                report("Blocked B")
            end
        end
    end
end

function up(dist, modi)
    loadData()
        checkFuel()
    if dist == nil then dist = 1 end
    for i = 1, dist do
        while true do
            if modi == "dig" or modi == "d" then
                turtle.digUp()
            end
            if turtle.up() then
                myTab.yPos = myTab.yPos + 1
                report("Ascending")
                saveMyData()
                break
            else
                report("Blocked U")
            end
        end
    end
end

function dn(dist, modi)
    loadData()
        checkFuel()
    if dist == nil then dist = 1 end
    for i = 1, dist do
        while true do
            if modi == "dig" or modi == "d" then
                turtle.digDown()
            end
            if turtle.down() then
                myTab.yPos = myTab.yPos - 1
                report("Descending")
                saveMyData()
                break
            else
                report("Blocked D")
            end
        end
    end
end

function rt()
    loadData()
        turtle.turnRight()
        myTab.hPos = (myTab.hPos + 1)%4
    report(myTab.hPos)
    saveMyData()
end

function lt()
    loadData()
        turtle.turnLeft()
        myTab.hPos = (myTab.hPos - 1)%4
    report(myTab.hPos)
    saveMyData()
end

function spin()
        rt()
        rt()
end

--ADVANCED MOVEMENT FUNCTIONS

function unblock()
    report("Unblocking!")
    local upBool, dnBool = true, true
    local yLine = myTab.yPos
    while turtle.detect() do
        if turtle.detectUp() then
            upBool = false
            report("not up")
        end
        if turtle.detectDown() then
            dnBool = false
            report("not down")
        end
        local coinToss = math.random(0, 1)
        if coinToss == 0 then
            if upBool then
                up()
            else
                dn()
            end
        else
            if dnBool then
                dn()
            else
                up()
            end
        end
    end
end

function face(heading)
    heading = tonumber(heading)
        if heading < myTab.hPos then
        if myTab.hPos == 3 and heading == 0 then
            left = false
        else
            left = true
        end
    else
        if myTab.hPos == 0 and heading == 3 then
            left = true
        else
            left = false
        end
    end
    while heading ~= myTab.hPos do
        if left then
            lt()
        else
            rt()
        end
    end
    saveMyData()
end

function findX(target, modi)
    loadData()
        report("Finding "..target.." on X axis")
        if target > myTab.xPos then
                face(E)
        else
                face(W)
    end
        while myTab.xPos ~= target do
                if modi == nil then
                        fd()
                elseif modi == "dig" or modi == "d" then
                        fd(1, modi)
                end
        end
end

function findZ(target, modi)
    loadData()
        report("Finding "..target.." on Z axis")
        if target < myTab.zPos then
                face(N)
        else
                face(S)
    end
    while myTab.zPos ~= target do
        if modi == nil then
            fd()
        elseif modi == "dig" or modi == "d" then
            fd(1, modi)
        end
    end
end

function findY(target, modi)
    loadData()
        report("Finding "..target.." on Y axis")
        if target < myTab.yPos then
                while target < myTab.yPos do
                        if modi == nil then
                                dn()
                        elseif modi == "dig" or modi == "d" then
                                dn(1, modi)
                        end
                end
        else
                while target > myTab.yPos do
                        if modi == nil then
                                up()
                        elseif modi == "dig" or modi == "d" then
                                up(1, modi)
                        end
                end
        end
end

function travel(tgtX, tgtY, tgtZ, tgtH)
    report("Outbound")
    myTab.home = false
    saveMyData()
    loadData()
    findY(myTab.safezone, "d")
    findX(tgtX)
    findZ(tgtZ)
    findY(tgtY, "d")
    face(tgtH)
    report("Arrived")
end

function moveToLoc(label, modi)
    myTab.home = false
    saveMyData()
    loadLocData()
    for i = 1, #locTab do
        if locTab[i][1] == label then
            if modi ~= nil then
                if modi == "lateral" or modi == "l" then
                    findX(locTab[i][2], "d")
                    findZ(locTab[i][4], "d")
                    face(locTab[i][5])
                else
                    travel(locTab[i][2], locTab[i][3], locTab[i][4], locTab[i][5], modi)
                    break
                end
            else
                travel(locTab[i][2], locTab[i][3], locTab[i][4], locTab[i][5])
                break
            end
        end
    end
end

function goHome()
    report("Inbound")
    loadData()
    findY(myTab.safezone, "d")
    findZ(myTab.homeZ)
    findX(myTab.homeX)
    findY(myTab.homeY, "d")
    face(myTab.homeH)
    myTab.home = true
    saveMyData()
end

--MINING FUNCTIONS

function digGrid(length, width)
    turn = true
    length = length - 1
    for i = 1, width do
        if i ~= width then
            fd(length, "t")
            if turn then
                rt()
            else
                lt()
            end
            fd(1, "t")
            if turn then
                rt()
            else
                lt()
            end
            turn = not turn
        else
            fd(length, "t")
        end
    end
    turtle.digUp()
    turtle.digDown()
end

function quarry(length, width, fb)
    digging = true
    if fb ~= nil then
        depth = 2
    else
        depth = 6
    end
    findY(depth, "d")
    fd(1, "t")
    turtle.digUp()
    turtle.digDown()
    while not turtle.detectUp() do
        up()
    end
    dn()
    bk()
    while myTab.yPos < myTab.safezone do
        addLoc("digSiteEntry", myTab.xPos, myTab.yPos, myTab.zPos, myTab.hPos)
        digGrid(length, width)
        moveToLoc("digSiteEntry", "l")
        up(3)
    end
    digging = false
    goHome()
    unload()
end

--BUILDING FUNCTIONS

function loadBlueprint(label)
    data = fs.open("Blueprints/"..label, "r")
    bpTab = textutils.unserialize(data.readLine())
    data.close()
end

function itemPlace(item)
    for i = 2, 16 do
        if obTab[i][1] == item then
            if obTab[i][2] > 0 then
                slotSelect(i)
                report("Placing "..item)
                if turtle.placeDown() then
                    obTab[i][2] = obTab[i][2] - 1
                end
                break
            end
        end
    end
end

function countItems(level)
    typeCount = {}
    skipLayer = false
    report("Checking Blueprint.")
    for i = 1, #bpTab[level] do
        for j = 1, #bpTab[level][i] do
            found = false
            if bpTab[level][i][j][1] ~= "air" then
                if typeCount[1] ~= nil then
                    for k = 1, #typeCount do
                        if typeCount[k][1] == bpTab[level][i][j][1] then
                            typeCount[k][2] = typeCount[k][2] + 1
                            found = true
                            break
                        end
                    end
                    if not found then
                        report("New type found.")
                        newMax = #typeCount + 1
                        typeCount[newMax] = {}
                        typeCount[newMax][1] = bpTab[level][i][j][1]
                        typeCount[newMax][2] = 1
                        --report(typeCount[newMax][1].." "..typeCount[newMax][2])
                    end
                else
                    report("First type found.")
                    typeCount[1] = {}
                    typeCount[1][1] = bpTab[level][i][j][1]
                    typeCount[1][2] = 1
                    --report(typeCount[1][1].." "..typeCount[1][2])
                end
            end
        end
    end
    if typeCount[1] == nil then
        skipLayer = true
    end
end

function readBlueprint(label, level)
    if fs.exists("Blueprints/"..label) then
        data = fs.open("Blueprints/"..label, "r")
        bpTab = textutils.unserialize(data.readLine())
        data.close()
    else
        report("No matching blueprint.")
        return false
    end
    countItems(level)
    for i = 1, #typeCount do
        print(i..". "..typeCount[i][1].." required: "..typeCount[i][2])
    end
    for i = 1, #typeCount do
        freeSlot = getFreeSlot()
        if typeCount[i][2] > 64 then
            local itemCount = typeCount[i][2]
            while itemCount > 0 do
                getItem(typeCount[i][1], freeSlot, 64)
                itemCount = itemCount - 64
                freeSlot = getFreeSlot()
            end
        else
            getItem(typeCount[i][1], freeSlot, typeCount[i][2])
        end
    end
end

function buildLayer(label, level)
    goHome()
    unload()
    rt()
    readBlueprint(label, level)
    if skipLayer then
        return
    end
    moveToLoc("buildSite")
    dn(#bpTab - level)
    turns = true
    for i = 1, #bpTab[level] do
        if turns then
            for j = 1, #bpTab[level][i] do
                if bpTab[level][i][j][1] ~= "air" then
                    if bpTab[level][i][j][5] ~= nil then
                        oldFacing = myTab.hPos
                        face(bpTab[level][i][j][5])
                        itemPlace(bpTab[level][i][j][1])
                        face(oldFacing)
                    else
                        itemPlace(bpTab[level][i][j][1])
                    end
                end
                if j ~= #bpTab[level][i] then
                    fd()
                end
            end
            if j ~= #bpTab[level][i] then
                rt()
                fd()
                rt()
            end
        else
            for j = #bpTab[level][i], 1, -1 do
                if bpTab[level][i][j][1] ~= "air" then
                    if bpTab[level][i][j][5] ~= nil then
                        oldFacing = myTab.hPos
                        face(bpTab[level][i][j][5])
                        itemPlace(bpTab[level][i][j][1])
                        face(oldFacing)
                    else
                        itemPlace(bpTab[level][i][j][1])
                    end
                end
                if j ~= 1 then
                    fd()
                end
            end
            if j ~= 1 then
                lt()
                fd()
                lt()
            end
        end
        turns = not turns
    end
end

function buildBP(location, bpName)
    moveToLoc(location)
    loadBlueprint(bpName)
    up(#bpTab)
    addLoc("buildSite", myTab.xPos, myTab.yPos, myTab.zPos, myTab.hPos)
    for i = 1, #bpTab do
        buildLayer(bpName, i)
    end
    goHome()
    unload()
    os.reboot()
end

--SORTING FUNCTIONS

function smartFill()
    report("Checking chest.")
    for i = 2, 16 do
        readChest()
        for j = 1, #chkTab do
            if chkTab[j][1] ~= "Nowt" then
                turtle.select(i)
                turtle.suck()
                obTab[i][1] = chkTab[j][1]
                obTab[i][2] = chkTab[j][2]
                chkTab[j][1] = "Nowt"
                chkTab[j][2] = 0
                report("Found "..obTab[i][2].." "..obTab[i][1])
                break
            end
        end
    end
    saveOnboardData()
end

function sortChest()
    report("Sort initialised.")
    smartFill()
    for i = 2, 16 do
        report("Sorting slot "..i..".")
        found = false
        report("Checking chest list")
        myTab.opt1 = obTab[i][1]
        print(myTab.opt1)
        saveMyData()
        report("Chest lookup")
        listen()
        turtle.select(i)
        if turtle.drop() then
            if turtle.getItemCount(i) > 0 then
                myTab["opt1"] = obTab[i][1]
                myTab["opt2"] = obTab[i][2] - turtle.getItemCount(i)
                obTab[i][2] = turtle.getItemCount(i)
                saveMyData()
                saveOnboardData()
                report("Item add")
            else
                myTab["opt1"] = obTab[i][1]
                myTab["opt2"] = obTab[i][2]
                saveMyData()
                obTab[i][1] = "Nowt"
                obTab[i][2] = 0
                saveOnboardData()
                report("Item add")
            end
        end
    end
    goHome()
    rt()
    emptyAll()
    lt()
end

--PROGRAM INIT

init()