View difference between Paste ID: PJZ9sWhB and dQJFnnAF

 -- Cloned
 -- This is an API for digging and
 -- keeping track of motion
 -- <[email protected]>
 
 -- x is right, y is up, z is forward
 -- r is clockwise rotation in degrees
 
 -------------------------------------
 -- |¯\  [¯¯]  /¯¯]    /\  |¯\ [¯¯] --
 -- |  |  ][  | [¯|   |  | | /  ][  --
 -- |_/  [__]  \__|   |||| ||  [__] --
 -------------------------------------
 
 os.loadAPI("flex.lua")
 
 local options = {
   "outputblocks",
   "blacklist",
   "buildingblocks",
   "dumplist",
   "fluids"  }
 
 
 -- Fluids, aka blocks treated as "Empty"
 options[options[5]] = {
   ":air", "water", "lava", "acid", "poison",
   "sewage", "sludge", "blood"  }
 
 
 -- Turtle will only drop loot into blocks
 -- that contain any of these keywords.
 options[options[1]] = {
   "chest", "storage", "box", "turtle",
   "hopper", "dropper", "backpack" }
 
 
 -- Turtle will avoid breaking (or getting
 -- stuck by) these blocks.
 -- Disabled by default;
 -- enable with dig.doBlacklist()
 options[options[2]] = { "chest", "spawn",
     "hopper", "dropper", "portal", "turtle",
     "hive", "openblocks:grave" }
 doblacklist = false
 function doBlacklist(x)
  if x == nil then
   x = true
  end --if
  doblacklist = (x==true)
 end --function
 
 
 -- Run dig.setBlockSlot(n) to choose
 -- a slot to keep building blocks stocked
 -- The list of valid keywords:
 options[options[3]] = { "cobblestone",
   "minecraft:stone", "dirt", "netherrack",
   "basalt", "soul_s", "magma_block",
   "terracotta", "rock", "sandstone",
   "andesite", "diorite", "granite",
   "marble", "bricks", "smooth_stone",
   "glass" }
 function isBuildingBlock(n)
  return flex.isItem(options[options[3]],n)
 end --function
 
 
 
 -- Turtle will dispose of these blocks
 -- at the command dig.doDump()/
 -- dig.doDumpUp()/dig.doDumpDown().
 -- You may add/remove entries by using
 -- dig.addToDumpList(<string>) or
 -- dig.removeFromDumpList(<string>).
 local dump = options[4]
 options[dump] = {}
 
 function resetDumpList(n)
  if n == 0 then
   options[dump] = {}
  else
   options[dump] = {
      "cobblestone", "dirt", "gravel",
      "andesite", "diorite", "granite",
      "netherrack", "soul_s", "magma_block",
      "rotten_flesh", "rock", "marble",
-     "gabbro", "scoria" }
+
      "gabbro", "scoria", "diorite", "granite", "slate" }
  end --if/else
 end --function
 
 function isDumpItem(x)
  return flex.isItem(options["dump"],x)
 end --function
 
 function addToDumpList(newkey)
  options[dump][#options[dump]+1] =
      tostring(newkey)
 end --function
 
 function removeFromDumpList(key)
  local x,z
  z = {}
  for x=1,#options[dump] do
   if string.find(options[dump][x],key)==nil then
    z[#z+1] = options[dump][x]
   end --if
  end --for
  options[dump] = z
 end --function
 
 resetDumpList()
 
 
 function doDump(z)
  z = z or "fwd"
  local slot = turtle.getSelectedSlot()
  local blockCount = blockStacks
  local x
  for x=1,16 do
   turtle.select(x)
   if flex.isItem(options[dump]) then
 
    if flex.isItem(options["buildingblocks"]) then
     blockCount = blockCount - 1
    end --if
 
    if blockCount <= 0 then
     if z == "fwd" then
      turtle.drop()
     elseif z == "down" then
      turtle.dropDown()
     elseif z == "up" then
      turtle.dropUp()
     end --if/else (direction)
    end --if (no more blocks needed)
 
   end --if dump item
  end --for
  checkBlocks()
  flex.condense(blockSlot)
  turtle.select(slot)
 end --function
 
 function doDumpDown() doDump("down") end
 function doDumpUp() doDump("up") end
 
 
 
 
 -- Attack entities that block the way
 attack = false
 function doAttack(x)
  if x == nil then
   x = true
  end --if
  attack = ( x == true )
 end --function
 
 
 function isChest(dir)
  return flex.isBlock(
    options["outputblocks"],dir)
 end --function
 function isChestUp()
  return isChest("up")
 end
 function isChestDown()
  return isChest("down")
 end
 
 
 local knownBedrock = {}
 function getKnownBedrock()
  return knownBedrock
 end --function
 
 
 
 
 ------------------------------------
 --  /¯\ |¯\[¯¯][¯¯] /¯\ |\ ||/¯¯\ --
 -- | O || / ||  ][ | O || \ |\_¯\ --
 --  \_/ ||  || [__] \_/ || \|\__/ --
 ------------------------------------
 --      |¯¯][¯¯]||  |¯¯]          --
 --      | ]  ][ ||_ | ]           --
 --      ||  [__]|__]|__]          --
 ------------------------------------
 
 local options_file = "dig_options.cfg"
 
 function optionsEdit()
  shell.run("edit "..options_file)
  optionsImport()
 end --function
 
 
 function optionsImport()
  if not fs.exists(options_file) then
   return false
  end --if
  local file,x,y,z
 
  for y=1,#options do
   z = options[y]
   file = fs.open(options_file,"r")
 
   x = file.readLine()
   while x ~= nil do
 
    if x == "["..z.."]" then
     options[z] = {}
     x = file.readLine()
     while x ~= "[/"..z.."]" and x ~= nil do
      options[z][#options[z]+1] = x
      x = file.readLine()
     end --while
     break
    end --if
 
    x = file.readLine()
   end --while
 
   file.close()
  end --for
 
  return true
 end --function
 
 
 function optionsExport()
  if fs.exists(options_file) then
   fs.delete(options_file)
  end --if
 
  local file,x,y,z
  while file == nil do
   file = fs.open(options_file,"w")
  end --while
  file.writeLine("# Dig API Options File #\n")
 
  for y=1,#options do
   z = options[y]
   file.writeLine("["..z.."]")
   for x=1,#options[z] do
    file.writeLine(options[z][x])
   end --for
   file.writeLine("[/"..z.."]\n")
  end --for
 
  file.close()
  return true
 end --function
 
 
 if not optionsImport() then
  optionsExport()
 end --if
 
 
 
 
 ----------------------------------
 --    /¯¯\  /\  ||  || |¯¯]     --
 --    \_¯\ |  |  \\//  | ]      --
 --    \__/ ||||   \/   |__]     --
 ----------------------------------
 -- |¯\  /\   /¯] ||// || || |¯\ --
 -- | < |  | | [  | <  ||_|| | / --
 -- |_/ ||||  \_] ||\\  \__| ||  --
 ----------------------------------
 
 local save = {"dig_save", ".cfg"}
 local savefile = save[1] .. save[2]
 local start = {"startup", ".lua"}
 local startfile = start[1] .. start[2]
 
 function saveExists()
  return ( fs.exists(startfile) and
     fs.exists(savefile) )
 end --function
 
 function saveClear()
  if fs.exists(startfile) then
   fs.delete(startfile)
  end --if
 end --function
 function clearSave()
  saveClear()
 end --function
 
 
 local args = {...}
 if #args > 0 then
  local a,file
 
  if args[1] == "save" then
   if not saveExists() then
    flex.send("Nothing to save",colors.yellow)
    return
   end --if
   if #args == 1 then
    a = 1
    while fs.exists(start[1].."_"..
         tostring(a)..start[2]) do
     a = a + 1
    end --while
   else -- #args > 1
    a = args[2]
   end --if
   a = tostring(a)
   shell.run("mv "..startfile.." "..
       start[1].."_"..a..start[2])
   shell.run("mv "..savefile.." " ..
       save[1].."_"..a..save[2])
   flex.send("Enter 'dig load "..a..
       "' to restore",colors.lightBlue)
 
  elseif args[1] == "load" then
   if #args == 1 then
    flex.send("Please specify load file",
      colors.red)
    return
   end --if
   saveClear()
   a = args[2]
   shell.run("mv "..start[1].."_"..a..
      start[2].." "..startfile)
   shell.run("mv "..save[1].."_"..a..
      save[2].." "..savefile)
   flex.send("Save files restored",
      colors.lightBlue)
 
  elseif args[1] == "clear" then
   saveClear()
   flex.send("Save files cleared",
       colors.lightBlue)
 
  elseif args[1] == "edit" then
   optionsEdit()
 
  else -- not save/load/clear/edit
   flex.send("Invalid parameter: "..
       args[1],colors.red)
 
  end --if/else save/load
  return
 end --function
 
 
 -----------------------------------------
 -- ||   /¯\  /¯] /\ [¯¯][¯¯] /¯\ |\ || --
 -- ||_ | O || [ |  | ||  ][ | O || \ | --
 -- |__] \_/  \_]|||| || [__] \_/ || \| --
 -----------------------------------------
 --||  || /\ |¯\[¯¯] /\ |¯\||  |¯¯]/¯¯\ --
 -- \\// |  || / ][ |  || <||_ | ] \_¯\ --
 --  \/  ||||| \[__]|||||_/|__]|__]\__/ --
 -----------------------------------------
 
 xdist = 0
 xlast = -1
 xmin = 0
 xmax = 0
 
 ydist = 0
 ylast = -1
 ymin = 0
 ymax = 0
 
 zdist = 0
 zlast = -1
 zmin = 0
 zmax = 0
 
 rdist = 0
 rlast = -1
 
 lastmove = "r-"
 dugtotal = 0
 
 
 function getx() return xdist end
 function gety() return ydist end
 function getz() return zdist end
 function getr() return rdist end
 
 function setx(x) xdist = x end
 function sety(y) ydist = y end
 function setz(z) zdist = z end
 function setr(r) rdist = r end
 
 function getxmin() return xmin end
 function getxmax() return xmax end
 function getymin() return ymin end
 function getymax() return ymax end
 function getzmin() return zmin end
 function getzmax() return zmax end
 
 function setxmin(x) xmin = x end
 function setxmax(x) xmax = x end
 function setymin(y) ymin = y end
 function setymax(y) ymax = y end
 function setzmin(z) zmin = z end
 function setzmax(z) zmax = z end
 
 function getxlast() return xlast end
 function getylast() return ylast end
 function getzlast() return zlast end
 function getrlast() return rlast end
 
 function setxlast(x) xlast = x end
 function setylast(y) ylast = y end
 function setzlast(z) zlast = z end
 function setrlast(r) rlast = r end
 
 function getlast() return lastmove end
 function setlast(lm) lastmove = lm end
 
 function getdug() return dugtotal end
 function setdug(d) dugtotal = d end
 
 
 
 
 -------------------------------------------
 --||   /¯\  /\ |¯\   ///¯¯\ /\ ||  |||¯¯]--
 --||_ | O ||  ||  | // \_¯\|  | \\// | ] --
 --|__] \_/ |||||_/ //  \__/||||  \/  |__]--
 -------------------------------------------
 
 function location()
  return
   { xdist, ydist, zdist, rdist,
     xmin, xmax, ymin, ymax, zmin, zmax,
     xlast, ylast, zlast, rlast,
     lastmove, dugtotal }
 end
 
 
 function saveCoords(loc,save)
  loc = loc or location()
  save = save or savefile
  local file,x
 
  --if fs.exists(save.."_old") then
  -- fs.delete(save.."_old")
  --end
  --if fs.exists(save) then
   --fs.move(save, save.."_old")
  --end
 
  while file == nil do
   file = fs.open(save,"w")
  end --while
 
  for x=1,#loc do
   file.writeLine(tostring(loc[x]))
   if x == 4 then file.flush() end
  end --for
 
  file.close()
 end --function
 
 
 
 function loadCoords(save)
  save = save or savefile
  local file
  if fs.exists(save) then
   while file == nil do
    file = fs.open(save,"r")
   end --while
   xdist = tonumber(file.readLine() or xdist)
   ydist = tonumber(file.readLine() or ydist)
   zdist = tonumber(file.readLine() or zdist)
   rdist = tonumber(file.readLine() or rdist)
   xmin = tonumber(file.readLine() or xmin)
   xmax = tonumber(file.readLine() or xmax)
   ymin = tonumber(file.readLine() or ymin)
   ymax = tonumber(file.readLine() or ymax)
   zmin = tonumber(file.readLine() or zmin)
   zmax = tonumber(file.readLine() or zmax)
   xlast = tonumber(file.readLine() or xlast)
   ylast = tonumber(file.readLine() or ylast)
   zlast = tonumber(file.readLine() or zlast)
   rlast = tonumber(file.readLine() or rlast)
   lastmove = file.readLine() or lastmove
   dugtotal = tonumber(file.readLine() or dugtotal)
   file.close()
   return true
 
  else
   --if fs.exists(save.."_old") then
   -- loadCoords(save.."_old")
   -- return true
   --end
 
   return false
  end --if/else
 
 end -- function
 
 
 
 function makeStartup(command, args)
  command = tostring(command)
  args = args or {}
  local x
  for x=1,#args do
   command = command.." "..args[x]
  end --for
 
  local file = fs.open(startfile,"w")
  file.writeLine("print(\"> "..command.."\")")
  file.writeLine("for x=5,1,-1 do")
  file.writeLine(" term.write(tostring(x)..\" \")")
  file.writeLine(" sleep(1)")
  file.writeLine("end --for")
  file.writeLine("print(\" \")")
  file.writeLine("shell.run(\""..command.."\")")
  file.close()
 end --function
 
 
 
 
 -------------------------------------
 --[¯¯]|¯\ /\  /¯]||//[¯¯]|\ || /¯¯]--
 -- || | /|  || [ | <  ][ | \ || [¯|--
 -- || | \|||| \_]||\\[__]|| \| \__|--
 -------------------------------------
 
 function update(n)
 
  if n=="fwd" then
 
   if rdist%360 == 0 then -- 12:00
    zdist = zdist + 1
    zlast = 1
    lastmove = "z+"
 
   elseif rdist%360 == 90 then -- 3:00
    xdist = xdist + 1
    xlast = 1
    lastmove = "x+"
 
   elseif rdist%360 == 180 then -- 6:00
    zdist = zdist - 1
    zlast = -1
    lastmove = "z-"
 
   elseif rdist%360 == 270 then -- 9:00
    xdist = xdist - 1
    xlast = -1
    lastmove = "x-"
 
   end --if/else
 
 
  elseif n=="back" then
 
   if rdist%360 == 0 then -- 12:00
    zdist = zdist - 1
    zlast = -1
    lastmove = "z-"
 
   elseif rdist%360 == 90 then -- 3:00
    xdist = xdist - 1
    xlast = -1
    lastmove = "x-"
 
   elseif rdist%360 == 180 then -- 6:00
    zdist = zdist + 1
    zlast = 1
    lastmove = "z+"
 
   elseif rdist%360 == 270 then -- 9:00
    xdist = xdist + 1
    xlast = 1
    lastmove = "x+"
 
   end --if/else
 
 
  elseif n=="up" then
   ydist = ydist + 1
   ylast = 1
   lastmove = "y+"
 
  elseif n=="down" then
   ydist = ydist - 1
   ylast = -1
   lastmove = "y-"
 
  elseif n=="right" then
   rdist = rdist + 90
   rlast = 1
   lastmove = "r+"
   while rdist > 999 do
    rdist = rdist - 360
   end --while
 
  elseif n=="left" then
   rdist = rdist - 90
   rlast = -1
   lastmove = "r-"
   while rdist < -999 do
    rdist = rdist + 360
   end --while
 
  end --if/else
 
 
  if xdist < xmin then
   xmin = xdist
  elseif xdist > xmax then
   xmax = xdist
  end
 
  if ydist < ymin then
   ymin = ydist
  elseif ydist > ymax then
   ymax = ydist
  end
 
  if zdist < zmin then
   zmin = zdist
  elseif zdist > zmax then
   zmax = zdist
  end
 
  saveCoords()
 
 end
 
 
 
 
 ------------------------------------------
 -- |\/| /¯\ ||  |||¯¯]|\/||¯¯]|\ ||[¯¯] --
 -- |  || O | \\// | ] |  || ] | \ | ||  --
 -- |||| \_/   \/  |__]|||||__]|| \| ||  --
 ------------------------------------------
 
 
 stuck = false
 function isStuck()
  return stuck
 end
 stuckDir = "none"
 function getStuckDir()
  return stuckDir
 end
 
 
 function left(n)
  n = (n or 1)
  if n < 0 then
   return right(-n)
  end --if
  local x
  for x=1,n do
   turtle.turnLeft()
   update("left")
  end --if
  return true
 end --function
 
 
 function right(n)
  n = (n or 1)
  if n < 0 then
   return left(-n)
  end --if
  local x
  for x=1,n do
   turtle.turnRight()
   update("right")
  end --if
  return true
 end --function
 
 
 
 local unbreak = "Unbreakable block detected"
 local protect = "Cannot break protected block"
 
 
 
 function up(n)
  n = n or 1
  if n < 0 then
   return down(-n)
  end --if
 
  local x,a,b,t
 
  for x=1, n do
   refuel()
 
   if not turtle.up() then
 
    if doblacklist then
     -- Blocks not to mine
     if flex.isBlockUp(options["blacklist"]) then
      if not back() then return false end
      if not up() then return false end
      return true
     end --if
    end --if
 
    t = os.time()
    stuck = false
    while not turtle.up() do
     a,b = turtle.digUp()
     while a do
      dugtotal = dugtotal + 1
      a,b = turtle.digUp()
     end --while
 
     if b == protect then
      if doblacklist then
       options["blacklist"][
          #options["blacklist"]+1]
          = flex.getBlockUp()
       return up(n-x+1)
      else
       b = unbreak
      end --if
     end --if
 
     if b == unbreak then
      flex.send("#1"..b.."#0: {#8"..
        tostring(getx()).."#0,#8"..
        tostring(gety()+1).."#0,#8"..
        tostring(getz()).."#0}")
      knownBedrock[#knownBedrock+1] = {
        getx(), gety()+1, getz() }
      stuck = true
      stuckDir = "up"
      return false
     end --if
     if a then
      dugtotal = dugtotal + 1
     end --if
     if attack then turtle.attackUp() end
 
     if (os.time()-t)/24*20*60 > 20 then
      -- Stuck for at least 20 seconds
      -- Usually caused by height limits
      flex.send("Unable to move up",colors.orange)
      stuck = true
      stuckDir = "up"
      return false
     end --if
 
    end --while
 
   end --if can't move
 
   update("up")
  end --for
 
  return true
 end --function
 
 
 
 function down(n)
  n = n or 1
  if n < 0 then
   return up(-n)
  end --if
 
  local x,a,b,t
 
  for x=1, n do
   refuel()
 
   if not turtle.down() then
 
    if doblacklist then
     -- Blocks not to mine
     if flex.isBlockDown(options["blacklist"]) then
      if not fwd() then return false end
      if not down() then return false end
      return true
     end --if
    end --if
 
    t = os.time()
    stuck = false
    while not turtle.down() do
     a,b = turtle.digDown()
     while a do
      dugtotal = dugtotal + 1
      a,b = turtle.digDown()
     end --while
 
     if b == protect then
      if doblacklist then
       options["blacklist"][
         #options["blacklist"]+1 ]
         = flex.getBlockDown()
       return down(n-x+1)
      else
       b = unbreak
      end --if
     end --if
 
     if b == unbreak then
      flex.send("#1"..b.."#0: {#8"..
        tostring(getx()).."#0,#8"..
        tostring(gety()-1).."#0,#8"..
        tostring(getz()).."#0}")
      knownBedrock[#knownBedrock+1] = {
        getx(), gety()-1, getz() }
      stuck = true
      stuckDir = "down"
      return false
     end --if
     if a then
      dugtotal = dugtotal + 1
     end --if
     if attack then turtle.attackDown() end
 
     if (os.time()-t)/24*20*60 > 20 then
      -- Stuck for at least 20 seconds
      -- Usually caused by height limits
      flex.send("Unable to move down",colors.orange)
      stuck = true
      stuckDir = "down"
      return false
     end --if
 
    end --while
 
   end --if can't move
 
   update("down")
  end --for
 
  return true
 end --function
 
 
 
 function fwd(n)
  n = n or 1
  if n < 0 then
   return back(-n)
  end --if
 
  local x,z,a,b,t
  for x=1, n do
   refuel()
 
   if not turtle.forward() then
 
    if doblacklist then
     -- Blocks not to mine
     if flex.isBlock(options["blacklist"]) then
      if flex.isBlockUp(options["blacklist"]) then
       if flex.isBlockDown(options["blacklist"]) then
 
        -- Blocks above, below and in front
        if not back() then return false end
        if not up(2) then return false end
        if not fwd(2) then return false end
        if not down(2) then return false end
        return true
 
       else -- Blocks in front and above
        if not down() then return false end
        x = 0
        while flex.isBlock(options["blacklist"]) do
         x = x + 1
         if not down() then return false end
        end --while
        if not fwd(2) then return false end
        if not up(x) then return false end
        return
       end --if/else
 
      else
       -- Block in front
       if not up() then return false end
       if not fwd(2) then return false end
       if not down() then return false end
       return true
      end --if/else
     end --if
    end --if doblacklist
 
    t = os.time()
    stuck = false
    while not turtle.forward() do
     a,b = turtle.dig()
     while a do
      dugtotal = dugtotal + 1
      a,b = turtle.dig()
     end --while
 
     if b == protect then
      if doblacklist then
       options["blacklist"][
           #options["blacklist"]+1]
           = flex.getBlock()
       return fwd(n-x+1)
      else
       b = unbreak
      end --if
     end --if
 
     if b == unbreak then
      z = { getx(), gety(),
            getz(), getr()%360 }
 
      if z[4] == 0 then
       z[3] = z[3] + 1
      elseif z[4] == 90 then
       z[1] = z[1] + 1
      elseif z[4] == 180 then
       z[3] = z[3] - 1
      elseif z[4] == 270 then
       z[1] = z[1] - 1
      end --if/else
 
      flex.send("#1"..b.."#0: {#8"..
        tostring(z[1]).."#0,#8"..
        tostring(z[2]).."#0,#8"..
        tostring(z[3]).."#0}")
      knownBedrock[#knownBedrock+1] =
        { z[1], z[2], z[3] }
      stuck = true
      stuckDir = "fwd"
      return false
     end --if
 
     if a then
      dugtotal = dugtotal + 1
     end --if
     if attack then turtle.attack() end
 
     --if (os.time()-t)/24*20*60 > 120 then
      -- Stuck for at least 20 seconds
      --flex.send("Unable to move forward",colors.orange)
      --stuck = true
      --stuckDir = "fwd"
      --return false
      --t = os.time()
     --end --if
 
    end --while not turtle.forward()
 
   end --if can't move
 
   update("fwd")
  end --if
 
  return true
 end --function
 
 
 
 function back(n)
  n = n or 1
  if n < 0 then
   return fwd(-n)
  end --if
 
  local x,turn
  turn = false
  for x=1,n do
   if turn then
    if not fwd() then return false end
   elseif turtle.back() then
    update("back")
   else
    turn = true
    gotor(rdist+180)
    if not fwd() then return false end
   end --if/else
  end --for
 
  if turn then gotor(rdist-180) end
  return true
 end --function
 
 
 
 function dig(x)
  local a,b
  x = x or "fwd"
 
  if x=="fwd" then
   while turtle.dig() and not stuck do
    dugtotal = dugtotal + 1
   end --while
 
  elseif x=="up" then
   while turtle.digUp() and not stuck do
    dugtotal = dugtotal + 1
   end --while
 
  elseif x=="down" then
   while turtle.digDown() and not stuck do
    dugtotal = dugtotal + 1
   end --while
 
  end --if/else
 end --function
 
 function digUp() dig("up") end
 function digDown() dig("down") end
 
 
 
 -- Agressive placement functions
 
 function place()
  local x = flex.getBlock("fwd")
  local t = os.time()
  while not turtle.place()
        and flex.isBlock(options["fluids"]) do
   if attack then
    turtle.attackUp()
    turtle.attack()
    turtle.attackDown()
   end --if
 
   if (os.time()-t)/24*20*60 > 20 then
    local z = { getx(), gety(),
          getz(), getr()%360 }
    if z[4] == 0 then
     z[3] = z[3] + 1
    elseif z[4] == 90 then
     z[1] = z[1] + 1
    elseif z[4] == 180 then
     z[3] = z[3] - 1
    elseif z[4] == 270 then
     z[1] = z[1] - 1
    end --if/else
 
    flex.send("#1End of world detected#0: {#8"..
      tostring(z[1]).."#0,#8"..
      tostring(z[2]).."#0,#8"..
      tostring(z[3]).."#0}")
    knownBedrock[#knownBedrock+1] =
      { z[1], z[2], z[3] }
 
    stuck = true
    stuckDir = "fwd"
    return false
   end --if
 
   sleep(0.1)
   x = flex.getBlock()
  end --while
  if turtle.getSelectedSlot() == blockSlot then
   checkBlocks()
  end --if
  return true
 end --function
 
 
 function placeUp()
  local x = flex.getBlockUp()
  local t = os.time()
  while not turtle.placeUp()
        and flex.isBlockUp(options["fluids"]) do
   if attack then
    turtle.attack()
    turtle.attackUp()
   end --if
 
   if (os.time()-t)/24*20*60 > 20 then
    flex.send("#1Edge of world detected#0: {#8"..
      tostring(getx()).."#0,#8"..
      tostring(gety()+1).."#0,#8"..
      tostring(getz()).."#0}")
    knownBedrock[#knownBedrock+1] = {
      getx(), gety()+1, getz() }
 
    stuck = true
    stuckDir = "up"
    return false
   end --if
 
   sleep(0.1)
   x = flex.getBlockUp()
  end --while
  if turtle.getSelectedSlot == blockSlot then
   checkBlocks()
  end --if
  return true
 end --function
 
 
 function placeDown()
  local x = flex.getBlockDown()
  local t = os.time()
  while not turtle.placeDown()
        and flex.isBlockDown(options["fluids"]) do
   if attack then
    turtle.attack()
    turtle.attackDown()
   end --if
 
   if (os.time()-t)/24*20*60 > 20 then
    flex.send("#1Edge of world detected#0: {#8"..
      tostring(getx()).."#0,#8"..
      tostring(gety()-1).."#0,#8"..
      tostring(getz()).."#0}")
    knownBedrock[#knownBedrock+1] = {
      getx(), gety()-1, getz() }
    up()
    placeDown()
    ymin = gety()
 
    stuck = true
    stuckDir = "down"
    return false
   end --if
 
   sleep(0.1)
   x = flex.getBlockDown()
  end --while
  if turtle.getSelectedSlot() == blockSlot then
   checkBlocks()
  end --if
  return true
 end --function
 
 
 
 
 ----------------------------
 --  /¯¯]  /¯\  [¯¯]  /¯\  --
 -- | [¯| | O |  ||  | O | --
 --  \__|  \_/   ||   \_/  --
 ----------------------------
 
 
 function gotor(r)
  if r == nil then
   error("Number expected, got nil", 2)
   return
  end --if
  local x = (r-rdist)%360
  -- X is the target direction relative to current rotation
 
  if x == 90 then
   right()
  elseif x == 180 then
   left(rlast*2)
   -- Rotate opposite to last rotation
  elseif x == 270 then
   left()
  elseif x ~= 0 then
   error("Invalid rotation parameter", 2)
   return false
  end --if/else
 
  return true
 end --function
 
 
 
 function gotoy(y)
  if y == nil then
   error("Number expected, got nil", 2)
   return
  end --if
 
  while ydist < y do
   if not up() then return false end
  end
  while ydist > y do
   if not down() then return false end
  end
  return true
 end
 
 
 function gotox(x)
  if x == nil then
   error("Number expected, got nil", 2)
   return
  end --if
 
  if xdist < x then
   if rdist == 270 then
    return back(x-xdist)
 
   else
    gotor(90)
    return fwd(x-xdist)
   end
  end
 
  if xdist > x then
   if rdist == 90 then
    return back(xdist-x)
 
   else
    gotor(270)
    return fwd(xdist-x)
   end
  end
 
  return true
 end
 
 
 function gotoz(z)
  if z == nil then
   error("Number expected, got nil", 2)
   return
  end --if
 
  if zdist < z then
   if rdist == 180 then
    return back(z-zdist)
 
   else
    gotor(0)
    return fwd(z-zdist)
   end
  end
 
  if zdist > z then
   if rdist == 0 then
    return back(zdist-z)
 
   else
    gotor(180)
    return fwd(zdist-z)
   end
  end
 
  return true
 end
 
 
 function goto(x,y,z,r,lm)
  if type(x) == "table" then
   if #x < 4 then
    error("Invalid Goto Table",2)
   end
   y = x[2]
   z = x[3]
   r = x[4]
   lm = x[15]
   x = x[1]
  end
  gotox(x or 0)
  gotoz(z or 0)
  gotor(r or 0)
  gotoy(y or 0)
  if lm~=nil then setlast(lm) end
 end
 
 
 
 
 ---------------------------------------
 -- |¯¯]|| |||¯¯]||    |¯\|¯\ /¯\     --
 -- | ] ||_||| ] ||_   | /| /| O | == --
 -- ||   \__||__]|__]  || | \ \_/     --
 ---------------------------------------
 --   /¯]|¯¯]/¯¯\/¯¯\[¯¯]|\ || /¯¯]   --
 --  | [ | ] \_¯\\_¯\ ][ | \ || [¯|   --
 --   \_]|__]\__/\__/[__]|| \| \__|   --
 ---------------------------------------
 
 fuelSlot = {1,16}
 
 function getFuelSlot()
  return fuelSlot[1],fuelSlot[2]
 end --function
 
 function setFuelSlot(a,b)
  if a == nil then
   return false
  end --if
  b = b or a
  if a < b then
   fuelSlot = {a,b}
  else
   fuelSlot = {b,a}
  end --if/else
  return true
 end --function
 
 
 
 function refuel(b)
  b = b or 1
  b = math.min(b, turtle.getFuelLimit())
  local a,x,z,slot
  slot = turtle.getSelectedSlot()
  a = true
 
  while turtle.getFuelLevel() < b do
   for x=fuelSlot[1],fuelSlot[2] do
    turtle.select(x)
    if turtle.refuel(1) then break end
    if x == fuelSlot[2] and a then
     if fuelSlot[1] == fuelSlot[2] then
 	    flex.send("Waiting for fuel in "..
 	      "slot "..tostring(fuelSlot[1])..
 	      "...", colors.pink)
    	else
      flex.send("Waiting for fuel in "..
        "slots "..tostring(fuelSlot[1])..
        "-"..tostring(fuelSlot[2])..
        "...", colors.pink)
    	end --if/else
     a = false
    end --if
   end --for
  end --while
 
  if not a then
   flex.send("Thanks!",colors.lime)
  end --if
  turtle.select(slot)
 
 end --function
 
 
 
 
 local fuelvalue = {}
 local fuelfile = "dig_fuel.cfg"
 local file, line
 if fs.exists(fuelfile) then
  file = fs.open(fuelfile, "r")
  line = file.readLine()
  while line ~= nil do
   fuelvalue[line] = tonumber(file.readLine())
   line = file.readLine()
  end --while
  file.close()
 else
  file = fs.open(fuelfile, "w")
  file.close()
 end --if/else
 
 
 function checkFuelValue(x)
  if type(x) ~= "number" then
   local x = turtle.getSelectedSlot()
  end --if
  if turtle.getItemCount(x) == 0 then
   return 0
  end --if
 
  local a,b,c,d
  a = turtle.getItemDetail(x)["name"]
  b = fuelvalue[a]
 
  if b == nil then
   c = turtle.getFuelLevel()
   turtle.select(x)
   turtle.refuel(1)
   d = turtle.getFuelLevel() - c
   fuelvalue[a] = d
 
   file = fs.open(fuelfile, "a")
   file.writeLine(a)
   file.writeLine(tostring(d))
   file.close()
 
   if turtle.getItemCount(x) == 0 then
    return 0
   else
    return d
   end --if
  end --if
 
  return b
 end --function
 
 
 
 
 blockSlot = 0
 blockStacks = 1
 function getBlockSlot() return blockSlot end
 function setBlockSlot(n) blockSlot = n end
 function getBlockStacks() return blockStacks end
 function setBlockStacks(n) blockStacks = n end
 
 
 function checkBlocks()
  if blockSlot == 0 then return end
  local x,docondense
 
  if not flex.isItem(options["buildingblocks"],blockSlot) then
   if turtle.getItemCount(blockSlot) > 0 then
    for x=blockSlot+1,16 do
     if turtle.getItemCount(x) == 0 then
      turtle.select(blockSlot)
      turtle.transferTo(x)
      break
     end --if
    end --for
   end --if
  end --if
 
  if turtle.getItemCount(blockSlot) == 0 then
   for x=1,16 do
    if flex.isItem(options["buildingblocks"],x) then
     turtle.select(x)
     turtle.transferTo(blockSlot)
     turtle.select(blockSlot)
    	break
    end --if
   end --for
  flex.condense(blockSlot)
  end --if
 
  turtle.select(blockSlot)
 end --function
 
 
 
 function blockLava(dir)
  if not flex.isBlock("lava",dir) then
   return
  end --if
  local slot = turtle.getSelectedSlot()
  checkBlocks()
  turtle.select(blockSlot)
  if dir == "up" then
   turtle.placeUp()
  elseif dir == "down" then
   turtle.placeDown()
  else
   turtle.place()
  end --if/else
  turtle.select(slot)
 end --function
 
 function blockLavaUp() blockLava("up") end
 function blockLavaDown() blockLava("down") end
 
 
 
 
 -- Organize Inventory/Fuel
 --   C
 --  CTQQQ
 --   QQQQ
 -- (Chest/Turtle/Quarry)
 
 function dropNotFuel()
 
  local slot = turtle.getSelectedSlot()
  local a,b,c,f,x,y,z
  local crafty,usedbucketalready,blocksPresent
  turtle.select(1)
  if turtle.getItemCount(1) > 1 then
   flex.condense()
  end --if
 
  -- Check there's inventory to place loot
  a = true
  while true do
   if isChest() then
    break
   end
   if a then
    flex.send("Output inventory not found!",
      colors.red)
    a = false
   end --if
   sleep(1)
  end --while
  if not a then
   flex.send("Thanks!",colors.lightBlue)
  end --if
 
 
  -- Drop off what's not fuel
  blocksPresent = blockStacks
  for x=1,16 do
   turtle.select(x)
   if not turtle.refuel(0) then
    if flex.isItem(options["buildingblocks"]) then
     if blocksPresent <= 0 then
      turtle.drop()
     else
      blocksPresent = blocksPresent - 1
     end --if/else
    else
     turtle.drop()
    end --if/else
   end --if
  end --for
  checkBlocks()
  turtle.select(1)
  -- Retrieve surplus fuel from fuel chest
  while turtle.suckUp() do sleep(0) end
  if turtle.getItemCount(fuelSlot[1]) > 0 then
   flex.condense()
  end --if
 
 
  -- Craft coal into blocks
  if peripheral.find("workbench") and isChestUp() then
 
   z = 0
   for x=1,16 do
    if turtle.getItemCount(x) > 0 and
       turtle.getItemDetail(x)["name"]
       ~= "minecraft:coal" then
     turtle.select(x)
     turtle.dropUp()
    end --if
    z = z + turtle.getItemCount(x)
   end --for
 
   if z >= 9 then
 
    y = 13
    for x=1,12 do
     turtle.select(x)
     while turtle.getItemCount(x) > 0 do
      if y <= 16 then
       turtle.transferTo(y)
      else
       z = z - turtle.getItemCount(x)
       turtle.dropUp()
      end --if/else
      if turtle.getItemCount(x) > 0 then
       y = y + 1
      end --if
     end --while
    end --for
 
    y = math.floor(z/9)
    turtle.select(13)
    turtle.dropUp(z%9)
    a = 13
    b = { 1, 2, 3, 5, 6, 7, 9, 10, 11 }
    for x=1,#b do
     if turtle.getItemCount(a) < y then
      turtle.select(a+1)
      turtle.transferTo(a,
        y - turtle.getItemCount(a))
     end --if
     turtle.select(a)
     turtle.transferTo(b[x], y)
     if turtle.getItemCount(a) == 0 then
      a = a + 1
     end --if
    end --for
 
    if peripheral.getType("left") == "workbench" then
     crafty = peripheral.wrap("left")
    else
     crafty = peripheral.wrap("right")
    end --if/else
    turtle.select(1)
    crafty.craft()
 
   end --if
   while turtle.suckUp() do sleep(0) end
   checkBlocks()
 
  end --if
 
 
  --Tally up fuel sources
  z = {} -- slot #
  f = {} -- amount of fuel
  usedbucketalready = false
 
  for x=1,16 do
   turtle.select(x)
 
   if turtle.refuel(0) then
    y = turtle.getItemCount()
 
    if flex.isItem("bucket") and y==1 then
     if not usedbucketalready then
      -- Only use buckets one at a time
      turtle.refuel()
      usedbucketalready = true
      turtle.drop()
     end
 
    else -- Not a bucket
     a = checkFuelValue(x)
     if a > 0 then
      z[#z+1] = x
      f[#z] = a*turtle.getItemCount(x)
     end --if
 
    end --if/else (is bucket)
 
   end --if (is fuel)
  end --for (slots)
 
 
  -- Choose best fuel available
  a = 0
  for x=1, #f do
   a = math.max(a,f[x])
  end --for
  for x=1, #f do
   if f[x] == a then
    if z[x] > 1 then
     for b=2,16 do
      if turtle.getItemCount(b) == 0 then
       turtle.select(1)
       turtle.transferTo(b)
       break
      end --if
     end --for
     turtle.select(z[x])
     turtle.transferTo(1)
    end --if
    break
   end --if
  end --for
 
 
  -- Deposit surplus fuel
  for x=fuelSlot[1]+1,16 do
   if turtle.getItemCount(x) > 0 then
 
    turtle.select(x)
    if turtle.refuel(0) then
     if isChestUp() then
      -- Place in fuel chest
      turtle.dropUp()
     end --if
     if turtle.getItemCount() > 0 then
      -- Fuel chest is full or absent
      turtle.drop()
     end --if
    end --if
 
   end --if (more than zero items)
  end --for (all slots after fuel slot)
 
  turtle.select(fuelSlot[1])
  if not turtle.refuel(0) then
   for x=fuelSlot[1]+1,16 do
    turtle.transferTo(x)
    if turtle.getItemCount() == 0 then
     break
    end --if
   end --for
  end --if
 
  flex.condense(fuelSlot[1]+1)
 
  if turtle.getItemCount(16) > 0 then
   flex.send("Inventory full!",colors.red)
   turtle.select(16)
   while not turtle.drop() do sleep(5) end
   flex.send("Inventory has room!",colors.lightBlue)
   turtle.select(slot)
   return dropNotFuel()
  end --if
 
  turtle.select(slot)
 
 end --function dropNotFuel()