View difference between Paste ID: YVAQ1ZZ9 and nLNQiU0W

---pastebin get nLNQiU0W theinsektAPIs/treefarm1
+--This pastebin is to test new stuff while the old code is still working
--- see ziBBd33L for startup program and installation instructions
+--Not working!
---not working, experimental, not tested
+
---will plant in middle of room.
+--pastebin get YVAQ1ZZ9 theinsektAPIs/treefarm2
---the outputChest should be in the floor,
+
---adjacent to a wall, and intersected by a straight line from the middle of the room.
+
---Should be able to handle being restarted at any point in the program
+--position zero is in one of the top corners, under a crafting table
---except maybe the first time if interrupted while writing to file.
+
 
---position zero is above output chest facing inwards
+
 os.loadAPI("theinsektAPIs/poz3")
---todo: roof, walls and corners at bottom must be walltype
+
---
+
 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