Logger

    --Logger V1.0 program made by Anonomit


    local bNoBroadcast = false --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