View difference between Paste ID: MmuyL6Ma and Z7DqdJu9

-function PlaceTorch()
+-- Position tracking
-  for a = 1, 16 do
+local currentX = 0
-    turtle.select(a)
+local currentY = 0
-    c = turtle.getItemCount(a)
+local currentZ = 0
-    if c == 0 then
+local facing = 0 -- 0=forward(away from chest), 1=right, 2=back(toward chest), 3=left
 local startRow = true -- Track if we're starting from the front or back of the row
 local miningLength = 0  -- Store length as a module-level variable
-      s = turtle.getItemDetail(a)
+local forward = true -- Moved to module-level to preserve state between layers
 local resumePos = {x=0, y=0, z=0, facing=0}
-      if s.name == "minecraft:torch" then
+
-        turtle.placeDown()
+local ESSENTIAL_ITEMS = {
-        return
+    ["minecraft:torch"] = true  -- or a very high number like 9999
 }
 
 local function setMiningLength(len)
   miningLength = len
 end
-local tArgs = {...}
+
-if #tArgs ~= 3 then
+-- Utility functions
-  print("Requires length, width & height!")
+local function findItem(itemName)
   for slot = 1, 16 do
     local item = turtle.getItemDetail(slot)
-
+    if item and item.name == itemName then
-local x = tonumber(tArgs[1]) - 1
+      turtle.select(slot)
-local y = tonumber(tArgs[2])
+      return true
-local z = tonumber(tArgs[3])
+
-local x2 = 0
+
-local y2 = 0
+  return false
-local startingtorch = false
+
-local distance = 0
+
-local countdown = false
+local function hasInventorySpace()
-
+  for slot = 1, 16 do
-if x == nil or y == nil or z == nil then
+    if turtle.getItemCount(slot) == 0 then
       return true
     end
   end
-
+  return false
-if x < 0 or y < 0 or z < 0 then
+
-  print("Invalid (negative) dimensions!")
+
 local function turnToFacing(targetFacing)
   while facing ~= targetFacing do
-
+
-local fuel = turtle.getFuelLevel()
+    facing = (facing + 1) % 4
-local roomSize = x * y * z
+
-while fuel < roomSize do
+
-  if not turtle.refuel(1) then
+
-    print("Not enough fuel!")
+-- Optimized turning function that takes shortest path
 local function turnToFacingOptimal(targetFacing)
   local currentFacing = facing
   local rightTurns = (targetFacing - currentFacing) % 4
   local leftTurns = (currentFacing - targetFacing) % 4
-local xTimes = x + 1
+
-local yTimes = y
+  if rightTurns <= leftTurns then
-local xTorches = 0
+      -- Turn right is shorter or equal
-local yTorches = 0
+      for i = 1, rightTurns do
-local t = true
+          turtle.turnRight()
-local tt = true
+          facing = (facing + 1) % 4
       end
-while t == true do
+
-  if xTimes >= 4 then
+      -- Turn left is shorter
-    xTimes = xTimes - 4
+      for i = 1, leftTurns do
-    xTorches = xTorches + 1
+          turtle.turnLeft()
-  elseif xTimes < 4 and xTimes > 0 then
+          facing = (facing - 1) % 4
-    xTorches = xTorches + 1
+
-    t = false
+
-  elseif xTimes == 1 then
+
-    xTorches = xTorches + 1
+
-    t = false
+local function tryMove(moveFunc, digFunc, direction)
     -- Maximum attempts to handle falling blocks
-    t = false
+    local maxAttempts = 10
-    if xTimes == 0 then
+    local attempts = 0
-      xTimes = 4
+
     while attempts < maxAttempts do
         attempts = attempts + 1
 
         -- Check if there's a block in the way
-while tt == true do
+        local detectFunc
-  if yTimes >= 4 then
+        if direction == "up" then
-    yTimes = yTimes - 4
+            detectFunc = turtle.detectUp
-    yTorches = yTorches + 1
+        elseif direction == "down" then
-  elseif yTimes < 4 and yTimes > 0 then
+            detectFunc = turtle.detectDown
-    yTorches = yTorches + 1
+        else
-    tt = false
+            detectFunc = turtle.detect
-  elseif yTimes == 1 then
+
-    yTorches = yTorches + 1
+
-    tt = false
+        if detectFunc() then
             -- There's a block, dig it
-    tt = false
+            digFunc()
-    if yTimes == 0 then
+            if moveFunc() then
-      yTimes = 4
+                break
             end
         else
             -- No block, try to move
             if moveFunc() then
-local RequiredTorches = xTorches * yTorches
+                break
-local Torches = 0
+
         end
-for a = 1, 16 do
+
-  turtle.select(a)
+        -- If we're still here after an attempt, brief pause
-  c = turtle.getItemCount(a)
+        sleep(0.2)
-  if c == 0 then
+
         if attempts == maxAttempts then
             print("Warning: Unable to move after multiple attempts")
-    s = turtle.getItemDetail(a)
+            return false
-    if s.name == "minecraft:torch" then
+
-      Torches = Torches + c
+
 
     -- Update position after successful move
     if attempts < maxAttempts then
         if moveFunc == turtle.forward then
-if RequiredTorches > Torches and z > 1 then
+            if facing == 0 then currentY = currentY - 1
-    print("Not enough Torches! You require a total of " .. RequiredTorches .. " Torches!")
+            elseif facing == 1 then currentX = currentX + 1
             elseif facing == 2 then currentY = currentY + 1
             else currentX = currentX - 1 end
-    print("Good to go!")
+        elseif moveFunc == turtle.up then
             currentZ = currentZ + 1
         elseif moveFunc == turtle.down then
-local direction = true
+            currentZ = currentZ - 1
-for i = 1, z do
+
-  for j = 1, y do
+        return true
-    for k = 1, x do
+
-      if i == 2 and j == yTimes and k == xTimes then
+
-        PlaceTorch()
+    return false
-        startingtorch = true
+
 
-      if turtle.forward() == false then
+-- Optimized turning function that takes shortest path
-        repeat
+local function turnToFacingOptimal(targetFacing)
-          turtle.dig()
+  local currentFacing = facing
-          sleep(0.25)
+  local rightTurns = (targetFacing - currentFacing) % 4
-        until turtle.forward() == true
+  local leftTurns = (currentFacing - targetFacing) % 4
 
-      if i == 2 and startingtorch == true then
+  if rightTurns <= leftTurns then
-        if countdown == false then
+      -- Turn right is shorter or equal
-          x2 = x2 + 1
+      for i = 1, rightTurns do
-          if x2 == 4 then
+          turtle.turnRight()
-            PlaceTorch()
+          facing = (facing + 1) % 4
-            x2 = 0
+
   else
-        elseif countdown == true then
+      -- Turn left is shorter
-          distance = distance + 1
+      for i = 1, leftTurns do
-          if xTimes == 1 then
+          turtle.turnLeft()
-            if distance == (x + 1) * 3 + 1 then
+          facing = (facing - 1) % 4
-              distance = 0
+
-              PlaceTorch()
+
-              countdown = false
+
 
-          elseif xTimes == 2 then
+local function returnToChest()
-            if distance == (x + 1) * 3 + 2 then
+  local returnFacing = facing
-              distance = 0
+  local pathFound = false
-              PlaceTorch()
+
-              countdown = false
+  -- Try multiple vertical levels to find an open path
   local function tryPathAtLevel(targetZ)
-          elseif xTimes == 3 then
+      -- Move to target Z level first
-            if distance == (x + 1) * 3 + 3 then
+      while currentZ > targetZ do
-              distance = 0
+          if not turtle.down() then return false end
-              PlaceTorch()
+          currentZ = currentZ - 1
-              countdown = false
+
       while currentZ < targetZ do
-          elseif xTimes == 4 then
+          if not turtle.up() then return false end
-            if distance == (x + 1) * 3 + 4 then
+          currentZ = currentZ + 1
-              distance = 0
+
-              PlaceTorch()
+
-              countdown = false
+      -- Face toward chest (facing 2)
       turnToFacingOptimal(2)
 
       -- Try Y movement without digging
       local initialY = currentY
       while currentY < 0 do
-    if j < y then
+          if not turtle.forward() then
-      if direction then
+              -- If blocked, restore position and return false
-        if i == 2 and countdown == false and startingtorch == true then
+              while currentY < initialY do
-          countdown = true
+                  turtle.back()
                   currentY = currentY + 1
               end
-        if turtle.forward() == false then
+              return false
-          repeat
+
-            turtle.dig()
+          currentY = currentY + 1
-            sleep(0.25)
+
-          until turtle.forward() == true
+
       -- Try X movement without digging
-        if i == 2 and startingtorch == true and countdown == true then
+      if currentX ~= 0 then
-          distance = distance + 1
+          if currentX > 0 then
               turnToFacingOptimal(3) -- face left
           else
-        direction = false
+              turnToFacingOptimal(1) -- face right
           end
-        turtle.turnLeft()
+
-        if turtle.forward() == false then
+          local initialX = currentX
-          repeat
+          while currentX ~= 0 do
-            turtle.dig()
+              if not turtle.forward() then
-            sleep(0.25)
+                  -- If blocked, restore position and return false
-          until turtle.forward() == true
+                  while currentX ~= initialX do
                       turtle.back()
-        if i == 2 and startingtorch == true and countdown == true then
+                      currentX = currentX + (currentX > 0 and 1 or -1)
-          distance = distance + 1
+                  end
-          if xTimes == 1 then
+                  return false
-            if distance == (x + 1) * 3 + 1 then
+              end
-              distance = 0
+              currentX = currentX + (currentX > 0 and -1 or 1)
-              PlaceTorch()
+
-              countdown = false
+
 
-          elseif xTimes == 2 then
+      return true
-            if distance == (x + 1) * 3 + 2 then
+
-              distance = 0
+
-              PlaceTorch()
+  -- Try paths at different levels, starting with levels we expect to be clear
-              countdown = false
+  local levelsToTry = {
       0,           -- Ground level (where chest is)
-          elseif xTimes == 3 then
+      -1,          -- One below ground
-            if distance == (x + 1) * 3 + 3 then
+      1,           -- One above ground
-              distance = 0
+      currentZ,    -- Current level
-              PlaceTorch()
+  }
-              countdown = false
+
   -- Add intermediate levels if we're far from 0
-          elseif xTimes == 4 then
+  if math.abs(currentZ) > 1 then
-            if distance == (x + 1) * 3 + 4 then
+      table.insert(levelsToTry, math.floor(currentZ/2))
-              distance = 0
+
-              PlaceTorch()
+
-              countdown = false
+  -- Try each level until we find a clear path
   for _, targetZ in ipairs(levelsToTry) do
       if tryPathAtLevel(targetZ) then
           pathFound = true
-        turtle.turnLeft()
+          break
-        direction = true
+
   end
 
   -- If no clear path found, fall back to original digging behavior
-  if i < z then
+  if not pathFound then
-    turtle.digUp()
+      -- Original digging behavior
-    turtle.up()
+      while currentZ > 0 do
           if not tryMove(turtle.down, turtle.digDown, "down") then
-    turtle.turnRight()
+              print("Can't move down to Z=0")
               return false
           end
-
+
-if y % 2 == 0 then
+      while currentZ < 0 do
-  turtle.turnRight()
+          if not tryMove(turtle.up, turtle.digUp, "up") then
-  for i = 1, y do
+              print("Can't move up to Z=0")
-    turtle.forward()
+              return false
           end
-  turtle.turnRight()
+
 
-  turtle.turnLeft()
+      turnToFacingOptimal(2)
-  for i = 1, y do
+      while currentY < 0 do
-    turtle.forward()
+          if not tryMove(turtle.forward, turtle.dig, "forward") then
               print("Obstruction while returning on Y axis")
-  turtle.turnLeft()
+              return false
-  for i = 1, x do
+
-    turtle.forward()
+
 
-  turtle.turnRight()
+      if currentX ~= 0 then
-  turtle.turnRight()
+          if currentX > 0 then
               turnToFacingOptimal(3)
-for i = 1, z do
+          else
-  turtle.down()
+              turnToFacingOptimal(1)
           end
 
           while currentX ~= 0 do
               if not tryMove(turtle.forward, turtle.dig, "forward") then
                   print("Obstruction while returning on X axis")
                   return false
               end
           end
       end
   end
 
   -- Final position verification and facing correction
   if currentX ~= 0 or currentY ~= 0 or currentZ ~= 0 then
       print("Failed to reach chest position!")
       return false
   end
 
   -- Ensure we're facing the chest (facing 2) at the end
   turnToFacingOptimal(2)
 
   return true
 end
 
 local function hasEssentialItems()
     local hasTorches = false
 
     for slot = 1, 16 do
         local item = turtle.getItemDetail(slot)
         if item and item.name == "minecraft:torch" then
             hasTorches = true
             break
         end
     end
 
     return hasTorches
 end
 
 local function hasOperationalInventory()
     -- Check if we have at least 1 free slot AND torches
     local hasSpace = false
     local hasTorches = false
 
     for slot = 1, 16 do
         if turtle.getItemCount(slot) == 0 then
             hasSpace = true
         else
             local item = turtle.getItemDetail(slot)
             if item and item.name == "minecraft:torch" then
                 hasTorches = true
             end
         end
     end
 
     return hasSpace and hasTorches
 end
 
 
 local function dumpInventory()
     -- Store current position
     resumePos.x = currentX
     resumePos.y = currentY
     resumePos.z = currentZ
     resumePos.facing = facing
 
     -- Return to chest
     print("Inventory full! Returning to chest...")
     if not returnToChest() then return false end
 
     -- Simply drop all non-torch items
     for slot = 1, 16 do
         turtle.select(slot)
         local item = turtle.getItemDetail(slot)
 
         if item and item.name ~= "minecraft:torch" then
             -- Drop all non-torch items
             turtle.drop()
         end
     end
 
     -- Return to mining position with optimized movement
     -- Move vertically first
     while currentZ ~= resumePos.z do
         if currentZ < resumePos.z then
             tryMove(turtle.up, turtle.digUp, "up")
         else
             tryMove(turtle.down, turtle.digDown, "down")
         end
     end
 
     -- Optimize Y movement
     if currentY ~= resumePos.y then
         if currentY > resumePos.y then
             turnToFacingOptimal(0)  -- Face mining direction
         else
             turnToFacingOptimal(2)  -- Face chest direction
         end
         while currentY ~= resumePos.y do
             tryMove(turtle.forward, turtle.dig, "forward")
         end
     end
 
     -- Optimize X movement
     if currentX ~= resumePos.x then
         if currentX < resumePos.x then
             turnToFacingOptimal(1)  -- Face right
         else
             turnToFacingOptimal(3)  -- Face left
         end
         while currentX ~= resumePos.x do
             tryMove(turtle.forward, turtle.dig, "forward")
         end
     end
 
     -- Return to original facing
     turnToFacingOptimal(resumePos.facing)
     return true
 end
 
 local function dumpAllInventory()
     -- Return to chest if not already there
     if currentX ~= 0 or currentY ~= 0 or currentZ ~= 0 then
         if not returnToChest() then
             print("Failed to return to chest!")
             return false
         end
     end
 
     -- Ensure facing chest
     turnToFacingOptimal(2)
 
     -- Small delay to ensure stable chest interaction
     sleep(0.5)
 
     -- Dump everything from inventory
     for slot = 1, 16 do
         turtle.select(slot)
         -- Drop entire stack, regardless of item type
         turtle.drop()
     end
 
     return true
 end
 
 -- Calculate torch positions for symmetric placement
 local function calculateTorchPositions(length, width)
   local positions = {}
 
   -- For very small rooms (less than 7x7), just place a torch in the center
   if length <= 7 and width <= 7 then
     table.insert(positions, {x = math.ceil(length/2), z = math.ceil(width/2)})
     return positions
   end
 
   -- For larger rooms, create a grid of torches with optimal spacing
   -- In newer versions (1.18+), we can use spacing up to 13 blocks
   -- But we'll adjust for symmetry based on room dimensions
 
   -- Calculate spacing for symmetrical pattern
   local xSpacing = math.min(13, length)
   local zSpacing = math.min(13, width)
 
   -- Adjust spacing for larger rooms to maintain symmetry
   if length > 13 then
     -- Find the number of torches needed along length
     local numTorchesX = math.ceil(length / 13)
     -- Distribute evenly
     xSpacing = length / numTorchesX
   end
 
   if width > 13 then
     -- Find the number of torches needed along width
     local numTorchesZ = math.ceil(width / 13)
     -- Distribute evenly
     zSpacing = width / numTorchesZ
   end
 
   -- Calculate offsets to center the grid
   local xOffset = xSpacing / 2
   local zOffset = zSpacing / 2
 
   -- Create the grid of torch positions
   for x = xOffset, length, xSpacing do
     for z = zOffset, width, zSpacing do
       table.insert(positions, {x = math.floor(x), z = math.floor(z)})
     end
   end
 
   return positions
 end
 
 -- Calculate the total number of torches needed
 local function calculateTorches(length, width)
   local positions = calculateTorchPositions(length, width)
   return #positions
 end
 
 -- Main Program
 local args = {...}
 if #args < 3 then
   print("Usage: digRoom <length> <width> <height> [horizontal] [vertical]")
   print("horizontal: left/right (default: right)")
   print("vertical: up/down (default: up)")
   return
 end
 
 local length = tonumber(args[1])
 local width = tonumber(args[2])
 local height = tonumber(args[3])
 local horizontalDir = args[4] or "right"
 local verticalDir = args[5] or "up"
 
 setMiningLength(length)
 
 if not (length and width and height) or length < 1 or width < 1 or height < 1 then
   print("Invalid dimensions!")
   return
 end
 
 if horizontalDir ~= "left" and horizontalDir ~= "right" then
   print("Invalid horizontal direction! Use 'left' or 'right'")
   return
 end
 
 if verticalDir ~= "up" and verticalDir ~= "down" then
   print("Invalid vertical direction! Use 'up' or 'down'")
   return
 end
 
 -- Calculate required resources
 local totalBlocks = length * width * height
 local fuelNeeded = totalBlocks + height + math.ceil(width/2) * 2
 local requiredTorches = height > 1 and calculateTorches(length, width) or 0
 
 -- Check fuel
 if turtle.getFuelLevel() < fuelNeeded then
   print(string.format("Need %d fuel, have %d", fuelNeeded, turtle.getFuelLevel()))
   return
 end
 
 -- Check torches if needed
 if requiredTorches > 0 then
   local torchCount = 0
   for slot = 1, 16 do
     local item = turtle.getItemDetail(slot)
     if item and item.name == "minecraft:torch" then
       torchCount = torchCount + turtle.getItemCount(slot)
     end
   end
   if torchCount < requiredTorches then
     print(string.format("Need %d torches, have %d", requiredTorches, torchCount))
     return
   end
 end
 
 local function turnToDir(targetDir)
   if horizontalDir == "left" then
     if targetDir == "right" then
       turtle.turnLeft()
       facing = (facing - 1) % 4
     else
       turtle.turnRight()
       facing = (facing + 1) % 4
     end
   else
     if targetDir == "right" then
       turtle.turnRight()
       facing = (facing + 1) % 4
     else
       turtle.turnLeft()
       facing = (facing - 1) % 4
     end
   end
 end
 
 local function moveVertical()
   if verticalDir == "up" then
     return turtle.up, turtle.digUp, "up"
   else
     return turtle.down, turtle.digDown, "down"
   end
 end
 
 local function mineLayer()
   -- Calculate torch positions for this layer
   local torchPositions = calculateTorchPositions(length, width)
 
   -- Initialize room-relative coordinates
   local roomX = 0
   local roomZ = 0
 
   for row = 1, width do
     roomZ = row - 1  -- Z coordinate is the row (0-indexed)
 
     for col = 1, length - 1 do
       -- Update room X based on direction (serpentine pattern)
       if forward then
         roomX = col - 1  -- When mining forward, X increases
       else
         roomX = length - col  -- When mining backward, X decreases
       end
 
       -- Check if current room position should have a torch with exact matching
       for _, pos in ipairs(torchPositions) do
         if pos.x - 1 == roomX and pos.z - 1 == roomZ then
           if findItem("minecraft:torch") then
             print("Placing torch at room position: " .. roomX .. "," .. roomZ)
             turtle.placeDown()
             break
           end
         end
       end
 
       -- Continue with inventory check and movement
       local hasSpace = false
       for slot = 1, 16 do
         if turtle.getItemCount(slot) == 0 then
           hasSpace = true
           break
         end
       end
 
       if not hasSpace then
         if not dumpInventory() then
           print("Aborting mining operation")
           return false
         end
       end
 
       -- Move forward
       if not tryMove(turtle.forward, turtle.dig, "forward") then
         print("Obstruction detected")
         return false
       end
     end
 
     -- Handle row changes
     if row < width then
       if forward then
         turnToDir("right")
         if not tryMove(turtle.forward, turtle.dig, "forward") then return false end
         turnToDir("right")
       else
         turnToDir("left")
         if not tryMove(turtle.forward, turtle.dig, "forward") then return false end
         turnToDir("left")
       end
       forward = not forward
     end
   end
 
   return true
 end
 
 -- Modified end of main program
 for layer = 1, height do
     if width % 2 == 0 then
         forward = (layer % 2 == 1)
     else
         forward = true
     end
 
     if not mineLayer() then break end
 
     if layer < height then
         -- Move up/down
         local moveFunc, digFunc, direction = moveVertical()
         if not tryMove(moveFunc, digFunc, direction) then
             print("Warning: Unable to move " .. verticalDir .. " (possible liquid)")
             print("Try again? (y/n)")
             local response = read():lower()
             if response ~= "y" then
                 break
             end
         end
 
         -- Turn around for next layer
         turtle.turnRight()
         turtle.turnRight()
         facing = (facing + 2) % 4
     end
 end
 
 -- Final return and dump all inventory
 print("Mining complete! Returning to chest...")
 if dumpAllInventory() then
     print("All items deposited in chest.")
     turnToFacingOptimal(0)
 else
     print("Failed to deposit all items!")
 end