enclosed tree farm 2 experiment

--This pastebin is to test new stuff while the old code is still working
--Not working!

--pastebin get YVAQ1ZZ9 theinsektAPIs/treefarm2


--position zero is in one of the top corners, under a crafting table


os.loadAPI("theinsektAPIs/fileHelp")
os.loadAPI("theinsektAPIs/poz3")
os.loadAPI("theinsektAPIs/poz3a")

function treeFarm(wallBlocks,limit)
--emptyInventory("d", {["minecraft:sapling"]=2,})--debug
--do return end

--if this is the first time, or if there was an error before
--print usage instructions
local startStuffPath="configs/startStuff"
local startString=fileHelp.loadString(startStuffPath)
if startString~="skip" then
  if startString==nil then startString="first" end
  if startString=="first" then
    print("Place this turtle in an enclosed room, with the width in both directions being odd (5 ,7 etc.).")
    print("Put one or more saplings in inventory slot 1, in the turtle.")
    print("Put an output chest in the middle along one of the walls, in the floor.")
    print("Put a fuel chest 2 steps to the left (if looking towards middle from output chest).")
    print("Put a dirt block in middle of the floor.")
  else
    print("Previously quit with error:")
    print(startString)
  end
  print("Press: c continue, e exit,i instructions, r reset configs, u update.")

  --wait for key press
  local _, key =os.pullEvent("key")
  --clear terminal
  --term.clear()
  --term.setCursorPos(1,1)

  if key==keys.c then
    print("continuing...")
    fileHelp.saveString(startStuffPath,"skip")
  elseif key==keys.e then
    print("Exiting...")
    return
  elseif key==keys.i then
    fileHelp.saveString(startStuffPath,"first")
    os.reboot()
  elseif key==keys.r then
    clearConfigs()
    fileHelp.saveString(startStuffPath,"first")
    os.reboot()
  else--
    print("Choice not yet implemented, terminating")
    return
  end
end--if
treeFarmStates(wallBlocks,limit)
end--function

--wallblocks is a table like this {"minecraft:cobblestone"=true, "minecraft:glass"=true, "minecraft"}
function treeFarmStates(wallBlocks,limit)
--state: start
print("debug, state: start")
--will save stuff like plantName and dimensions,
--so that it can be loaded after next restart
--local tryLoad=true
--local trySave=true

--state: getting plantName
print("debug, state: getting plantName")
--get type of plant (from file or slot 1)
local plantName = getItemType(1,"configs/plantName")
if plantName==nil then
  quitWithError("Error: No plant in slot 1")
end

----(skipped)state: getting fuelName
--get type of fuel (from file or slot 2)
--local fuelName = getItemType(2,"configs/fuelName")

--state: getting room dimensions, get dimensions of room (from file or program)
print("debug, state: getting room dimensions")
local dimensions=getDimensions(wallBlocks, limit,"configs/dimensions")
local halfWidth=math.floor(dimensions["width"]/2)

--state: defining coordinate points, now it's possible to define some coordinates
print("debug, state: defining coordinate points")
--some coords
--positive x=east
--positive y=up
--positive z=south
--north is if standing on output chest and looking towards plant in the middle
local outputChestPos={x=0,y=0,z=0,f="n"}--above output chest, looking towards plant in middle of room
local southWestCorner={x=-halfWidth,y=0,z=0,f="n"}--used as a starting point when harvesting
local waitPos={x=0,y=0,z=-(halfWidth-1),f="n"}--go north from outputChestPos until before plant
local fuelPos={x=-2,y=0,z=0,f="n"}--two steps to the left of output chest

--state: defining keep table
print("debug, state: defining keep table")
--what items to keep when emptying the inventory, and how much
--local keepTable={[plantName]=32,[fuelName]=32}
local keepTable={[plantName]=32,}



--state: finding pos
print("debug, state: finding pos")
findAndSetPos(dimensions, plantName, wallBlocks,waitPos,outputChestPos)


while(true) do
  --state: refuelling
  print("debug, state: refueling")
  --refuel if has to little fuel
  gotoAndRefuelFromChestIf(fuelPos, "d",1000,2000)
  --state: waiting
  print("debug, state: waiting")
  --wait until not plant
  while(true) do
    --get what is infront
    local success, data=poz3.inspect("n")
    if not success then
      --plant has somehow disappeared, so goto next state
      break
    end
    if success and data.name~=plantName then
      --it's a tree, or the wrong plant, so goto next state
      break
    end
    --the sappling is still there so wait for a while
    os.sleep(10)
  end
  --state: destroying plant position
  print("debug, state: destroying plant position")
  --dig if it's not a wall
  if not isBlockMatch("n", wallBlocks) then
    poz3.dig("n")
  end
  --state: harvesting/clearing (destroy not plant and not wall, then dcube2 inside room)
  print("debug, state: harvesting/clearing")
  harvest(dimensions, southWestCorner)
  --state: emptying inventory
  print("debug, state: emptying inventory")
  if not poz3a.digToCoords2(outputChestPos) then
    quitWithError("Error: failed when trying to go to output chest.")
  end
  emptyInventory("d", keepTable)
  --state: planting
  print("debug, state: planting")
  --goto plant/wait position
  if not poz3a.digToCoords2(waitPos) then
    quitWithError("Error: failed when trying to go to wait position (infront of plant).")
  end
  --place/plant sapling
  if not placeItem("n",plantName) then
    quitWithError("Error: failed when trying to place sapling.")
  end
end
end--main

function gotoAndRefuelFromChestIf(fuelPos, direction,lower,upper)
  --check if fuel level is below lower limit
  local fuelLevel=turtle.getFuelLevel()
  --quit if doesn’t need to refuel (fuel level isn't below lower)
  local fuelLevel=turtle.getFuelLevel()
  if fuelLevel == "unlimited" or fuelLevel >= lower then
    return
  end
  --goto refuelling chest
  if not poz3a.digToCoords2(fuelPos) then
    quitWithError("Error: failed when trying to go to refuelling position.")
  end
  --refuel from chest
  if not refuelFromChest(direction, upper) then
    quitWithError("Error: failed when refuelling from chest.")
  end
end

--suck fuel from a chest in the given direction
--and refuel until fuel level reaches upper (upper bound)
function refuelFromChest(direction,upper)
  --return true if has unlimited fuel
  if turtle.getFuelLevel() == "unlimited" then return true end
  --check upper
  if upper>turtle.getFuelLimit() then upper=turtle.getFuelLimit() end
  --select the slot to place the fuel in
  local slot=findEmptyInventorySlot()
  if slot==-1 then
    return false
  end
  turtle.select(slot)
  --refuel from chest
  while(turtle.getFuelLevel()<upper) do
    if not poz3.suck(direction,1) then
      --could not suck fuel from fuel chest
      return false
    end
    if not turtle.refuel() then
      --could not refuel from the selected slot
      --maybe it's not a fuel
      return false
    end
  end
  --refuelled!
  return true
end

function findEmptyInventorySlot()
  for slot=1,16 do
    if turtle.getItemCount(slot)==0 then
      return slot
    end
  end
  return -1
end


function placeItem(direction, itemName)
  local slot=getItemSlot(itemName)
  if slot==-1 then return false end
  turtle.select(slot)
  return poz3.place(direction)
end

function getItemSlot(itemName)
  for slot=1, 16 do
    local data=turtle.getItemDetail(slot)
    if data and data.name==itemName then
      return slot
    end
  end
  return -1
end


--not tested
--example keepTable: {"minecraft:sappling"=32,"minecraft:charcoal"=32}
function emptyInventory(direction, keepTable)
  local amounts={}
  for slot=1, 16 do
    local data=turtle.getItemDetail(slot)
    if data then
      if keepTable[data.name] then
        if not amounts[data.name] then amounts[data.name]=0 end
        local limit=keepTable[data.name]
        amount = turtle.getItemCount(slot) + amounts[data.name]
        if amount>limit then
          local dropAmount=amount-limit
          turtle.select(slot)
          poz3.drop(direction,dropAmount)
          amount=limit
        end --if amount>limit
        amounts[data.name]=amount
      else --if keep
        --drop whole stack
        turtle.select(slot)
        poz3.drop(direction)
      end
    end--if data
  end --for
  return true
end

function harvest(dimensions, southWestCorner)
  --go to southwest corner
  if not poz3a.digToCoords2(southWestCorner) then
    quitWithError("Error: failed when trying to go to southWestCorner.")
  end
  --harvest, digcube ,refuel=false, return to origin=true
  if not poz3a.callDigCube("u",dimensions["height"],"e",dimensions["width"],"n",dimensions["width"],false,true) then
    quitWithError("Error: failed when digging everything inside the room.")
  end
  --returned to south west corner
end



--does not need a known postion
function getDimensions(wallBlocks,limit, path)
  local dimensions=nil

  if path then
    dimensions = fileHelp.loadValue(path)
    if dimensions~=nil then return dimensions end
  end

  --measure dimensions
  --go to a top corner
  local len1,data=digGoUntilWall("u",wallBlocks,limit)
  if turtle.getFuelLevel() == 0 then quitWithError("Turtle error: turtle is out of fuel.") end
  if not data then quitWithError("Room error: reached limit without finding a wall block.") end

  local len2,data=digGoUntilWall("w",wallBlocks,limit)
  if turtle.getFuelLevel() == 0 then quitWithError("Turtle error: turtle is out of fuel.") end
  if not data then quitWithError("Room error: reached limit without finding a wall block.") end


  local len3,data=digGoUntilWall("s",wallBlocks,limit)
  if turtle.getFuelLevel() == 0 then quitWithError("Turtle error: turtle is out of fuel.") end
  if not data then quitWithError("Room error: reached limit without finding a wall block.") end


  --measure height
  local height,data=digGoUntilWall("d",wallBlocks,limit)
  height=height+1--because needs to count place where turtle stood
  if turtle.getFuelLevel() == 0 then quitWithError("Turtle error: turtle is out of fuel.") end
  if not data then quitWithError("Room error: reached limit without finding a wall block.") end


  if height<2 then error("Room error: the room must have a height that is 2 or larger.") end

  --measure width1
  local width1,data=digGoUntilWall("e",wallBlocks,limit)
  width1=width1+1--because needs to count place where turtle stood
  if turtle.getFuelLevel() == 0 then quitWithError("Turtle error: turtle is out of fuel.") end
  if not data then quitWithError("Room error: reached limit without finding a wall block.") end

  if width1<5 then
    quitWithError("Room error: the width of the room must be 5 or larger.")
  end

  if (width1 % 2) == 0 then
    if not data then
      quitWithError("Room error: the width of the room must be odd number, examples 5 ,7, 9 etc.")
    end
  end


  --measure width2
  local width2,data=digGoUntilWall("n",wallBlocks,limit)
  width2=width2+1--because needs to count place where turtle stood
  if turtle.getFuelLevel() == 0 then quitWithError("Turtle error: turtle is out of fuel.") end
  if not data then quitWithError("Room error: reached limit without finding a wall block.") end


  if width1 ~= width2 then quitWithError("Room error: width1 and width2 must be the same in the room.") end

  --save and return dimensions
  dimensions={["width"]=width1, ["height"]=height,}
  if path then
    fileHelp.saveValue(path,dimensions)
  end
  return dimensions
end

--general code that can be reused in many situations
function doLoop(limit,doFunction,direction,...)
  for i=1,limit do
    local success, data=doFunction(direction,...)
    if not success then
      return i-1,data
    end
  end
  return limit,nil
end

--works for all the directions
--returns steps taken and the data from a wall block if was stopped by it
function digGoUntilWall(direction, wallBlocks,limit)
  --get absolute direction so that if the direction is right
  --it will continue forward after turning right once
  direction=poz3.getAbsoluteDirection(direction)
  --do the actual loop and then return the result
  return doLoop(limit,digGoIfNotWall,direction,wallBlocks)
end

--Works in all directions.
--Handles blocking players or creatures.
--Returns false if out of fuel (handles unlimited fuel)
--Kinda handles gravel blocks (will not be blocked, but may leave some)
--stops if reaches one of the wallBlocks
function digGoIfNotWall(direction,wallBlocks)
  --check fuel level
  local fuelLevel=turtle.getFuelLevel()
  local noFuel = fuelLevel ~= "unlimited" and fuelLevel < 1 then
  --an infinite loop so that it won't be blocked by creatures
  while(true) do
    local success,data=poz3.inspect(direction)
    if success then
      --detected a block
      if wallBlocks[data.name] then
        --found wall so send data and stop signal
        return false,data
      end--if
      if not poz3.dig(direction) then
        --found non wall block, but could not dig through it
        --so return stop signal and nil
        return false,nil
      end--if
    end--if success
    if poz3.go(direction) then
      --managed to go so return continue signal
      return true,nil
    elseif nofuel then
      --could not go becuase of fuel so return stop signal and nil
      return false,nil
    end--elseif
    --continue trying if could not go becuase of a blocking creature
  end--while
end

--will add reference block to wallblocks if it's not already added
function findPos2(limit,path,referencePos,referenceBlock,wallBlocks)
  --add reference block to wallblocks so that it won't be dug
  wallBlocks[referenceBlock]=true

  --go to upper north west corner
  local directions={"u","n","w"}
  for _,dir in ipdairs(directions) do
    local distance, data = digGoUntilWall(direction, wallBlocks,limit)
    if not data then
      error("Room error: Could not find wall when trying to find position.")
    end
  end

  --search for referenceBlock
  local data,matchDirection=nil,nil
  local directions={"s","e","n"}
  for i,goDirection in ipdairs(directions) do
    data,matchDirection=blockMatching(referenceBlock, "u")
    if data then break end
    digGoUntilWallErrors(goDirection, wallBlocks,limit,noWallErrorString)
    if i==3 then
      data,matchDirection=blockMatching(referenceBlock, "u")
      if data then break end
    end
  end
  if not data then
    error("Room error: there is no reference block in one of the upper corners.")
  end

  --if here, have found referenceBlock, turn to face north
  local turnDirection="l"
  --turn until wall
  while(not poz3.detect("f") and turn(turnDirection))
  --turn until not wall
  while(poz3.detect("f") and turn(turnDirection))
  --turn once more
  turn(turnDirection)
  --if was in corner will have wall on right side, if turns right
  --if turns left will have wall on left side
  --if was along wall will be facing out from wall

  --if has no refrence position, then set it to amount of steps from previous corner
  if referencePos==nil then referencePos = {x=distance,y=0,z=0,f="n"} end

  --have found referencePos
  poz3.setPos2(referencePos)
end

--warning: will not automatically turn back
--directions are relative to the starting direction, so "r","f" is possible
--example usage1:
--matchBlockDirections("minecraft:cobblestone","f","u")
--example usage2:
--matchBlockDirections({"minecraft:cobblestone"=true,"minecraft:glass"=true},"f","r","l")
function blockMatching(blocksOrBlock,...)
  --check arguments
  checkArg(1, blocksOrBlock, "string","table")
  --arg is the table that ... is automatically stored in
  local directions=arg
  --loops through the directions and checks if it is one of the wanted blocks
  for i, direction in ipairs(directions) do
    checkArg(i+1, direction, "string")
    --neccesary if for example have "r" and "f"
    direction=poz3.getAbsoluteDirection(direction)
    --check if the direction have the block
    local success,data=poz3.inspect(direction)
    --check if detected a block
    if success then
      --check if it's one block or many blocks
      if type(blocksOrBlock)=="string" then
        --check against one block
        local block=blocksOrBlock
        if block==data.name then
          return data,direction
        end--if block
      else
        --check against many blocks
        local blocks=blocksOrBlock
        if blocks[data.name] then
          return data,direction
        end--if blocks
      end--else
    end--if success
  end--for
  --no matching block was found, so retrun nil,nil
  return nil,nil
end

function findReferenceBlock(wallBlocks,referenceBlock,limit)
  local distance, data, matchDirection=digGoSearchUntilWallOrMatch("s",wallBlocks, limit, referenceBlock, "u")
  if matchDirection then return true end
  if distance==limit then return false end
  local distance, data, matchDirection=digGoSearchUntilWallOrMatch("e",wallBlocks, limit, referenceBlock, "u")
  if matchDirection then return true end
  if distance==limit then return false end
  local distance, data, matchDirection=digGoSearchUntilWallOrMatch("n",wallBlocks, limit, referenceBlock, "u")
  if matchDirection then return true end
  if distance==limit then return false end
  --local distance, data, matchDirection=digGoSearchUntilWallOrMatch("w",wallBlocks, limit, referenceBlock, "u")
  if matchDirection then return true end
  --if distance==limit then return false end
  --didn't find reference block along any edge
  return false
end

--returns true if should be waiting
--returns false if should be harvesting
function findAndSetPos(dimensions, plantName, wallBlocks,waitPos,outputChestPos)
  local success,data=poz3.inspect("f")
  if success then
    if data.name==plantName then
      --known pos, at waitpos
      print("debug, pos: waitPos")
      poz3.setPos2(waitPos)
      return
    end --if
    --if it's not a wall it might be
    --a sapling of wrong type so destroy it
    if not wallBlocks[data.name] then
      print("removing potential bad plant")
      poz3.dig("f")
    end
  end --if

  --unknown pos, so find it
  local halfWidth=math.floor(dimensions["width"]/2)
  findOutputChest(dimensions,halfWidth,wallBlocks)
  print("debug, pos: outputChestPos")
  poz3.setPos2(outputChestPos)
end --function

--Goes to the outputChestPos without knowing the current position
function findOutputChest(dimensions,halfWidth,wallBlocks)
  --go to a top corner
  local _,data=digGoUntilWall("u",wallBlocks,dimensions["height"])
  if data==nil then quitWithError("Room error: a wall is missing, or dimensions have changed") end
  local _,data=digGoUntilWall("w",wallBlocks,dimensions["width"])
  if data==nil then quitWithError("Room error: a wall is missing, or dimensions have changed") end
  local _,data=digGoUntilWall("s",wallBlocks,dimensions["width"])
  if data==nil then quitWithError("Room error: a wall is missing, or dimensions have changed") end


  --go to bottom corner
  local len1,data=digGoUntilWall("d",wallBlocks,dimensions["height"]+1)
  if data==nil then quitWithError("Room error: a wall is missing, or dimensions have changed") end
if len1+1 ~= dimensions["height"] then quitWithError("Room error: a wall is missing, or dimensions have changed") end


  --go in circle looking for chest,
  local turnDirectionIfFound="l"
  if checkForMiddleChest("e",halfWidth,wallBlocks,turnDirectionIfFound) then return true end
  if checkForMiddleChest("n",halfWidth,wallBlocks,turnDirectionIfFound) then return true end
  if checkForMiddleChest("w",halfWidth,wallBlocks,turnDirectionIfFound) then return true end
  if checkForMiddleChest("s",halfWidth,wallBlocks,turnDirectionIfFound) then return true end

  quitWithError("Room error: there is no output chest at the four possible positions, or room dimensions have changed")
end

--must be going along right wall
function checkForMiddleChest(direction,halfWidth,wallBlocks,directionIfFound)
  local _,data=digGoUntilWall(direction,wallBlocks,halfWidth)
  if data then quitWithError("Room error: a wall block is inside room, or dimensions have changed") end
  local success, data=poz3.inspect("d")
  if success and data and data.name=="minecraft:chest" then
    poz3.turn(directionIfFound)
    return true
  end
  local _,data=digGoUntilWall(direction,wallBlocks,halfWidth+1)
  if not data then quitWithError("Room error: a wall block is missing, or dimensions have changed") end
  return false
end






--returns blocksTraveled, blockData if encountered a wall
--returns limit, nil if travelled limit blocks
--returns blokcsTraveled, nil if blocked by something undigable (impossible?)
function digGoUntilWall(direction, wallBlocks,limit)
  for i=1, limit do
    local went, data = digGoIfNotWall(direction, wallBlocks)
    if not went then return i-1, data end
  end
  return limit,nil
end

--digs or goes one step in the given direction
--returns true,nil if went
--returns false, nil if could not dig through non wall block
--returns false, blockData if reached wall
--will continue trying if blocked by player
function digGoIfNotWall(direction,wallBlocks)
  --no fuel
  if turtle.getFuelLevel() == 0 then return false,nil end
  while(true) do
    --check block in direction
    local success, data=poz3.inspect(direction)
    if success then
      if wallBlocks[data.name] then
        return false, data
      end
      if not poz3.dig(direction) then return false, nil end
    end
    --go in direction
    if poz3.go(direction) then return true, nil end
  end
end


--resulting direction could be changed
--returns the name of the block, if it's one of the blocks
--blocks could be a string, or a table with string keys
function isBlockMatch(direction, blocks)
  local success, data=poz3.inspect(direction)
  if success then
    if type(blocks)=="string" then
      if data.name=blocks
        return data.name
      end--if
      return nil
    end--if type
    if blocks[data.name]
      return data.name
    end--if
  end--if success
  return nil
end--function


--first tries to get itemname from the given file path
--second tries to find name of the item in the given slotNum
--if got itemName from slot and doSave is true, then saves the itemName in the given path
function getItemType(slotNum,path)
  local itemName=nil
  if path then
    itemName=fileHelp.loadString(path)
  end
  if itemName==nil then
    local data=turtle.getItemDetail(slotNum)
    if data then
      itemName=data.name
      if path then
        fileHelp.saveString(path,itemName)
      end
    end
  end
  return itemName
end

function quitWithError(errorMessage)
  fileHelp.saveString("configs/startStuff",errorMessage)
  error(errorMessage,2)
end

function clearConfigs()
  --delete the configs folder
  fs.delete("configs")
end