View difference between Paste ID: fqKbjaqa and 9UHMNvAe

 -- --------------------------------------------------------------------------------------- --
 -- START OF THE DEFAULT CONFIG OF THIS PROGRAM, THOUGH COMMAND LINE PARAMETERS CAN BE USED --
 -- FOR THE DIRECTION PARAMETERS USE up/down/left/right/forward/back                        --
 -- --------------------------------------------------------------------------------------- --
 
 args={...}
 
 local configuration={}
 
 -- THE NUMBER OF LEVELS
 configuration.numL = 1
 
 -- THE NUMBER OF TUNNELS
 configuration.numT = 4
 
 -- THE NUMBER OF SHAFTS TO EXCAVATE
-configuration.numS = 16
+configuration.numS = 21
 
 -- HOW MANY LEVELS TO SKIP
 configuration.skipL = 0
 
 -- HOW MANY TUNNELS TO SKIP
 configuration.skipT = 0
 
 -- HOW MANY SHAFTS TO SKIP
 configuration.skipS = 0
 
 -- THE DIRECTION OF THE NEXT LEVEL (UP or DOWN)
 configuration.nextDirL = "up"
 
 -- THE DIRECTION OF THE NEXT TUNNEL (LEFT or RIGHT)
 configuration.nextDirT = "left"
 
 -- THE HEIGHT OF THE LEVELS/TUNNELS
 configuration.height = 3
 
 -- THE NUMBER OF BLOCKS BETWEEN EACH SHAFT
-configuration.blocksBetweenShafts = 3
+configuration.blocksBetweenShafts = 2
 
 -- HOW MANY BLOCKS WILL THE TURTLE MOVE BEFORE DIGGING THE FIRST SHAFT
 configuration.firstShaftOffset = 4
 
 -- THE NUMBER OF BLOCKS THE EVEN LEVEL SHAFTS WILL BE OFFSET
 configuration.evenLevelOffset = 2
 
 -- DOES THE TURTLE ALSO PLACE TORCHES
 configuration.placeTorches = false
 
 -- IS THERE A SINGLE DROPOFF CHEST (true) OR ONE PER DIRECTION, PER LEVEL (false)
 configuration.singleChest = false
 
 -- THE RADIUS OF THE CIRCLE ON WHICH THE REFUELING STATIONS ARE POSITIONED
 configuration.centerRadius = 5
 
 -- THE NUMBER OF BLOCK TYPES THE TURTLE WILL _NOT_ DIG UNLESS NEEDED
 -- DEFAULT CONSIDERS: Smooth stone, Dirt, Gravel, Marble (Tekkit), Wood, stone bricks
-configuration.numIgnoreBlocks = 6
+configuration.numIgnoreBlocks = 4
 
 -- DOES THE TURTLE REQUIRE FUEL TO OPERATE?
-configuration.requiresFuel = true
+configuration.requiresFuel = false
 
 -- THE AMOUNT OF FUEL THE TURTLE WILL STORE BEFORE HEADING OF TO A SHAFT
 configuration.departureFuel = 1200
 
 -- THE AMOUNT OF FUEL AT WHICH THE TURTLE WILL RETURN TO DROPOFF
 configuration.returnFuel = 200
 
 -- THE DIRECTION OF THE FUEL ITEMS (IN THE REFUELING STATION)
 configuration.fuelSuckDir = "up"
 
 -- THE DIRECTION WHERE THE TURTLE WILL DROP LEFTOVERS (BUCKETS)
 configuration.fuelDropDir = "down"
 
 -- THE DIRECTION WHERE THE TURTLE WILL DROP ANY MINED ITEMS
 configuration.itemDropDir = "down"
 
 -- THE DIRECTION OF THE TORCHES
 configuration.torchSuckDir = "right"
 
 -- THE DIRECTION OF THE IGNORE BLOCKS
 configuration.ignoreDir = "left"
 
 -- USED TO KEEP TRACK OF THE POSITION OF THE TUNNEL
 configuration.currentL = 1
 configuration.currentT = 1
 configuration.currentS = 0
 
 -- ------------------------------------------------------------------------------------- --
 -- END OF THE DEFAULT CONFIG OF THIS PROGRAM, THOUGH COMMAND LINE PARAMETERS CAN BE USED --
 -- FOR THE DIRECTION PARAMETERS USE up/down/left/right/forward/back                      --
 -- ------------------------------------------------------------------------------------- --
 
 -- -------------------------------------------------- --
 -- START OF THE PARSING OF THE COMMAND LINE ARGUMENTS --
 -- -------------------------------------------------- --
 
 -- PRINTS THE MANUAL TO THE TERMINAL IN CASE THE USER SPECIFIED INCORRECT VALUES
 function printManual()
   term.clear()
   print("Usage: digOres [OPTIONS] (1/3)")
   print("------------------------------")
   print(" -numL <num>     (=nr. of levels)")
   print(" -numT <num>     (=nr. of tunnels)")
   print(" -numS <num>     (=nr. of shafts)")
   print(" -skipL <num>    (=skip # levels)")
   print(" -skipT <num>    (=skip # tunnels)")
   print(" -skipS <num>    (=skip # shafts)")
   print(" -dirNextL <dir> (=next lev. U/D)")
   print(" -dirNextT <dir> (=next tun. L/R)")
   print("PRESS ANY KEY TO CONTINUE")
   print("")
   read()
   term.clear()
   print("Usage: digOres [OPTIONS] (2/3)")
   print("------------------------------")
   print(" -height <num>   (=level height 2/3)")
   print(" -betw <num>     (=blocks betw shafts)")
   print(" -firstOffs <num>(=first shaft offset)")
   print(" -evenOffs <num> (=even level offset)")
   print(" -torches        (=place torches)")
   print(" -oneChest       (=single drop chest)")
   print(" -rad <num>      (=center radius)")
   print(" -numIgnore <num>(=num ignore blocks)")
   print("PRESS ANY KEY TO CONTINUE")
   print("")
   read()
   term.clear()
   print("Usage: digOres [OPTIONS] (3/3)")
   print("------------------------------")
   print(" -noFuel         (=no need for fuel)")
   print(" -depFuel <num>  (=departure fuel)")
   print(" -retFuel <num>  (=return fuel)")
   print(" -fuelS <dir>    (=fuel suck dir)")
   print(" -fuelD <dir>    (=fuel drop dir)")
   print(" -torchS <dir>   (=torch suck dir)")
   print(" -itemD <dir>    (=item drop dir)")
   print(" -ignoreS <dir>  (=ignore block dir)")
   print("")
   print("")
 end
 
 -- PRINTS THE POSSIBLE DIRECTION VALUES TO THE TERMINAL
 function printDirs()
   term.clear()
   print("Invalid direction chosen: pick from:")
   print("------------------------------------")
   print(" up")
   print(" down")
   print(" forward")
   print(" back")
   print(" right")
   print(" left")
   print("")
   print("")
   print("")
   print("")
 end
 
 -- CHECKS IF A STRING DENOTES A DIRECTION
 function isDir(dir)
   if dir=="forward" or dir=="back" or dir=="left" or dir=="right" or dir=="up" or dir=="down" then
     return true
   end
   return false
 end
 
 -- READS IN THE COMMAND LINE ARGUMENTS AND PARSES THEM
 readParams = 0
 while readParams < #args do
   if args[readParams+1] == "-numL" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.numL=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-numT" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.numT=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-numS" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.numS=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-skipL" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.skipL=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-skipT" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.skipT=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-skipS" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.skipS=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-dirNextL" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     if not isDir(args[readParams+2]) then
       printDirs()
       return
     end
     configuration.nextDirL=args[readParams+2]
     readParams=readParams+2
 
   elseif args[readParams+1] == "-dirNextT" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     if not isDir(args[readParams+2]) then
       printDirs()
       return
     end
     configuration.nextDirT=args[readParams+2]
     readParams=readParams+2
 
   elseif args[readParams+1] == "-height" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.height=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-betw" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.blocksBetweenShafts=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-firstOffs" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.firstShaftOffset=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-evenOffs" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.evenLevelOffset=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-torches" then
     configuration.placeTorches=true
     readParams=readParams+1
 
   elseif args[readParams+1] == "-oneChest" then
     configuration.singleChest=true
     readParams=readParams+1
 
   elseif args[readParams+1] == "-rad" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.centerRadius=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-numIgnore" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.numIgnoreBlocks=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-noFuel" then
     configuration.requiresFuel=false
     readParams=readParams+1
 
   elseif args[readParams+1] == "-depFuel" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.departureFuel=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-retFuel" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     configuration.returnFuel=tonumber(args[readParams+2])
     readParams=readParams+2
 
   elseif args[readParams+1] == "-fuelS" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     if not isDir(args[readParams+2]) then
       printDirs()
       return
     end
     configuration.fuelSuckDir=args[readParams+2]
     readParams=readParams+2
 
   elseif args[readParams+1] == "-fuelD" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     if not isDir(args[readParams+2]) then
       printDirs()
       return
     end
     configuration.fuelDropDir=args[readParams+2]
     readParams=readParams+2
 
   elseif args[readParams+1] == "-torchS" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     if not isDir(args[readParams+2]) then
       printDirs()
       return
     end
     configuration.torchSuckDir=args[readParams+2]
     readParams=readParams+2
 
   elseif args[readParams+1] == "-itemD" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     if not isDir(args[readParams+2]) then
       printDirs()
       return
     end
     configuration.itemDropDir=args[readParams+2]
     readParams=readParams+2
 
   elseif args[readParams+1] == "-ignoreS" then
     if not (readParams + 1 < #args) then
       printManual()
       return
     end
     if not isDir(args[readParams+2]) then
       printDirs()
       return
     end
     configuration.ignoreDir=args[readParams+2]
     readParams=readParams+2
 
   else
     printManual()
     return
   end
 end
 
 -- ------------------------------------------------ --
 -- END OF THE PARSING OF THE COMMAND LINE ARGUMENTS --
 -- ------------------------------------------------ --
 
 -- ---------------------------------------------------------------------- --
 -- START OF COPY/PASTED CODE EXTENDING THE FUNCTIONALITY OF THE BASIC API --
 -- SOME OF THESE FUNCTIONS MIGHT BE REDUNDANT FOR THIS PROGRAM            --
 -- ---------------------------------------------------------------------- --
 
 up = "up"
 down = "down"
 forward = "forward"
 back  = "back"
 right = "right"
 left = "left"
 
 -- ALIGNS THE TURTLE TO MOVE, DIG, ... IN A CERTAIN DIRECTION
 function turnTo(dir)
   if dir==back then
     turtle.turnLeft()
     turtle.turnLeft()
   elseif dir==right then
     turtle.turnRight()
   elseif dir==left then
     turtle.turnLeft()
   end
 end
 
 -- REALIGNS THE TURTLE TO THE ORIGINAL DIRECTION
 function turnFrom(dir)
   if dir==back then
     turtle.turnLeft()
     turtle.turnLeft()
   elseif dir==right then
     turtle.turnLeft()
   elseif dir==left then
     turtle.turnRight()
   end
 end
 
 -- RETURNS THE DIRECTION THE TURTLE SHOULD MOVE, DIG, ... AFTER THE PREVIOUS ALIGNMENT
 function turnedDir(dir)
   if dir==right or dir==left or dir==back then
     return forward
   else
     return dir
   end
 end
 
 -- RETURNS THE REVERSE DIRECTION SO UP BECOMES DOWN ETC
 function reverseDir(dir)
   if dir==forward then
     return back
   elseif dir==back then
     return forward
   elseif dir==up then
     return down
   elseif dir==down then
     return up
   elseif dir==right then
     return left
   elseif dir==left then
     return right
   end
 end
 
 -- RETURNS THE DIRECTION USED BY THE PERIPHERAL FUNCTIONS
 function peripheralDir(dir)
   if dir==forward then
     return "front"
   elseif dir==up then
     return "top"
   elseif dir==down then
     return "bottom"
   end
 end
 
 -- MOVES THE TURTLE A CERTAIN DISTANCE IN A CERTAIN DIRECTION
 -- IF NO DISTANCE IS SPECIFIED IT WILL JUST MOVE 1 STEP
 function move(dir, steps)
   steps = steps or 1
   local stepsTaken = 0
   turnTo(dir)
   local tDir=turnedDir(dir)
   for i=1,steps,1 do
     local tries=0
     local success=false
     while ((not success) and (tries<10)) do
       if tDir==forward then
         success=turtle.forward()
       elseif tDir==up then
         success=turtle.up()
       elseif tDir==down then
         success=turtle.down()
       end
       if success then
         break
       end
       attack(tDir)
       tries = tries+1
       sleep(0.5)
     end
     if not success then
       break
     end
     stepsTaken=stepsTaken+1
   end
   turnFrom(dir)
   return stepsTaken
 end
 
 -- DIGS IN A CERTAIN DIRECTION
 function dig(dir)
   turnTo(dir)
   local tDir=turnedDir(dir)
   local tries=0
   local success=false
   if not (peripheral.getType(peripheralDir(tDir))=="turtle") then
     while ((detect(tDir)) and (tries<10)) do
       if tDir==forward then
         success=turtle.dig()
       elseif tDir==up then
         success=turtle.digUp()
       elseif tDir==down then
         success=turtle.digDown()
       end
       if not success then
         tries = tries+1
       end
       sleep(0.5)
     end
   end
   turnFrom(dir)
   return success
 end
 
 -- DIGS AND MOVES A CERTAIN DISTANCE IN A CERTAIN DIRECTION
 -- IF NO DISTANCE IS SPECIFIED IT WILL JUST MOVE 1 STEP
 function digAndMove(dir, steps)
   steps = steps or 1
   local stepsTaken = 0
   turnTo(dir)
   local tDir=turnedDir(dir)
   for i=1,steps,1 do
     dig(tDir)
     local success=move(tDir)
     if success==0 then
       turnFrom(dir)
       return stepsTaken
     end
     stepsTaken=stepsTaken+1
   end
   turnFrom(dir)
   return stepsTaken
 end
 
 -- ATTACKS IN A CERTAIN DIRECTION
 function attack(dir)
   turnTo(dir)
   local tDir=turnedDir(dir)
   while turtle.attack(tDir) do
     sleep(0.3)
   end
   turnFrom(dir)
 end
 
 -- PLACES A BLOCK FROM A CERTAIN SLOT IN A CERTAIN DIRECTION
 function place(dir, slot)
   turtle.select(slot)
   turnTo(dir)
   local tDir=turnedDir(dir)
   if tDir==forward then
     turtle.place()
   elseif tDir==up then
     turtle.placeUp()
   elseif tDir==down then
     turtle.placeDown()
   end
   turnFrom(dir)
 end
 
 -- DETECTS IF THERE IS A BLOCK IN A CERTAIN DIRECTION
 function detect(dir)
   local block = false
   turnTo(dir)
   local tDir=turnedDir(dir)
   if tDir==forward then
     block = turtle.detect()
   elseif tDir==up then
     block = turtle.detectUp()
   elseif tDir==down then
     block = turtle.detectDown()
   end
   turnFrom(dir)
   return block
 end
 
 -- COMPARES A BLOCK IN A CERTAIN DIRECTION TO THE BLOCK IN A CERTAIN INVENTORY SLOT
 function compare(dir, slot)
   local same = false
   turtle.select(slot)
   turnTo(dir)
   local tDir=turnedDir(dir)
   if tDir==forward then
     same = turtle.compare()
   elseif tDir==up then
     same = turtle.compareUp()
   elseif tDir==down then
     same = turtle.compareDown()
   end
   turnFrom(dir)
   return same
 end
 
 -- COMPARES A BLOCK IN A CERTAIN DIRECTION TO A CERTAIN INVENTORY SLOT
 -- IF IT MATCHES THE BLOCK WILL BE REPLACED BY A BLOCK IN THE SPECIFIED SLOT
 function compareAndReplace(dir, compareSlot, replaceSlot)
   local replaced = false
   turnTo(dir)
   local tDir=turnedDir(dir)
   if not compare(tDir, compareSlot) then
     replaced = true
     dig(tDir)
     place(tDir, replaceSlot)
   end
   turnFrom(dir)
   return replaced
 end
 
 -- DROPS A CERTAIN NUMBER OF ITEMS IN A CERTAIN DIRECTION
 -- IF NO NUMBER IS SPECIFIED IT WILL DROP ALL THE ITEMS
 function drop(dir, num)
   turnTo(dir)
   local tDir=turnedDir(dir)
   if num == null then
     if tDir==forward then
       turtle.drop()
     elseif tDir==up then
       turtle.dropUp()
     elseif tDir==down then
       turtle.dropDown()
     end
   else
     if tDir==forward then
       turtle.drop(num)
     elseif tDir==up then
       turtle.dropUp(num)
     elseif tDir==down then
       turtle.dropDown(num)
     end
   end
   turnFrom(dir)
 end
 
 -- SUCKS UP ITEMS FROM A CERTAIN DIRECTION
 function suck(dir)
   turnTo(dir)
   local tDir=turnedDir(dir)
   if tDir==forward then
     turtle.suck()
   elseif tDir==up then
     turtle.suckUp()
   elseif tDir==down then
     turtle.suckDown()
   end
   turnFrom(dir)
 end
 
 -- REFUELS THE TURTLE, PARAMETERS DENOTE IN WHICH DIRECTION THE FUEL ITEMS WILL BE, WHERE TO DROP ANY
 -- LEFTOVERS (BUCKETS) IN WHICH INVENTORY SPOT THE FUEL WILL BE AND HOW MUCH FUEL NEEDS TO BE STORED
 function refuel(suckDir, dropDir, fuelSlot, requiredFuel)
-  turtle.select(fuelSlot)
+  --[[turtle.select(fuelSlot)
   while turtle.getFuelLevel() < requiredFuel do
     suck(suckDir)
     turtle.refuel()
     drop(dropDir)
     sleep(0)
   end]]--
   turtle.select(1)
 end
 
 -- -------------------------------------------------------------------- --
 -- END OF COPY/PASTED CODE EXTENDING THE FUNCTIONALITY OF THE BASIC API --
 -- -------------------------------------------------------------------- --
 
 -- -------------------------------------------------- --
 -- START OF THE FUNCTIONS SHARED BETWEEN ALL PROGRAMS --
 -- -------------------------------------------------- --
 
 -- CHECKS IF THE TURTLE NEEDS RESTOCKING
 function needsRestocking(configuration)
-  if turtle.getFuelLevel() < configuration.returnFuel then
+  --[[if turtle.getFuelLevel() < configuration.returnFuel then
     return true
   end]]--
   if turtle.getItemCount(15)~=0 or turtle.getItemCount(16)~=0 then
     return true
   end
   if configuration.placeTorches and turtle.getItemCount(1)==0 then
     return true
   end
   return false
 end
 
 -- EMPTIES THE INVENTORY, GETS NEW TORCHES AND NEW FUEL
 function restockTurtle(configuration, ignoreBlocks)
   tempL = configuration.currentL
   tempT = configuration.currentT
   tempS = configuration.currentS
   if configuration.singleChest then
     moveToLocation(configuration, 1, 1, 0)
   else
     moveToLocation(configuration, tempL, tempT, 0)
   end
   dropoff(configuration, ignoreBlocks)
   if configuration.placeTorches then
     restockTorches(configuration, ignoreBlocks)
   end
   if configuration.requiresFuel then
     refuel(configuration.fuelSuckDir, configuration.fuelDropDir, 16, configuration.departureFuel)
   end
   moveToLocation(configuration, tempL, tempT, tempS)
 end
 
 -- PARTIALLY EMPTIES THE INVENTORY
 function dropoff(configuration, ignoreBlocks)
   ignoreBlocks = ignoreBlocks or 0
   local torchSlot=0
   if configuration.placeTorches then
     torchSlot=1
   end
 
   -- Drop the extras of the ignore blocks
   turnTo(configuration.itemDropDir)
   for i=1+torchSlot,torchSlot+ignoreBlocks do
     turtle.select(i)
     drop(turnedDir(configuration.itemDropDir), math.max(turtle.getItemCount(i)-1, 0))
   end
   turnFrom(configuration.itemDropDir)
 
   -- Drop the other items
   turnTo(configuration.itemDropDir)
   for i=torchSlot+ignoreBlocks+1,16 do
     turtle.select(i)
     drop(turnedDir(configuration.itemDropDir), turtle.getItemCount(i))
   end
   turnFrom(configuration.itemDropDir)
 
   turtle.select(1)
 end
 
 -- COMPLETELY EMPTIES THE INVENTORY
 function dropAll(configuration, ignoreBlocks)
   ignoreBlocks = ignoreBlocks or 0
   local torchSlot=0
 
   -- Drop the torches
   if configuration.placeTorches then
     torchSlot=1
     drop(configuration.torchSuckDir)
   end
 
   -- Drop the extras of the ignore blocks
   turnTo(configuration.itemDropDir)
   for i=1+torchSlot,torchSlot+ignoreBlocks do
     turtle.select(i)
     drop(turnedDir(configuration.itemDropDir), math.max(turtle.getItemCount(i)-1, 0))
   end
   turnFrom(configuration.itemDropDir)
 
   -- Drop the ignore blocks
   turnTo(configuration.ignoreDir)
   for i=1+torchSlot,torchSlot+ignoreBlocks do
     turtle.select(i)
     drop(turnedDir(configuration.ignoreDir), 1)
   end
   turnFrom(configuration.ignoreDir)
 
   -- Drop the other items
   turnTo(configuration.itemDropDir)
   for i=torchSlot+ignoreBlocks+1,16 do
     turtle.select(i)
     drop(turnedDir(configuration.itemDropDir), turtle.getItemCount(i))
   end
   turnFrom(configuration.itemDropDir)
 
   turtle.select(1)
 end
 
 -- GETS NEW TORCHES
 function restockTorches(configuration, ignoreBlocks)
   ignoreBlocks = ignoreBlocks or 0
   turnTo(configuration.torchSuckDir)
   local tDir = turnedDir(configuration.torchSuckDir)
   turtle.select(1)
   suck(tDir)
   turtle.select(2+ignoreBlocks)
   drop(tDir)
   turnFrom(configuration.torchSuckDir)
 end
 
 -- CALCULATES HOW MUCH MOVES NEED TO BE MADE TO GO FROM ONE SHAFT TO ANOTHER
 function calculateMoves(configuration, numL, fromS, toS)
   local lowS = fromS
   local highS = toS
   if highS < lowS then
     lowS = toS
     highS = fromS
   end
   if lowS == highS then
     return 0
   end
   local requiredMoves = 0
   if highS == (configuration.numS + 1) then
     if numL % 2 == 1 then
       requiredMoves = requiredMoves+configuration.evenLevelOffset
     end
     highS = highS - 1
   end
   if lowS == 0 then
     requiredMoves = requiredMoves+configuration.firstShaftOffset
     if numL % 2 == 0 then
       requiredMoves = requiredMoves+configuration.evenLevelOffset
     end
     requiredMoves = requiredMoves+((configuration.blocksBetweenShafts+1)*(highS-1))
   else
     requiredMoves = requiredMoves+((configuration.blocksBetweenShafts+1)*(highS-lowS))
   end
   return requiredMoves
 end
 
 -- MOVES FROM THE CURRENT LOCATION TO ANOTHER
 function moveToLocation(configuration, newL, newT, newS)
   if newL == configuration.currentL and newT == configuration.currentT then
     if configuration.currentS < newS then
       digAndMove(forward, calculateMoves(configuration, newL, configuration.currentS, newS))
     elseif newS < configuration.currentS then
       digAndMove(reverseDir(forward), calculateMoves(configuration, newL, configuration.currentS, newS))
     end
   else
     local turnDir = configuration.nextDirT
     local moves = newT - configuration.currentT
     if configuration.currentT > newT then
       turnDir = reverseDir(turnDir)
       moves = configuration.currentT - newT
     end
     if configuration.currentS == 0 then
       digAndMove(forward)
       turnTo(turnDir)
     else
       turnTo(back)
       digAndMove(forward, calculateMoves(configuration, configuration.currentL, 0, configuration.currentS)-1)
       turnFrom(turnDir)
     end
     digAndMove(forward, configuration.centerRadius+1)
     if configuration.currentL < newL then
       digAndMove(configuration.nextDirL, (newL-configuration.currentL)*(configuration.height+1))
     end
     if configuration.currentL > newL then
       digAndMove(reverseDir(configuration.nextDirL), (configuration.currentL-newL)*(configuration.height+1))
     end
     if newT == configuration.currentT then
       turnTo(back)
     else
       turnTo(turnDir)
       for i=2, moves do
         digAndMove(forward, 2*(configuration.centerRadius+1))
         turnTo(turnDir)
       end
     end
     if newT == configuration.currentT then
       turnDir = reverseDir(turnDir)
     end
     digAndMove(forward, configuration.centerRadius+1)
     if newS == 0 then
       turnTo(turnDir)
       digAndMove(forward)
       turnTo(back)
     else
       turnFrom(turnDir)
       digAndMove(forward, calculateMoves(configuration, newL, 0, newS)-1)
     end
   end
   configuration.currentL = newL
   configuration.currentT = newT
   configuration.currentS = newS
 end
 
 -- ------------------------------------------------ --
 -- END OF THE FUNCTIONS SHARED BETWEEN ALL PROGRAMS --
 -- ------------------------------------------------ --
 
 -- ------------------------------------------ --
 -- START OF THE FUNCTIONS SPECIFIC TO digOres --
 -- ------------------------------------------ --
 
 -- EXCAVATES A SHAFT, DIGGING OUT ALL THE SPECIAL BLOCKS (ORES ETC)
 function excavateShaft(configuration, dir)
   local squaresMoved=0
   for i=1,configuration.centerRadius+calculateMoves(configuration, configuration.currentL, 0, configuration.currentS) do
     if needsRestocking(configuration) then
       turnTo(back)
       exitShaftAndRestock(configuration, dir, squaresMoved)
     end
     if digAndMove(forward)==0 then
       print("Encountered obstruction in:")
       print(" LEV: "..configuration.currentL)
       print(" TUN: "..configuration.currentT)
       print(" SH : "..configuration.currentS.." ("..dir..")")
       break
     end
     squaresMoved = squaresMoved + 1
     checkSides(configuration, up)
   end
   digAndMove(down)
   turnTo(back)
   checkSides(configuration, down)
   for i=1,squaresMoved do
     if configuration.placeTorches and (squaresMoved%8==7) then
       place(up, 1)
     end
     if needsRestocking(configuration) then
       digAndMove(up)
       exitShaftAndRestock(configuration, dir, squaresMoved)
       turnTo(back)
       digAndMove(down)
     end
     if digAndMove(forward)==0 then
       print("Encountered obstruction in:")
       print(" LEV: "..configuration.currentL)
       print(" TUN: "..configuration.currentT)
       print(" SH : "..configuration.currentS.." ("..dir..")")
       break
     end
     squaresMoved = squaresMoved - 1
     checkSides(configuration, down)
   end
   digAndMove(up)
   digAndMove(forward, squaresMoved)
 end
 
 -- CHECKS IF THE BLOCKS AT THE LEFT OR RIGHT ARE SPECIAL (AND THE TOP OR BOTTOM, DEPENDING ON THE INPUT)
 -- IF SO IT WILL DIG OUT THAT BLOCK AND EXCAVATE THE REST OF THE VEIN
 function checkSides(configuration, vDir)
   check(configuration, vDir)
   check(configuration, left)
   check(configuration, right)
 end
 
 -- DROPS THE ITEMS IN THE INVENTORY AND REFUELS THE TURTLE
 function exitShaftAndRestock(configuration, dir, squaresMoved)
   local cur
   digAndMove(forward, squaresMoved)
   turnTo(dir)
   restockTurtle(configuration, configuration.numIgnoreBlocks)
   turnTo(dir)
   digAndMove(forward, squaresMoved)
 end
 
 -- CHECKS IF A BLOCK IN A CERTAIN DIRECTION IS SPECIAL
 -- IF SO IT WILL DIG OUT THAT BLOCK AND EXCAVATE THE REST OF THE VEIN
 function check(configuration, dir)
   turnTo(dir)
   local tDir=turnedDir(dir)
   if detect(tDir) then
     if isSpecial(configuration, tDir) then
       if digAndMove(tDir) == 1 then
         excavate(configuration)
         digAndMove(reverseDir(tDir))
       end
     end
   end
   turnFrom(dir)
 end
 
 -- CHECKS IF A BLOCK IN A CERTAIN DIRECTION IS SPECIAL (NOT ONE OF THE REFERENCE COMPONENTS (DIRT ETC))
 function isSpecial(configuration, dir)
   turnTo(dir)
   local tDir=turnedDir(dir)
   local torchSlot=0
   if configuration.placeTorches then
     torchSlot=1
   end
   if not detect(tDir) then
     return false
   end
   for i=1, configuration.numIgnoreBlocks do
     if compare(tDir, i+torchSlot) then
       turnFrom(dir)
       return false
     end
   end
   turnFrom(dir)
   return true
 end
 
 -- EXCAVATES AN ORE VEIN
 function excavate(configuration)
   local numSteps = 0
   local steps = {}
   repeat
     steps[numSteps] = steps[numSteps] or 0
     steps[numSteps] = lookForOres(configuration, steps[numSteps])
     if steps[numSteps] ~= 7 then
       if digAndMove(turnedDir(intToDir(steps[numSteps]))) == 1 then
         numSteps = numSteps + 1
       end
     else
       steps[numSteps] = 0
       numSteps = numSteps - 1
       if numSteps >= 0 then
         digAndMove(reverseDir(turnedDir(intToDir(steps[numSteps]))))
       end
     end
   until numSteps < 0
 end
 
 -- LOOKS AROUND THE CURRENT POSITION, LOOKING FOR ORES
 function lookForOres(configuration, dir)
   if dir < 1 then
     dir = dir + 1
     if isSpecial(configuration, up) then
       return 1
     end
   end
   if dir < 2 then
     dir = dir + 1
     if isSpecial(configuration, down) then
       return 2
     end
   end
   if dir > 2 then
     turnTo(left)
   end
   for dir=dir+1, 6 do
     if isSpecial(configuration, forward) then
       return dir
     end
     turnTo(left)
   end
   return 7
 end
 
 -- CONVERTS AN INTEGER TO A DIRECTION
 function intToDir(dir)
   if dir == 1 then
     return up
   elseif dir == 2 then
     return down
   elseif dir == 3 then
     return forward
   elseif dir == 4 then
     return left
   elseif dir == 5 then
     return back
   elseif dir == 6 then
     return right
   end
 end
 
 -- PUTS THE IGNORE BLOCKS IN THE INVENTORY
 function restockIgnore(configuration, ignoreBlocks)
   local torchSlot=0
   if configuration.placeTorches then
     torchSlot=1
   end
   turnTo(configuration.ignoreDir)
   local tDir = turnedDir(configuration.ignoreDir)
   for i=1+torchSlot,ignoreBlocks+torchSlot do
     suck(tDir)
   end
   turnFrom(configuration.ignoreDir)
 end
 
 
 -- CHECKS IF THE USER PLACED ENOUGH BLOCKS IN THE INVENTORY
 function enoughBlocksProvided(configuration)
   local torchSlot=0
   if configuration.placeTorches then
     torchSlot=1
   end
   for i=1+torchSlot,configuration.numIgnoreBlocks+torchSlot do
     if turtle.getItemCount(i)==0 then
       return false
     end
   end
   return true
 end
 
 -- ---------------------------------------- --
 -- END OF THE FUNCTIONS SPECIFIC TO digOres --
 -- ---------------------------------------- --
 
 -- ------------------------------------------------------------ --
 -- START OF THE CODE THAT GETS EXECUTED WHEN THE PROGRAM STARTS --
 -- ------------------------------------------------------------ --
 
 restockTurtle(configuration, configuration.numIgnoreBlocks)
 restockIgnore(configuration, configuration.numIgnoreBlocks)
 
 if not enoughBlocksProvided(configuration) then
   term.clear()
   print("You said you wanted to turtle")
   print("To ignore "..configuration.numIgnoreBlocks.." blocks but didn't")
   print("place them all in the inventory")
   return
 end
 
 if (configuration.departureFuel < 400) then
   print("Warning: Low fuel value chosen")
   print("Do you wish to proceed? (Y/N)")
   local answer=io.read()
   if not (answer=="Y") then
     return
   end
 end
 
 -- For every level
 for curL = 1 + configuration.skipL, configuration.numL do
   local firstT = 1
   if curL == 1 + configuration.skipL then
     firstT = firstT + configuration.skipT
   end
 
   -- For every tunnel
   for curT = firstT, configuration.numT do
     local firstS = 1
     if (curL == 1 + configuration.skipL) and (curT == 1 + configuration.skipT) and (configuration.skipS~=0) then
       firstS = 1 + configuration.skipS
     end
 
     -- For every shaft
     for curS = firstS, configuration.numS do
       moveToLocation(configuration, curL, curT, curS)
       turnTo(left)
       excavateShaft(configuration, left)
       excavateShaft(configuration, right)
       turnTo(right)
       if needsRestocking(configuration) then
         restockTurtle(configuration, configuration.numIgnoreBlocks)
       end
     end
   end
 end
 
 -- Return to start
 moveToLocation(configuration, 1, 1, 0)
 dropAll(configuration, configuration.numIgnoreBlocks)
 
 -- ---------------------------------------------------------- --
 -- END OF THE CODE THAT GETS EXECUTED WHEN THE PROGRAM STARTS --
 -- ---------------------------------------------------------- --