FarmTree-1

--Logger V1.0 program made by Anonomit
-- Original en http://www.computercraft.info/forums2/index.php?/topic/6221-logger-program/page__p__51832#entry51832


local bNoBroadcast = true --set to true to suppress option to use broadcast console
local bUseFuel = true --whether turtles consume fuel
local bDebugDefault = false

local tArgs = { ... }
local bDebug = tArgs[1] == "debug" and true or ( tArgs[1] == "noDebug" and false or bDebugDefault )
local nLoggerSettingsLines = 9
local foo
local bar
local baz
local nTreesremaining
local sHarvestMode
local bUseBroadcast
local nRows
local nTrees
local bEmptyLogs
local bRefillSaplings
local bOutput
local tSides = {}
local bLowSaplings
local bNoSaplings
local bKeyLog
tPeripheralType = {}

local xTerm, yTerm = term.getSize()

term.clear()


local function getPeripherals()
    for _, side in pairs( rs.getSides() ) do
        if peripheral.isPresent( side ) then
            tPeripheralType[side] = peripheral.getType( side )
        end --if peripheral.isPresent( side )
    end --for _, side in pairs( rs.getSides() )
end --local function getPeripherals()

getPeripherals()

local function round( _number, _dp)
    local nMultiple = 10^( _dp or 0 )
    return math.floor( _number * nMultiple + 0.5 ) / nMultiple
end --local function round( _number, _dp )



function clearAll( _xPos, _yPos, _text, ... )
    local xDefault = 1
    local yDefault = 3

    foo = false

    if not arg[1] then
        term.clear()
    else --arg[1]
        for i = 1, yTerm do
            for _, value in ipairs( arg ) do
                if i == value then
                    foo = true
                end --if i == value
            end --for _, value in ipairs( arg )
            if not foo then
                term.setCursorPos( 1, i )
                term.clearLine()
            end --if not foo
            foo = false
        end --for i = 1, yTerm
    end --if not arg[1]

    foo = nil

    term.setCursorPos( 1, 1 )
    if _text then
        write( _text )
    else --_text
        write( "Anonomit Tree Farmer #" .. os.computerID() )
    end --if _text
    term.setCursorPos( 1, 2 )
    for i = 1, xTerm - 1 do
        write( "~" )
    end --for i = 1, xTerm - 1

    if type( tonumber( _xPos ) ) == "number" and type( tonumber( _yPos ) ) == "number" then
        if _xPos <= xTerm and _xPos > 0 and _yPos <= yTerm and _yPos > 0 then
            term.setCursorPos( _xPos, _yPos )
        else --_xPos <= xTerm and _xPos > 0 and _yPos <= yTerm and _yPos > 0
            term.setCursorPos( xDefault, yDefault )
        end --if _xPos <= xTerm and _xPos > 0 and _yPos <= yTerm and _yPos > 0
    else --type( tonumber( _xPos ) ) == "number" and type( tonumber( _yPos ) ) == "number"
        term.setCursorPos( xDefault, yDefault )
    end --if _xPos == nil or _yPos == nil

end --function clearAll( _xPos, _yPos, _text )



local function header( _text )
    local xCursorPos, yCursorPos = term.getCursorPos()
    term.setCursorPos( 1, 1 )
    term.clearLine()
    if _text then
        print( _text )
    else --_text
        print( "Anonomit Tree Farmer #" .. os.computerID() )
    end --if _text
    term.clearLine()
    for i = 1, xTerm - 1 do
        write( "~" )
    end --for i = 1, xTerm - 1
    term.setCursorPos( xCursorPos, yCursorPos )
end --local function header( _text )



local function rednetSend( _message )

    if bUseBroadcast then
        rednet.send( nBroadcastID, _message )
    end --if bUseBroadcast

end --local function rednetSend( _message )



local function keyLog()

    bKeyLog = false

    while true do

        event, key = os.pullEvent( "char" )
        if key ~= 1 then
            print( "Stopping..." )
            bKeyLog = true
            break --while true
        end --if key ~= 1

    end --while true

    while true do

        sleep( 0.01 )

    end --while true

end --local function keyLog()



local function select( _selectSlot )

    if tonumber( _selectSlot ) == nil then
        for i = 3, 15 do
            if turtle.getItemSpace( i ) > 0 then
                select( i )
                return i
            end --if turtle.getItemSpace( i ) > 0
        end --for i = 3, 15
    else --tonumber( _selectSlot ) == nil
        turtle.select( tonumber( _selectSlot ) )
        return _selectSlot
    end --if tonumber( _selectSlot ) == nil

    return 3

end --local function select( _selectSlot )



local function dig( _digDirection )

    if _digDirection == nil then
        _digDirection = "forward"
    elseif _digDirection == "right" or _digDirection == "r" then
        move( "right" )
        _digDirection = "forward"
    elseif _digDirection == "left" or _digDirection == "l" then
        move( "left" )
        _digDirection = "forward"
    elseif _digDirection == "back" or _digDirection == "b" then
        move( "right" )
        move( "right" )
        _digDirection = "forward"
    end

    if _digDirection == "forward" or _digDirection == "f" and turtle.detect() then
        turtle.dig()
    elseif _digDirection == "up" or _digDirection == "u" and turtle.detectUp() then
        turtle.digUp()
    elseif _digDirection == "down" or _digDirection == "d" and turtle.detectDown() then
        turtle.digDown()
    end --if _digDirection == "forward" or _digDirection == "f" and turtle.detect()

end --local function dig( _digDirection )



local function move( _moveDirection, _moveDistance, _moveSlot )

    local hasSpun = false

    if type( tonumber( _moveDirection ) ) == "number" and _moveDistance == nil then
        _moveDirection = "forward"
        _moveDistance = _moveDirection
    elseif type( tonumber( _moveDirection ) ) == "number" and type( tonumber( _moveDistance ) ) == "nil" then
        _moveDirection = _moveDistance
        _moveDistance = _moveDirection
    end --if type( tonumber( _moveDirection ) ) == "number" and _moveDistance == nil

    local function selection()
        if tonumber( _moveSlot ) then
            if tonumber( _moveSlot ) > 2 then
                select()
            else --tonumber( _moveSlot ) > 2
                select( _moveSlot )
            end --if tonumber( _moveSlot ) > 2
        else --tonumber( _moveSlot )
            _moveSlot = select()
        end --if tonumber( _moveSlot )
    end --local function selection()

    local function checkFuel()
        if bUseFuel then
            if turtle.getFuelLevel() == 0 then
                if turtle.getItemSpace( 16 ) ~= 64 then
                    select( 16 )
                else --turtle.getItemSpace( 16 ) ~= 64
                    for i = 3, 15 do
                        if turtle.getItemSpace( i ) ~= 64 then
                            turtle.select( i )
                            break --for i = 3, 15
                        end --if turtle.getItemSpace( i ) ~= 64
                    end --for i = 3, 15
                end --if turtle.getItemSpace( 16 ) ~= 64
                turtle.refuel( 1 )
            end --if turtle.getFuelLevel() == 0
            selection()
        end --if bUseFuel
    end --local function checkFuel()

    if _moveDirection == "right" or _moveDirection == "r" then
        turtle.turnRight()
        _moveDirection = "forward"
    elseif _moveDirection == "left" or _moveDirection == "l" then
        turtle.turnLeft()
        _moveDirection = "forward"
    end --if _moveDirection == "right" or _moveDirection == "r"

    local function movement()

        if _moveDirection == "forward" or _moveDirection == "f" then
            if turtle.forward() then
                return true
            else --turtle.forward()
                return false
            end --if turtle.forward()
        elseif _moveDirection == "up" or _moveDirection == "u" then
            if turtle.up() then
                return true
            else --turtle.up()
                return false
            end --if turtle.up()
        elseif _moveDirection == "down" or _moveDirection == "d" then
            if turtle.down() then
                return true
            else --turtle.down()
                return false
            end --if turtle.down()
        elseif _moveDirection == "back" or _moveDirection == "b" then
            if hasSpun then
                if turtle.forward() then
                    return true
                else --turtle.forward()
                    return false
                end --if turtle.forward()
            else --hasSpun
                if turtle.back() then
                    return true
                else --turtle.back()
                    return false
                end --if turtle.back()
            end --if hasSpun
        end --if _moveDirection == "forward" or _moveDirection == "f"

    end --local function movement()

    local function digger()

        if _moveDirection == "forward" or _moveDirection == "f" then
            dig( "forward" )
        elseif _moveDirection == "up" or _moveDirection == "u" then
            dig( "up" )
        elseif _moveDirection == "down" or _moveDirection == "d" then
            dig( "down" )
        elseif _moveDirection == "back" or _moveDirection == "b" then
            if hasSpun then
                dig( "forward" )
            else --hasSpun then
                turtle.turnRight()
                turtle.turnRight()
                dig( "forward" )
            end --if hasSpun
        end --if _moveDirection == "forward" or _moveDirection == "f"

    end --local function digger()

    local slotCount = {}
    local function vacuum()
        for i = 1, 16 do
            slotCount[i] = turtle.getItemSpace( i )
        end --for i = 3, 16
        turtle.suckDown()
        for i = 3, 15 do
            if turtle.getItemSpace( i ) < slotCount[i] and slotCount[i] == 64 then
                turtle.select( i )
                turtle.dropUp()
            end --if turtle.getItemSpace[i] < slotCount[i]
        end --for i = 3, 15

        selection()

    end --local function vacuum()

    if _moveDistance ~= nil and _moveDistance ~= 0 then
        for i = 1, _moveDistance do
            if not turtle.detectDown() then
                --vacuum()
            end --if not turtle.detectDown()
            selection()
            while not movement() do
                checkFuel()
                digger()
            end --while not movement()
        end --for i = 1, _moveDistance
        if hasSpun then
            turtle.turnRight()
            turtle.turnRight()
        end --if hasSpun
    end --if _moveDistance ~= nil and _moveDistance ~= 0

end --local function move( _moveDirection, _moveDistance, _moveSlot )



local function loadSettings()

    sHarvestMode, nRows, nTrees, bEmptyLogs, bRefillSaplings = nil, nil, nil, nil, nil
    bOutput = false
    tSides = {}

    if fs.exists( "loggerSettings" ) then

        local tLine = {}
        local file = fs.open( "loggerSettings", "r" )

        for i = 1, nLoggerSettingsLines do
            tLine[ #tLine + 1 ] = file.readLine()
        end --for i = 1, nLoggerSettingsLines

        file.close()

        sHarvestMode = tLine[1]
        bUseBroadcast = tLine[2] == "true" and true or ( tLine[2] == "false" and false or false )
        if bUseBroadcast then

            nBroadcastID = tonumber( tLine[3] ) ~= nil and tonumber( nBroadcastID ) or nil

        end --if bUseBroadcast

        if sHarvestMode == "farm" then

            nRows = tonumber( tLine[4] ) ~= nil and tonumber( tLine[4] ) or nil
            nTrees = tonumber( tLine[5] ) ~= nil and tonumber( tLine[5] ) or nil
            bEmptyLogs = tLine[6] == "true" and true or ( tLine[6] == "false" and false or false )
            bRefillSaplings = tLine[7] == "true" and true or ( tLine[7] == "false" and false or false )
            if bEmptyLogs or bRefillSaplings then
                bOutput = tLine[8] == "true" and true or ( tLine[8] == "false" and false or false )
                if bOutput then
                    tSides = textutils.unserialize( tLine[9] ) or {}
                end --if bOutput
            end --if bEmptyLogs or bRefillSaplings

        end --if sHarvestMode == "farm"



        if sHarvestMode == "farm" and ( bUseBroadcast == true or bUseBroadcast == false ) and nRows and nTrees and ( bEmptyLogs == true or bEmptyLogs == false ) and ( bRefillSaplings == true or bRefillSaplings == false ) then
            return true
        elseif sHarvestMode == "bonemeal" then
            return true
        else --sHarvestMode == "farm" and ( bUseBroadcast == true or bUseBroadcast == false ) and nRows and nTrees and ( bEmptyLogs == true or bEmptyLogs == false ) and ( bRefillSaplings == true or bRefillSaplings == false )
            return false
        end --sHarvestMode == "farm" and ( bUseBroadcast == true or bUseBroadcast == false ) and nRows and nTrees and ( bEmptyLogs == true or bEmptyLogs == false ) and ( bRefillSaplings == true or bRefillSaplings == false )

    elseif not fs.exists( "loggerSettings" ) then
        return false
    end --if fs.exists( "loggerSettings" )

end --local function loadSettings()



local function writeToFile()

    if fs.exists( "loggerSettings" ) then
        fs.delete( "loggerSettings" )
    end --if fs.exists( "loggerSettings" )
    local file = fs.open( "loggerSettings", "w" )
    file.writeLine( sHarvestMode )
    file.writeLine( bUseBroadcast ~= nil and tostring( bUseBroadcast ) or "nil" )
    file.writeLine( tostring( nBroadcastId ) ~= nil and tostring( nBroadcastID ) or "nil" )
    if sHarvestMode == "farm" then
        file.writeLine( nRows ~= nil and nRows or "nil" )
        file.writeLine( nTrees ~= nil and nTrees or "nil" )
        file.writeLine( tostring( bEmptyLogs ) ~= nil and tostring( bEmptyLogs ) or "false" )
        file.writeLine( tostring( bRefillSaplings ) ~= nil and tostring( bRefillSaplings ) or "false" )
        if bEmptyLogs or bRefillSaplings then
            file.writeLine( tostring( bOutput ) ~= nil and tostring( bOutput ) or "false" )
            if bOutput then
                file.writeLine( textutils.serialize( tSides ) ~= nil and textutils.serialize( tSides ) or "nil" )
            end --if bOutput
        end --if bEmptyLogs or bRefillSaplings
    end --if sHarvestMode == "farm"
    file.close()

end --local function writeToFile()



local function createSettings()

    sHarvestMode = nil
    bUseBroadcast = nil
    nBroadcastID = nil
    nRows = nil
    nTrees = nil
    bEmptyLogs = nil
    bRefillSaplings = nil
    bOutput = nil
    tSides = {}

    clearAll( 1, 3, "Settings:" )

    local xCursorPos, yCursorPos = term.getCursorPos()
    while sHarvestMode == nil do
        header( "Settings:" )
        term.setCursorPos( xCursorPos, yCursorPos )
        term.clearLine()
        write( "Harvest mode (farm/bonemeal): " )
        sHarvestMode = string.lower( read() )
        if sHarvestMode ~= "farm" and sHarvestMode ~= "bonemeal" then
            term.clearLine()
            write( "Invalid Value" )
            sleep( 0.5 )
            term.clearLine()
            sHarvestMode = nil
        end --if sHarvestMode ~= "farm" and sHarvestMode ~= "bonemeal"
    end --while sHarvestMode == nil

    if not bNoBroadcast and tPeripheralType[right] ~= "modem" then

        local xCursorPos, yCursorPos = term.getCursorPos()
        while bUseBroadcast == nil do
            header( "Settings:" )
            term.setCursorPos( xCursorPos, yCursorPos )
            term.clearLine()
            write( "Use Broadcast Console: " )
            bUseBroadcast = read()
            if bUseBroadcast == "true" or bUseBroadcast == "yes" or bUseBroadcast == "1" then
                bUseBroadcast = true
            elseif bUseBroadcast == "false" or bUseBroadcast == "no" or bUseBroadcast == "0" then
                bUseBroadcast = false
            else --if bUseBroadcast == "true" or bUseBroadcast == "yes" or bUseBroadcast == "1"
                term.clearLine()
                write( "Invalid Value" )
                sleep( 0.5 )
                term.clearLine()
                bUseBroadcast = nil
            end --if bUseBroadcast == "true" or bUseBroadcast == "yes" or bUseBroadcast == "1"
        end --while bUseBroadcast == nil


        if bUseBroadcast then

            for _, side in pairs( rs.getSides() ) do
                rednet.open( side )
            end --for _, side in pairs( rs.getSides() )

            local xCursorPos, yCursorPos = term.getCursorPos()
            while nBroadcastID == nil do
                header( "Settings:" )
                rednet.broadcast( "broadcastPing" )
                local param1, param2, param3 = rednet.receive( 0.1 )
                if param2 == "broadcastPong" then
                    term.setCursorPos( xCursorPos, yCursorPos + 1 )
                    term.clearLine()
                    write( ">Broadcast Console #" .. param1 .. " is " .. round( param3, 0 ) .. " Away" )
                else --param2 == "loggerPong"
                    write( ">No Broadcast Consoles Found Nearby" )
                end --if param2 == "loggerPong"
                term.setCursorPos( xCursorPos, yCursorPos )
                term.clearLine()
                write( "Broadcast Console ID: " )
                nBroadcastID = tonumber( read() )
                if nBroadcastID == nil then
                    term.clearLine()
                    write( "Invalid Value" )
                    sleep( 0.5 )
                    term.clearLine()
                elseif nBroadcastID < 0 then
                    term.clearLine()
                    write( "Invalid Value" )
                    sleep( 0.5 )
                    term.clearLine()
                    nBroadcastID = nil
                else --nBroadcastID == nil
                    rednetSend( "loggerPing" )
                    local id, msg, dist = rednet.receive( 0.1 )
                    if msg == "loggerPong" then
                        break --while nBroadcastID == nil
                    else --msg == "loggerPong"
                    term.clearLine()
                    write( "No Response" )
                    sleep( 1 )
                    term.clearLine()
                    nBroadcastID = nil
                    end --if msg == "broadcastPong"
                end --if nBroadcastID == nil
            end --while nBroadcastID == nil

        end --if bUseBroadcast

    else --not bNoBroadcast and tPeripheralType[right] ~= "modem"

        bUseBroadcast = false

    end --if not bNoBroadcast and tPeripheralType[right] ~= "modem"

    if sHarvestMode == "farm" then
        local xCursorPos, yCursorPos = term.getCursorPos()
        while nRows == nil do
            header( "Settings:" )
            term.setCursorPos( xCursorPos, yCursorPos )
            term.clearLine()
            write( "Number of rows: " )
            nRows = tonumber( read() )
            if nRows == nil then
                term.clearLine()
                write( "Invalid Value" )
                sleep( 0.5 )
                term.clearLine()
            elseif nRows < 1 then
                term.clearLine()
                write( "Invalid Value" )
                sleep( 0.5 )
                term.clearLine()
                nRows = nil
            end --if nRows == nil
        end --while nRows == nil

        local xCursorPos, yCursorPos = term.getCursorPos()
        while nTrees == nil do
            header( "Settings:" )
            term.setCursorPos( xCursorPos, yCursorPos )
            term.clearLine()
            write( "Trees per row: " )
            nTrees = tonumber( read() )
            if nTrees == nil then
                term.clearLine()
                write( "Invalid Value" )
                sleep( 0.5 )
                term.clearLine()
            elseif nTrees < 1 then
                term.clearLine()
                write( "Invalid Value" )
                sleep( 0.5 )
                term.clearLine()
                nTrees = nil
            end --if nTrees == nil
        end --while nTrees == nil

        local xCursorPos, yCursorPos = term.getCursorPos()
        while bEmptyLogs == nil do
            header( "Settings:" )
            term.setCursorPos( xCursorPos, yCursorPos )
            term.clearLine()
            write( "Wait for emptied logs: " )
            bEmptyLogs = read()
            if bEmptyLogs == "true" or bEmptyLogs == "yes" or bEmptyLogs == "1" then
                bEmptyLogs = true
            elseif bEmptyLogs == "false" or bEmptyLogs == "no" or bEmptyLogs == "0" then
                bEmptyLogs = false
            else --if bEmptyLogs == "true" or bEmptyLogs == "yes" or bEmptyLogs == "1"
                term.clearLine()
                write( "Invalid Value" )
                sleep( 0.5 )
                term.clearLine()
                bEmptyLogs = nil
            end --if bEmptyLogs == "true" or bEmptyLogs == "yes" or bEmptyLogs == "1"
        end --while bEmptyLogs == nil

        local xCursorPos, yCursorPos = term.getCursorPos()
        while bRefillSaplings == nil do
            header( "Settings:" )
            term.setCursorPos( xCursorPos, yCursorPos )
            term.clearLine()
            write( "Wait for full saplings: " )
            bRefillSaplings = read()
            if bRefillSaplings == "true" or bRefillSaplings == "yes" or bRefillSaplings == "1" then
                bRefillSaplings = true
            elseif bRefillSaplings == "false" or bRefillSaplings == "no" or bRefillSaplings == "0" then
                bRefillSaplings = false
            else --if bRefillSaplings == "true" or bRefillSaplings == "yes" or bRefillSaplings == "1"
                term.clearLine()
                write( "Invalid Value" )
                sleep( 0.5 )
                term.clearLine()
                bRefillSaplings = nil
            end --if bRefillSaplings == "true" or bRefillSaplings == "yes" or bRefillSaplings == "1"
        end --while bRefillSaplings == nil

        if bEmptyLogs or bRefillSaplings then
            local xCursorPos, yCursorPos = term.getCursorPos()
            while bOutput == nil do
                header( "Settings:" )
                term.setCursorPos( xCursorPos, yCursorPos )
                term.clearLine()
                write( "Output redstone after cycle: " )
                bOutput = read()
                if bOutput == "true" or bOutput == "yes" or bOutput == "1" then
                    bOutput = true
                elseif bOutput == "false" or bOutput == "no" or bOutput == "0" then
                    bOutput = false
                else --if bOutput == "true" or bOutput == "yes" or bOutput == "1"
                    term.clearLine()
                    write( "Invalid Value" )
                    sleep( 0.5 )
                    term.clearLine()
                    bOutput = nil
                end --if bOutput == "true" or bOutput == "yes" or bOutput == "1"
            end --while bOutput == nil
        end --if bEmptyLogs or bRebillSaplings

        if bOutput then
            for _, side in ipairs( rs.getSides() ) do
                if tPeripheralType[side] ~= "modem" and tPeripheralType[side] ~= "workbench" then
                    local xCursorPos, yCursorPos = term.getCursorPos()
                    term.setCursorPos( xCursorPos, yCursorPos )
                    term.clearLine()
                    while tSides[side] == nil do
                        header( "Settings:" )
                        term.setCursorPos( xCursorPos, yCursorPos )
                        term.clearLine()
                        write( "Output on " .. side .. " side: " )
                        tSides[side] = read()
                        if tSides[side] == "true" or tSides[side] == "yes" or tSides[side] == "1" then
                            tSides[side] = true
                        elseif tSides[side] == "false" or tSides[side] == "no" or tSides[side] == "0" then
                            tSides[side] = false
                        else --if tSides[side] == "true" or tSides[side] == "yes" or tSides[side] == "1"
                            term.clearLine()
                            write( "Invalid Value" )
                            sleep( 0.5 )
                            term.clearLine()
                            tSides[side] = nil
                        end --if tSides[side] == "true" or tSides[side] == "yes" or tSides[side] == "1"
                    end --while tSides[side] == nil
                end --if tPeripheralType[side] ~= "modem" and tPeripheralType[side] ~= "workbench"
            end --for i, side in ipairs( rs.getSides() )
        end --if bOutput


    end --if sHarvestMode == "farm"

    writeToFile()

    clearAll()

end --local function createSettings()



local function saplingCheck()

    if not bLowSaplings and turtle.getItemCount( 1 ) < ( nRows * nTrees > 32 and 32 or ( nRows * nTrees < 9 and 9 or nRows * nTrees ) ) and turtle.getItemCount( 1 ) ~= 0 then
        bLowSaplings = true
        rednetSend( "loggerLowSaplings" )
    end --if not bLowSaplings and turtle.getItemCount( 1 ) < ( nRows * nTrees > 32 and 32 or ( nRows * nTrees < 9 and 9 or nRows * nTrees ) ) and turtle.getItemCount( 1 ) ~= 0

    if not bNoSaplings and turtle.getItemSpace( 1 ) == 64 then
        bNoSaplings = true
        rednetSend( "loggerNoSaplings" )
    end --if not bNoSaplings and turtle.getItemSpace( 1 ) == 64

end --local function saplingCheck()



local function output( _sState )

    if _sState == "on" then
        if bRefillSaplings or bEmptyLogs then
            for side, _ in pairs( tSides ) do
                if tSides[side] then
                    rs.setOutput( side, true )
                end --if tSides[side]
            end --for side, _ in ipairs( tSides )
        end --if bRefillSaplings or bEmptyLogs then
    elseif _sState == "off" then
        for side, _ in pairs( tSides ) do
            if tSides[side] then
                rs.setOutput( side, true )
            end --if tSides[side]
        end --for side, _ in ipairs( tSides )
    end --if _sState

end --local function output( _sState )



local function emptyLogs()

    local slotCheck = bNoSaplings

    while true do

        for i = 2, 15 do
            if turtle.getItemSpace( 1 ) == 64 then
                slotCheck = false
            end --if turtle.getItemSpace( 1 ) == 64
            i = i == 2 and ( slotCheck and 1 or 3 ) or i
            if turtle.getItemSpace( i ) ~= 64 then
                break --for i = 3, 15
            else --turtle.getItemCount( i ) ~= 64
                if i == 15 then
                    return true
                end --if i == 15
            end --if turtle.getItemSpace( i ) ~= 64
        end --for i = 3, 15

        sleep( 0.01 )

    end --while true

end --local function emptyLogs()



local function refillSaplings()

    while true do

        if turtle.getItemSpace( 1 ) == 0 then
            return true
        end --if turtle.getItemSpace == 0

        sleep( 0.01 )

    end --while true

end --local function refillSaplings()



local function plantTree()
    if bDebug then
        print( "plantTree" )
    end --if bDebug

    saplingCheck()

    if not bNoSaplings and not turtle.compareDown() then
        if not turtle.detectDown() then
            select( 1 )
            if not turtle.placeDown() then
                move( "down", 1, select() )
                select( 2 )
                turtle.placeDown()
                move( "up", 1, select() )
                select( 1 )
                turtle.placeDown()
            end --if not turtle.placeDown()
        end --if not turtle.detectDown()
    end --if not bNoSaplings and not turtle.compareDown()

    saplingCheck()

end --local function plantTree()



local function harvestTree()
    if bDebug then
        print( "harvestTree" )
    end --if bDebug

    move( "forward", 1, 3 )
    if turtle.compareDown() then
        dig( "down" )
    end --if turtle.compareDown()

    bar = foo
    foo = 0

    while turtle.compareUp() do

        move( "up", 1, 3 )
        foo = foo + 1
        if foo == 20 then
            break --while true
        end --if foo == 20

    end --while turtle.compareUp() do

    for i = 1, foo do

        move( "down", 1, 1 )

    end --for i = 1, foo

    foo = bar
    bar = nil

    plantTree()

end --local function harvestTree()



local function checkTree()
    if bDebug then
        print( "checkTree" )
    end --if bDebug

    if turtle.getItemSpace( 3 ) < 64 then

        select( 3 )

        if turtle.compare() then
            harvestTree()
        else --turtle.compare()
            move( "forward", 1, 1 )
            plantTree()
        end --if turtle.compare()

    else --turtle.getItemSpace( 3 ) < 64

        if turtle.detect() then
            harvestTree()
        else --turtle.detect()
            move( "forward", 1, 1 )
            plantTree()
        end --if turtle.detect()

    end --if turtle.getItemSpace < 64

    nTreesremaining = nTreesremaining - 1
    header()
    local xCursorPos, yCursorPos = term.getCursorPos()
    term.setCursorPos( 1, 3 )
    term.clearLine()
    write( "Harvesting " .. nRows .. "x" .. nTrees .. ". " .. nTreesremaining .. ( nTreesremaining == 1 and " tree" or " trees" ) .. " remaining." )
    term.setCursorPos( xCursorPos, yCursorPos )

end --local function checkTree()



local function harvest( _sHarvestMode )
    if bDebug then
        print( "harvest" )
    end --if bDebug

    if _sHarvestMode == "farm" then

        bLowSaplings = false
        bNoSaplings = false

        saplingCheck()

        nTreesremaining = nRows * nTrees

        if bUseFuel then
            while turtle.getFuelLevel() < ( ( nTreesremaining ) * 3 ) + ( nRows % 2 == 1 and ( nTrees * 3 ) or 1 ) + ( nRows * 3 ) - 2 do

                if turtle.getItemSpace( 16 ) ~= 64 then
                    select( 16 )
                else --turtle.getItemSpace( 16 ) ~= 64
                    for i = 3, 15 do
                        if turtle.getItemSpace( i ) ~= 64 then
                            turtle.select( i )
                            break --for i = 3, 15
                        end --if turtle.getItemSpace( i ) ~= 64
                        if i == 15 then
                            print( "Need " .. ( ( ( nTreesremaining ) * 3 ) + ( nRows % 2 == 1 and ( nTrees * 3 ) or 1 ) + ( nRows * 3 ) - 2 ) - turtle.getFuelLevel() .. " more fuel." )
                            sleep( 2 )
                            return
                        end --if i == 15
                    end --for i = 3, 15
                end --if turtle.getItemSpace( 16 ) ~= 64
                turtle.refuel( 1 )

            end --while turtle.getFuelLevel() < ( ( nTreesremaining ) * 3 ) + ( nRows % 2 == 1 and ( nTrees * 3 ) or 1 ) + ( nRows * 3 ) - 2
        end --if bUseFuel

        if turtle.getItemCount( 1 ) < nTreesremaining then
            rednetSend( "loggerLowSaplings" )
        end --if turtle.getItemCount( 1 ) < nTreesremaining


        clearAll()
        print( "Harvesting " .. nRows .. "x" .. nTrees .. ". " .. nTreesremaining .. ( nTreesremaining == 1 and " tree" or " trees" ) .. " remaining." )

        move( "up", 1, 1 )
        checkTree()

        for i = 1, nRows do

            for i = 1, nTrees do

                if i ~= nTrees then

                    move( "forward", 2, 1 )
                    checkTree()

                end --if i ~= nTrees

            end --for i = 1, nTrees

            if i ~= nRows then
                move( i % 2 == 0 and "right" or "left", 2, 1 )
                checkTree()
                move( i % 2 == 0 and "right" or "left", 0, 1 )
            end --if i ~= nRows

        end --for i = 1, nRows

        if nRows % 2 == 0 then
            move( "forward", 1, 1 )
            move( "left", 0, 1 )
        else --nRows % 2 == 0
            move( "left", 1, 1 )
            move( "left", 0, 1 )
            move( "forward", ( nTrees * 3 ) - 2, 1 )
            move( "left", 1, 1 )
        end --if nRows % 2 == 0

        if nRows ~= 1 then
            move( "forward", ( nRows * 3 ) - 3, 1 )
        end --if nRows ~= 1

        move( "left", 0, 1 )
        move( "down", 1, 1 )

        output( "on" )
        if bEmptyLogs then
            if bRefillSaplings then
                parallel.waitForAll( emptyLogs, refillSaplings )
            end --if bRefillSaplings
            parallel.waitForAll( emptyLogs )
        else --bEmptyLogs
            if bRefillSaplings then
                parallel.waitForAll( refillSaplings )
            end --if bRefillSaplings
        end --if bEmptyLogs
        output( "off" )


    elseif _sHarvestMode == "bonemeal" then

        while true do

            if not bKeyLog then

                clearAll()
                print( "Press Any Key to Stop Logging" )

                if turtle.getItemSpace( 1 ) ~= 64 and turtle.getItemSpace( 2 ) ~= 64 then

                    select( 1 )
                    if not turtle.compare() then
                        while not turtle.place() do
                            turtle.dig()
                        end --while not turtle.place()
                    end --if turtle.compare()

                    select( 2 )
                    if not turtle.place() then
                        print( "Need bonemeal in slot 2" )
                        sleep( 1 )
                        return
                    end --if not turtle.place()

                    move( "forward", 1, 3 )

                    bar = foo
                    foo = 1

                    while turtle.compareUp() do

                        move( "up", 1, 3 )
                        foo = foo + 1
                        if foo == 20 then
                            break --while turtle.compareUp()
                        end --if foo == 20

                    end --while turtle.compareUp()

                    for i = 1, foo do
                        if i ~= foo then
                            move( "down", 1, 3 )
                        end --if i ~= foo
                    end --for i = 1, foo

                    foo = bar
                    bar = nil

                    move( "back", 1, 3 )


                else --if turtle.getItemSpace( 1 ) ~= 64 and turtle.getItemSpace( 2 ) ~= 64

                    term.setCursorPos( 1, 3 )
                    term.clearLine()

                    if turtle.getItemSpace( 1 ) == 64 then
                        print( "Need saplings in slot 1" )
                    end --if turtle.getItemSpace( 1 ) == 64

                    if turtle.getItemSpace( 2 ) == 64 then
                        print( "Need bonemeal in slot 2" )
                    end --if turtle.getItemSpace( 1 ) == 64

                    sleep( 2 )
                    return

                end --if turtle.getItemSpace( 1 ) ~= 64 and turtle.getItemSpace( 2 ) ~= 64

            else --not keyLog

                break --while true

            end --if not bKeyLog

        end --while true

    end --if _sHarvestMode == "farm"

end --local function harvest( _sHarvestMode, nRows, nTrees )







--[[MAIN METHOD]]


while true do

    if not loadSettings() then
        createSettings()
    end --if not LoadSettings()

    rednet.open( "right" )
    baz = bUseBroadcast

    while true do
        if baz then
            clearAll( 1, 3, "Anonomit Tree Farmer #" .. os.computerID(), 5 )
        else --baz
            clearAll()
        end --if baz
        baz = bUseBroadcast
        print( "Press 'r' to begin logging" )
        print( "Press 's' to recreate settings" )
            if bUseBroadcast then
                print( "Press 'c' to clear broadcast console" )
            end --if bUseBroadcast

        local event, param1, param2, param3 = os.pullEvent()
        if event == "char" and param1 == "r" then
            rednetSend( "loggerLogging" )
            if sHarvestMode == "farm" then
                harvest( sHarvestMode )
            elseif sHarvestMode == "bonemeal" then
                parallel.waitForAny( function() harvest( sHarvestMode ) end, keyLog )
            end --if sHarvestMode == "farm"
            rednetSend( "loggerDoneLogging" )
            print( "Press 'r' to begin logging" )
            print( "Press 's' to recreate settings" )
            if bUseBroadcast then
                print( "Press 'c' to clear broadcast console" )
            end --if bUseBroadcast
        elseif bUseBroadcast and param1 == nBroadcastID and event == "rednet_message" and param2 == "loggerStartLogging" then
            rednetSend( "loggerLogging" )
            if sHarvestMode == "farm" then
                harvest( sHarvestMode )
            elseif sHarvestMode == "bonemeal" then
                parallel.waitForAny( function() harvest( sHarvestMode ) end, keyLog )
            end --if sHarvestMode == "farm"
            rednetSend( "loggerDoneLogging" )
            print( "Press 'r' to begin logging" )
            print( "Press 's' to recreate settings" )
        elseif event == "char" and param1 == "s" then
            createSettings()
            break --while true
        elseif event == "char" and param1 == "c" then
            rednetSend( "loggerForget" )
            local id, msg, dist = rednet.receive( 0.1 )
            if id == nBroadcastID and msg == "loggerForgot" then
                local xCursorPos, yCursorPos = term.getCursorPos()
                term.setCursorPos( 1, yCursorPos - 1 )
                term.clearLine()
                print( "Cleared from Broadcast Console" )
                bUseBroadcast = false
                writeToFile()
            else --id == nBroadcastID and msg == "loggerForgot"
                local xCursorPos, yCursorPos = term.getCursorPos()
                term.setCursorPos( 1, yCursorPos - 1 )
                term.clearLine()
                print( "No Response" )
                sleep( 0.5 )
            end --if id == nBroadcastID and msg == "loggerForgot"
        end --if event == "char" and param1 == "r"
    end --while true

end --while true