--Logger V1.0 program made by Anonomit
-- Edited By MinecraftFarms12
-- All Creadit Goes to 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("right")
                        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 'x' to exit" )
                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 == "x" then --add a damn exit function
                shell.run("clear")
                return
                elseif 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