CC: Treefarm - item.lua

inventory = {}
types = {
    unknown = "unknown",
    dirt = "dirt",
    grass = "dirt",
    sapling = "sapling",
    log = "wood",
    wood = "wood",
    dropoff = "dropoff", --not actual item type, but can be refered to
}
-- position for each type
-- while standing at target location facing desired direction
-- turtle should be able to do a turtle.suck() to grab the material
-- if dir=up suckUp() if dir=down suckDown()
position = {}

-- if you have a small tunnel towards your storage for the turtle
-- addStoragePathCheckpoint(x,y,z) to add enterance
-- ^ can be used multiple times if you have a complicated path
-- turtle will follow the path in revese when it exits
storageEnterancePath = {}

local differenceRecord = {}

function update()
    for slot = 1,16 do
        local oldType = nil
        if type(inventory[slot])=="table" then oldType=inventory[slot].type end
        inventory[slot] = {
            type = oldType or types.unknown,
            qty = turtle.getItemCount(slot),
        }
        if inventory[slot].qty==0 then
            inventory[slot].type = nil
        end
    end
end

-- gets all global variables
function init( global )
    update()
    setfenv(1,global)
end

function recordDifference()
    differenceRecord = {}
    for slot=1,16 do
        differenceRecord[slot] = {
            type = inventory[slot].type,
            qty = inventory[slot].qty,
        }
    end
end

function getDifference()
    local difference = {}
    update()
    for slot=1,16 do
        local qtyDifference = inventory[slot].qty - differenceRecord[slot].qty
        if qtyDifference~=0 or inventory[slot].type~=differenceRecord[slot].type then
            difference[slot] = {}
            difference[slot].qty = qtyDifference
            difference[slot].type = differenceRecord[slot].type

            if inventory[slot].type~=differenceRecord[slot].type then
                difference[slot].oldType = differenceRecord[slot].type
            end
        end
    end
    return difference
end

function setItemAccess( item,x,y,z,dir )
    position[item] = {x=x,y=y,z=z,dir=dir}
end

function getItemAccess( item )
    return position[item].x,position[item].y,position[item].z,position[item].dir
end

function addStoragePathCheckpoint( x,y,z )
    storageEnterancePath[#storageEnterancePath+1] = {x=x,y=y,z=z}
end

function getStoragePathCheckpoint( step )
    if type(storageEnterancePath[step])=="table" then
        return (storageEnterancePath[step].x or _),(storageEnterancePath[step].y or _),(storageEnterancePath[step].z or _)
    end
end

function resetStoragePath()
    storageEnterancePath = {}
end

-- reverse = boolean
function followStoragePath( reverse )
    if type(reverse)~="boolean" then reverse = false end

    local start = 1
    local stop = #storageEnterancePath
    if reverse then start=stop stop=1 end

    for step = start,stop,mult(stop-start) do
        gps.goto(getStoragePathCheckpoint(step))
    end
end

function getItemCount( item )
    update()
    local count = 0
    for slot = 1,16 do
        if inventory[slot].type == item then
            count = count + inventory[slot].qty
        end
    end
    return count
end

-- gotoStorageRoom = (boolean) wether or not it should follow the storage path
function dropoff( gotoStorageRoom )
    if type(gotoStorageRoom)~="boolean" then gotoStorageRoom = false end

    -- dropoff must have a location
    local x,y,z,dir = getItemAccess(types.dropoff)
    if type(x)~="number" or type(y)~="number"
    or type(z)~="number" or type(dir)~="string" then
        return false
    end

    if gotoStorageRoom then
        followStoragePath()
    end

    gps.goto(x,y,z,dir)

    for slot=1,16 do
        local count = turtle.getItemCount(slot)
        while count~=0 do
            turtle.select(slot)
            if dir==gps.up then
                turtle.dropUp(count)
            elseif dir==gps.down then
                turtle.dropDown(count)
            else
                turtle.drop(count)
            end
            count = turtle.getItemCount(slot)
        end
    end

    -- exit the storage room
    if gotoStorageRoom then
        followStoragePath(true)
    end
end

-- tries to get item from storage canceles if it has enough
-- returns true on success and false when it fails for some reason
-- noEnterancePath=true if you dont want it to go through the storage enterance path
function getItem( item,minQty,noEnterancePath )
    if type(minQty)~="number" then minQty=64 end
    if type(noEnterancePath)~="boolean" then noEnterancePath=false end

    -- count quantity already in inventory
    local qtyRequired = minQty - getItemCount(item)
    if qtyRequired < 1 then
        -- already got enough of target item
        return true
    end

    -- item must be obtainable
    local x,y,z,dir = getItemAccess(item)
    if type(x)~="number" or type(y)~="number"
    or type(z)~="number" or type(dir)~="string" then
        return false
    end

    if not noEnterancePath then
        followStoragePath()
    end

    -- check if inv is full
    update()
    local invFull = true
    for slot=1,16 do
        if inventory[slot].qty == 0 then
            invFull = false
            break
        end
    end

    if invFull then
        dropoff(false)
    end

    gps.goto(x,y,z,dir)

    local qtyInInv-- number
    repeat
        recordDifference()

        if dir == gps.up then
            turtle.suckUp()
        elseif dir == gps.down then
            turtle.suckDown()
        else
            turtle.suck()
        end

        -- check how many slots changed when you sucked for items
        local diff = getDifference()
        local slotsChanged = 0
        for slot,item in pairs(diff) do
            slotsChanged = slotsChanged + 1
        end

        if slotsChanged == 0 then
            -- didn't obtain anything when trying to get items
            -- gonna have to loop through again and again
            --break
        elseif slotsChanged > 1 then
            -- more than one slot changed, might be 'cause of player interaction
            -- go empty out and try again just so we know for sure we can keep track of the item
            dropoff(false)
            gps.goto(x,y,z,dir)
        elseif slotsChanged == 1 then
            -- one slot changed, record it, gotta keep track of it
            for slot in pairs(diff) do
                inventory[slot].type = item
            end
        end

        qtyInInv = getItemCount(item)
    until qtyInInv >= qtyRequired

    if not noEnterancePath then
        followStoragePath(true)
    end

    return true
end

-- example input
-- t = { "dirt", "sapling" } minQty = 64: gets 64 dirt and 64 saplings
function getItems( t,minQty )
    for num,item in ipairs(t) do
        if num == 1 then
            followStoragePath(false)
        end
        getItem(item,minQty,true)
        if num == #t then
            followStoragePath(true)
        end
    end
end

function select( item )
    for slot=1,16 do
        if inventory[slot].type == item then
            turtle.select(slot)
            return true
        end
    end
    return false
end