View difference between Paste ID: fhs7KzYn and MmuyL6Ma

 -- Advanced Mining Path Optimizer
 -- Optimizes mining paths based on room dimensions to minimize turns
 
 -- Position tracking
 local currentX = 0
-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
+
-local forward = true -- Moved to module-level to preserve state between layers
+
 local resumePos = {x=0, y=0, z=0, facing=0}
 
 -- Essential items to keep
-    ["minecraft:torch"] = true  -- or a very high number like 9999
+
     ["minecraft:torch"] = 64,
     ["minecraft:cobblestone"] = 128,
-local function setMiningLength(len)
+    ["minecraft:dirt"] = 128,
-  miningLength = len
+    ["minecraft:cobbled_deepslate"] = 128
 }
 
--- Utility functions
+-- Utility function to find an item in inventory
 local function findItem(itemName)
-  for slot = 1, 16 do
+
         local item = turtle.getItemDetail(slot)
-    if item and item.name == itemName then
+        if item and item.name == itemName then
-      turtle.select(slot)
+            turtle.select(slot)
-      return true
+            return true
         end
-  end
+
-  return false
+
 end
 
-local function hasInventorySpace()
+-- Check if there's space in inventory
-  for slot = 1, 16 do
+local function hasSpace()
-    if turtle.getItemCount(slot) == 0 then
+
-      return true
+
             return true
-  end
+
-  return false
+
     return false
 end
-local function turnToFacing(targetFacing)
+
-  while facing ~= targetFacing do
+-- Handle liquid blocks by placing a solid block
-    turtle.turnRight()
+local function handleLiquid(direction)
-    facing = (facing + 1) % 4
+    if findItem("minecraft:cobblestone") or findItem("minecraft:dirt") or findItem("minecraft:cobbled_deepslate") then
-  end
+
             turtle.placeUp()
         elseif direction == "down" then
--- Optimized turning function that takes shortest path
+
         else
-  local currentFacing = facing
+            turtle.place()
-  local rightTurns = (targetFacing - currentFacing) % 4
+
-  local leftTurns = (currentFacing - targetFacing) % 4
+        sleep(0.5)
-
+
-  if rightTurns <= leftTurns then
+
-      -- Turn right is shorter or equal
+
-      for i = 1, rightTurns do
+
-          turtle.turnRight()
+
-          facing = (facing + 1) % 4
+-- Turn to face specific direction optimally
-      end
+
-  else
+    local currentFacing = facing
-      -- Turn left is shorter
+    local rightTurns = (targetFacing - currentFacing) % 4
-      for i = 1, leftTurns do
+    local leftTurns = (currentFacing - targetFacing) % 4
-          turtle.turnLeft()
+
-          facing = (facing - 1) % 4
+    if rightTurns <= leftTurns then
-      end
+        -- Turn right is shorter or equal
-  end
+        for i = 1, rightTurns do
             turtle.turnRight()
             facing = (facing + 1) % 4
         end
     else
         -- Turn left is shorter
         for i = 1, leftTurns do
             turtle.turnLeft()
             facing = (facing - 1) % 4
         end
     end
-        -- Check if there's a block in the way
+
-        local detectFunc
+
 -- Try to move with obstacle handling
-            detectFunc = turtle.detectUp
+
     -- First check if there's a liquid
-            detectFunc = turtle.detectDown
+    local detectFunc
     if direction == "up" then
-            detectFunc = turtle.detect
+        detectFunc = turtle.detectUp
     elseif direction == "down" then
         detectFunc = turtle.detectDown
     else
-            -- There's a block, dig it
+        detectFunc = turtle.detect
-            digFunc()
+
 
     -- Maximum attempts to handle falling blocks
     local maxAttempts = 10
     local attempts = 0
-            -- No block, try to move
+
     while attempts < maxAttempts do
         attempts = attempts + 1
 
         if detectFunc() then
             -- Handle liquid first
-        -- If we're still here after an attempt, brief pause
+            if handleLiquid(direction) then
                 digFunc()
                 if moveFunc() then
                     break
-            print("Warning: Unable to move after multiple attempts")
+                end
             else
                 digFunc()
                 if moveFunc() then
                     break
                 end
-    if attempts < maxAttempts then
+
         else
             if moveFunc() then
                 break
             else
                 -- If movement failed but no block detected, try handling liquid
                 if handleLiquid(direction) then
                     if moveFunc() then
                         break
                     end
                 end
             end
         end
 
         -- If we're still here after an attempt, brief pause before next try
         -- This helps with falling blocks settling
         sleep(0.2)
--- Optimized turning function that takes shortest path
+
         -- If we've tried several times and still can't move, it might be an infinite fall
-  local currentFacing = facing
+
-  local rightTurns = (targetFacing - currentFacing) % 4
+            print("Warning: Possible falling blocks causing obstruction")
-  local leftTurns = (currentFacing - targetFacing) % 4
+
-
+
-  if rightTurns <= leftTurns then
+
-      -- Turn right is shorter or equal
+
-      for i = 1, rightTurns do
+
-          turtle.turnRight()
+    if attempts < maxAttempts then  -- Only update if we actually moved
-          facing = (facing + 1) % 4
+
-      end
+
-  else
+
-      -- Turn left is shorter
+
-      for i = 1, leftTurns do
+
-          turtle.turnLeft()
+
-          facing = (facing - 1) % 4
+
-      end
+
-  end
+
         end
         return true
     end
-  local returnFacing = facing
+
-  local pathFound = false
+
-
+
-  -- Try multiple vertical levels to find an open path
+
-  local function tryPathAtLevel(targetZ)
+-- Return to the chest position
-      -- Move to target Z level first
+
-      while currentZ > targetZ do
+    local pathFound = false
-          if not turtle.down() then return false end
+
-          currentZ = currentZ - 1
+    -- Try multiple vertical levels to find an open path
-      end
+    local function tryPathAtLevel(targetZ)
-      while currentZ < targetZ do
+        -- Move to target Z level first
-          if not turtle.up() then return false end
+        while currentZ > targetZ do
-          currentZ = currentZ + 1
+            if not turtle.down() then return false end
-      end
+
-
+
-      -- Face toward chest (facing 2)
+        while currentZ < targetZ do
-      turnToFacingOptimal(2)
+            if not turtle.up() then return false end
-
+
-      -- Try Y movement without digging
+
-      local initialY = currentY
+
-      while currentY < 0 do
+        -- Face toward chest (facing 2)
-          if not turtle.forward() then
+        turnToFacingOptimal(2)
-              -- If blocked, restore position and return false
+
-              while currentY < initialY do
+        -- Try Y movement without digging
-                  turtle.back()
+        local initialY = currentY
-                  currentY = currentY + 1
+        while currentY < 0 do
-              end
+            if not turtle.forward() then
-              return false
+                -- If blocked, restore position and return false
-          end
+                while currentY < initialY do
-          currentY = currentY + 1
+                    turtle.back()
-      end
+                    currentY = currentY + 1
-
+                end
-      -- Try X movement without digging
+                return false
-      if currentX ~= 0 then
+
-          if currentX > 0 then
+            currentY = currentY + 1
-              turnToFacingOptimal(3) -- face left
+
-          else
+
-              turnToFacingOptimal(1) -- face right
+        -- Try X movement without digging
-          end
+        if currentX ~= 0 then
-
+            if currentX > 0 then
-          local initialX = currentX
+                turnToFacingOptimal(3) -- face left
-          while currentX ~= 0 do
+            else
-              if not turtle.forward() then
+                turnToFacingOptimal(1) -- face right
-                  -- If blocked, restore position and return false
+
-                  while currentX ~= initialX do
+
-                      turtle.back()
+            local initialX = currentX
-                      currentX = currentX + (currentX > 0 and 1 or -1)
+            while currentX ~= 0 do
-                  end
+                if not turtle.forward() then
-                  return false
+                    -- If blocked, restore position and return false
-              end
+                    while currentX ~= initialX do
-              currentX = currentX + (currentX > 0 and -1 or 1)
+                        turtle.back()
-          end
+                        currentX = currentX + (currentX > 0 and 1 or -1)
-      end
+                    end
-
+                    return false
-      return true
+                end
-  end
+                currentX = currentX + (currentX > 0 and -1 or 1)
-
+
-  -- Try paths at different levels, starting with levels we expect to be clear
+
-  local levelsToTry = {
+
-      0,           -- Ground level (where chest is)
+
-      -1,          -- One below ground
+
-      1,           -- One above ground
+
-      currentZ,    -- Current level
+    -- Try paths at different levels, starting with levels we expect to be clear
-  }
+    local levelsToTry = {
-
+        0,           -- Ground level (where chest is)
-  -- Add intermediate levels if we're far from 0
+        -1,          -- One below ground
-  if math.abs(currentZ) > 1 then
+        1,           -- One above ground
-      table.insert(levelsToTry, math.floor(currentZ/2))
+        currentZ,    -- Current level
-  end
+    }
-
+
-  -- Try each level until we find a clear path
+    -- Add intermediate levels if we're far from 0
-  for _, targetZ in ipairs(levelsToTry) do
+    if math.abs(currentZ) > 1 then
-      if tryPathAtLevel(targetZ) then
+        table.insert(levelsToTry, math.floor(currentZ/2))
-          pathFound = true
+
-          break
+
-      end
+    -- Try each level until we find a clear path
-  end
+    for _, targetZ in ipairs(levelsToTry) do
-
+        if tryPathAtLevel(targetZ) then
-  -- If no clear path found, fall back to original digging behavior
+            pathFound = true
-  if not pathFound then
+
-      -- Original digging behavior
+
-      while currentZ > 0 do
+
-          if not tryMove(turtle.down, turtle.digDown, "down") then
+
-              print("Can't move down to Z=0")
+    -- If no clear path found, fall back to original digging behavior
-              return false
+    if not pathFound then
-          end
+        -- Original digging behavior
-      end
+        while currentZ > 0 do
-      while currentZ < 0 do
+            if not tryMove(turtle.down, turtle.digDown, "down") then
-          if not tryMove(turtle.up, turtle.digUp, "up") then
+                print("Can't move down to Z=0")
-              print("Can't move up to Z=0")
+                return false
-              return false
+
-          end
+
-      end
+        while currentZ < 0 do
-
+            if not tryMove(turtle.up, turtle.digUp, "up") then
-      turnToFacingOptimal(2)
+                print("Can't move up to Z=0")
-      while currentY < 0 do
+                return false
-          if not tryMove(turtle.forward, turtle.dig, "forward") then
+
-              print("Obstruction while returning on Y axis")
+
-              return false
+
-          end
+        turnToFacingOptimal(2)
-      end
+        while currentY < 0 do
-
+            if not tryMove(turtle.forward, turtle.dig, "forward") then
-      if currentX ~= 0 then
+                print("Obstruction while returning on Y axis")
-          if currentX > 0 then
+                return false
-              turnToFacingOptimal(3)
+
-          else
+
-              turnToFacingOptimal(1)
+
-          end
+        if currentX ~= 0 then
-
+            if currentX > 0 then
-          while currentX ~= 0 do
+                turnToFacingOptimal(3)
-              if not tryMove(turtle.forward, turtle.dig, "forward") then
+            else
-                  print("Obstruction while returning on X axis")
+                turnToFacingOptimal(1)
-                  return false
+
-              end
+
-          end
+            while currentX ~= 0 do
-      end
+                if not tryMove(turtle.forward, turtle.dig, "forward") then
-  end
+                    print("Obstruction while returning on X axis")
-
+                    return false
-  -- Final position verification and facing correction
+                end
-  if currentX ~= 0 or currentY ~= 0 or currentZ ~= 0 then
+
-      print("Failed to reach chest position!")
+
-      return false
+
-  end
+
-
+    -- Final position verification and facing correction
-  -- Ensure we're facing the chest (facing 2) at the end
+
-  turnToFacingOptimal(2)
+        print("Failed to reach chest position!")
-
+
-  return true
+
 
     -- Ensure we're facing the chest (facing 2) at the end
-local function hasEssentialItems()
+
-    local hasTorches = false
+
     return true
 end
 
 -- Dump inventory while preserving essential items
-            hasTorches = true
+
     -- Store current position
     resumePos.x = currentX
     resumePos.y = currentY
     resumePos.z = currentZ
-    return hasTorches
+
 
     -- Return to chest
-local function hasOperationalInventory()
+
-    -- Check if we have at least 1 free slot AND torches
+
-    local hasSpace = false
+
-    local hasTorches = false
+    -- Track preserved quantities
     local preserved = {
         ["minecraft:torch"] = 0,
         ["minecraft:cobblestone"] = 0,
-            hasSpace = true
+        ["minecraft:dirt"] = 0,
         ["minecraft:cobbled_deepslate"] = 0
-            local item = turtle.getItemDetail(slot)
+    }
-            if item and item.name == "minecraft:torch" then
+
-                hasTorches = true
+    -- First pass: Calculate total preserved items
     for slot = 1, 16 do
         local item = turtle.getItemDetail(slot)
         if item and ESSENTIAL_ITEMS[item.name] then
             preserved[item.name] = preserved[item.name] + item.count
-    return hasSpace and hasTorches
+
     end
 
     -- Second pass: Drop excess items
     for slot = 1, 16 do
         turtle.select(slot)
         local item = turtle.getItemDetail(slot)
 
         if item then
             local itemName = item.name
             if ESSENTIAL_ITEMS[itemName] then
                 local maxKeep = ESSENTIAL_ITEMS[itemName]
                 local alreadyPreserved = preserved[itemName]
 
                 if alreadyPreserved > maxKeep then
-    -- Simply drop all non-torch items
+                    -- Drop excess from this slot
                     local toDrop = math.min(alreadyPreserved - maxKeep, item.count)
                     turtle.drop(toDrop)
                     preserved[itemName] = preserved[itemName] - toDrop
                 end
-        if item and item.name ~= "minecraft:torch" then
+            else
-            -- Drop all non-torch items
+                -- Drop all non-essential items
-            turtle.drop()
+                turtle.drop()
             end
         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
 
 -- Dump all inventory at the end of mining
 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
--- Calculate torch positions for symmetric placement
+
-local function calculateTorchPositions(length, width)
+
-  local positions = {}
+-- Calculate required torches
-
+
-  -- For very small rooms (less than 7x7), just place a torch in the center
+    return math.ceil(length/4) * math.ceil(width/4)
-  if length <= 7 and width <= 7 then
+
-    table.insert(positions, {x = math.ceil(length/2), z = math.ceil(width/2)})
+
-    return positions
+-- Move vertically based on direction
-  end
+local function moveVertical(verticalDir)
-
+    if verticalDir == "up" then
-  -- For larger rooms, create a grid of torches with optimal spacing
+        return turtle.up, turtle.digUp, "up"
-  -- In newer versions (1.18+), we can use spacing up to 13 blocks
+
-  -- But we'll adjust for symmetry based on room dimensions
+        return turtle.down, turtle.digDown, "down"
-
+
-  -- Calculate spacing for symmetrical pattern
+
-  local xSpacing = math.min(13, length)
+
-  local zSpacing = math.min(13, width)
+-- Execute the generated path
-
+local function executePath(path)
-  -- Adjust spacing for larger rooms to maintain symmetry
+    local torchCounter = 0
-  if length > 13 then
+
-    -- Find the number of torches needed along length
+    for i, step in ipairs(path) do
-    local numTorchesX = math.ceil(length / 13)
+        -- Check inventory space
-    -- Distribute evenly
+        if not hasSpace() then
-    xSpacing = length / numTorchesX
+            if not dumpInventory() then
-  end
+                print("Aborting mining operation")
-
+                return false
-  if width > 13 then
+
-    -- Find the number of torches needed along width
+
-    local numTorchesZ = math.ceil(width / 13)
+
-    -- Distribute evenly
+        if step.action == "mine" then
-    zSpacing = width / numTorchesZ
+            -- Mine and move forward
-  end
+            if not tryMove(turtle.forward, turtle.dig, "forward") then
-
+                print("Obstruction detected at position " .. step.x .. "," .. step.y)
-  -- Calculate offsets to center the grid
+                return false
-  local xOffset = xSpacing / 2
+
-  local zOffset = zSpacing / 2
+
-
+            -- Place torch periodically
-  -- Create the grid of torch positions
+            torchCounter = torchCounter + 1
-  for x = xOffset, length, xSpacing do
+            if torchCounter % 4 == 0 and findItem("minecraft:torch") then
-    for z = zOffset, width, zSpacing do
+                turtle.placeDown()
-      table.insert(positions, {x = math.floor(x), z = math.floor(z)})
+
         elseif step.action == "turn_right" then
-  end
+            turtle.turnRight()
-
+            facing = (facing + 1) % 4
-  return positions
+        elseif step.action == "turn_left" then
             turtle.turnLeft()
             facing = (facing - 1) % 4
--- Calculate the total number of torches needed
+
     end
-  local positions = calculateTorchPositions(length, width)
+
-  return #positions
+
 end
 
 -- Generate an improved serpentine pattern for even×even dimensions
 local function generateSerpentinePath(length, width)
     local path = {}
-  print("Usage: digRoom <length> <width> <height> [horizontal] [vertical]")
+
-  print("horizontal: left/right (default: right)")
+    -- Start at position 1,1
-  print("vertical: up/down (default: up)")
+    table.insert(path, {x=1, y=1, action="mine"})
-  return
+
     for row = 1, width do
         local isEvenRow = (row % 2 == 0)
 
         for col = 2, length do
             local x = isEvenRow and (length - col + 1) or col
             table.insert(path, {x=x, y=row, action="mine"})
         end
 
-setMiningLength(length)
+        -- Move to next row if not the last row
         if row < width then
             local x = isEvenRow and 1 or length
-  print("Invalid dimensions!")
+            -- Add turn
-  return
+            table.insert(path, {x=x, y=row, action="turn_right"})
             -- Add move down
             table.insert(path, {x=x, y=row+1, action="mine"})
             -- Add turn to prepare for next row
-  print("Invalid horizontal direction! Use 'left' or 'right'")
+            if isEvenRow then
-  return
+                table.insert(path, {x=x, y=row+1, action="turn_right"})
             else
                 table.insert(path, {x=x, y=row+1, action="turn_left"})
             end
-  print("Invalid vertical direction! Use 'up' or 'down'")
+
-  return
+
 
     return path
 end
 
-local fuelNeeded = totalBlocks + height + math.ceil(width/2) * 2
+-- Generate a spiral pattern for odd×odd dimensions
 local function generateSpiralPath(length, width)
     local path = {}
     local x, y = 1, 1
     local minX, maxX = 1, length
-  print(string.format("Need %d fuel, have %d", fuelNeeded, turtle.getFuelLevel()))
+    local minY, maxY = 1, width
-  return
+    local dir = 0  -- 0=right, 1=down, 2=left, 3=up
 
     -- Track visited blocks
     local visited = {}
     for i = 1, length do
-  local torchCount = 0
+        visited[i] = {}
-  for slot = 1, 16 do
+        for j = 1, width do
             visited[i][j] = false
-    if item and item.name == "minecraft:torch" then
+
-      torchCount = torchCount + turtle.getItemCount(slot)
+
 
-  end
+    visited[x][y] = true
-  if torchCount < requiredTorches then
+    table.insert(path, {x=x, y=y, action="mine"})
-    print(string.format("Need %d torches, have %d", requiredTorches, torchCount))
+
     while true do
-  end
+        local nextX, nextY = x, y
 
         if dir == 0 then  -- right
-local function turnToDir(targetDir)
+            nextX = x + 1
-  if horizontalDir == "left" then
+            if nextX > maxX or visited[nextX][y] then
-    if targetDir == "right" then
+                dir = (dir + 1) % 4
-      turtle.turnLeft()
+                minY = minY + 1
-      facing = (facing - 1) % 4
+                nextX, nextY = x, y + 1
             end
-      turtle.turnRight()
+        elseif dir == 1 then  -- down
-      facing = (facing + 1) % 4
+            nextY = y + 1
             if nextY > maxY or visited[x][nextY] then
-  else
+                dir = (dir + 1) % 4
-    if targetDir == "right" then
+                maxX = maxX - 1
-      turtle.turnRight()
+                nextX, nextY = x - 1, y
-      facing = (facing + 1) % 4
+
         elseif dir == 2 then  -- left
-      turtle.turnLeft()
+            nextX = x - 1
-      facing = (facing - 1) % 4
+            if nextX < minX or visited[nextX][y] then
                 dir = (dir + 1) % 4
-  end
+                maxY = maxY - 1
                 nextX, nextY = x, y - 1
             end
-local function moveVertical()
+        else  -- up
-  if verticalDir == "up" then
+            nextY = y - 1
-    return turtle.up, turtle.digUp, "up"
+            if nextY < minY or visited[x][nextY] then
-  else
+                dir = (dir + 1) % 4
-    return turtle.down, turtle.digDown, "down"
+                minX = minX + 1
-  end
+                nextX, nextY = x + 1, y
             end
         end
-local function mineLayer()
+
-  -- Calculate torch positions for this layer
+        -- Add turn if direction changed
-  local torchPositions = calculateTorchPositions(length, width)
+        if x ~= nextX or y ~= nextY then
-
+            if nextX < 1 or nextX > length or nextY < 1 or nextY > width or visited[nextX][nextY] then
-  -- Initialize room-relative coordinates
+                -- We've completed the spiral
-  local roomX = 0
+
-  local roomZ = 0
+
-
+
-  for row = 1, width do
+            -- Add turn if needed
-    roomZ = row - 1  -- Z coordinate is the row (0-indexed)
+            if dir == 0 and facing ~= 1 then
                 table.insert(path, {x=x, y=y, action="turn_right"})
-    for col = 1, length - 1 do
+            elseif dir == 1 and facing ~= 2 then
-      -- Update room X based on direction (serpentine pattern)
+                table.insert(path, {x=x, y=y, action="turn_right"})
-      if forward then
+            elseif dir == 2 and facing ~= 3 then
-        roomX = col - 1  -- When mining forward, X increases
+                table.insert(path, {x=x, y=y, action="turn_right"})
-      else
+            elseif dir == 3 and facing ~= 0 then
-        roomX = length - col  -- When mining backward, X decreases
+                table.insert(path, {x=x, y=y, action="turn_right"})
-      end
+
-
+
-      -- Check if current room position should have a torch with exact matching
+            -- Add move
-      for _, pos in ipairs(torchPositions) do
+            table.insert(path, {x=nextX, y=nextY, action="mine"})
-        if pos.x - 1 == roomX and pos.z - 1 == roomZ then
+            visited[nextX][nextY] = true
-          if findItem("minecraft:torch") then
+            x, y = nextX, nextY
-            print("Placing torch at room position: " .. roomX .. "," .. roomZ)
+
             -- No more moves possible
             break
-          end
+
     end
-      end
+
-
+    return path
-      -- Continue with inventory check and movement
+
-      local hasSpace = false
+
-      for slot = 1, 16 do
+-- Generate an adaptive pattern for mixed dimensions (odd×even or even×odd)
 local function generateAdaptivePath(length, width)
-          hasSpace = true
+    local path = {}
-          break
+
     -- Start at position 1,1
-      end
+    table.insert(path, {x=1, y=1, action="mine"})
-
+
-      if not hasSpace then
+    for row = 1, width do
-        if not dumpInventory() then
+        local isEvenRow = (row % 2 == 0)
-          print("Aborting mining operation")
+
-          return false
+        for col = 2, length do
             local x = isEvenRow and (length - col + 1) or col
-      end
+            table.insert(path, {x=x, y=row, action="mine"})
-
+
-      -- Move forward
+
-      if not tryMove(turtle.forward, turtle.dig, "forward") then
+        -- Move to next row if not the last row
-        print("Obstruction detected")
+        if row < width then
             local x = isEvenRow and 1 or length
-      end
+            -- Add turn
             table.insert(path, {x=x, y=row, action="turn_right"})
             -- Add move down
-    -- Handle row changes
+            table.insert(path, {x=x, y=row+1, action="mine"})
-    if row < width then
+            -- Add turn to prepare for next row
-      if forward then
+            if isEvenRow then
-        turnToDir("right")
+                table.insert(path, {x=x, y=row+1, action="turn_right"})
-        if not tryMove(turtle.forward, turtle.dig, "forward") then return false end
+            else
-        turnToDir("right")
+                table.insert(path, {x=x, y=row+1, action="turn_left"})
-      else
+
-        turnToDir("left")
+
-        if not tryMove(turtle.forward, turtle.dig, "forward") then return false end
+
-        turnToDir("left")
+
-      end
+    -- Add optimized return path for mixed dimensions
-      forward = not forward
+    -- This is particularly important for odd×even dimensions
     if width % 2 == 0 then
-  end
+        -- We ended at the bottom left, which is good for returning
         -- No need to optimize
-  return true
+
         -- We ended at the bottom right, optimize return path
         local endPos = path[#path]
--- Modified end of main program
+        if endPos.x == length and endPos.y == width then
             -- Add path to get closer to start
             table.insert(path, {x=length, y=width, action="turn_left"})
-        forward = (layer % 2 == 1)
+            table.insert(path, {x=length, y=width, action="turn_left"})
 
-        forward = true
+            -- Move up a few steps
             for i = 1, math.min(3, width-1) do
                 table.insert(path, {x=length, y=width-i, action="mine"})
-    if not mineLayer() then break end
+
-
+
             -- Turn left toward start
-        -- Move up/down
+            table.insert(path, {x=length, y=width-3, action="turn_left"})
-        local moveFunc, digFunc, direction = moveVertical()
+
             -- Move left a few steps
             for i = 1, math.min(3, length-1) do
                 table.insert(path, {x=length-i, y=width-3, action="mine"})
             end
         end
     end
 
     return path
 end
-        -- Turn around for next layer
+
-        turtle.turnRight()
+-- Generate a specialized pattern for mining a chunk (16×16 or larger)
-        turtle.turnRight()
+local function generateChunkPattern(length, width)
-        facing = (facing + 2) % 4
+    local path = {}
 
     -- Calculate quadrant sizes
     local quadWidth = math.floor(width / 2)
     local quadLength = math.floor(length / 2)
 
     -- First quadrant (top-left)
     local q1 = generateSerpentinePath(quadLength, quadWidth)
     for _, move in ipairs(q1) do
         table.insert(path, move)
     end
 
     -- Add bridge to second quadrant (top-right)
     local lastPos = q1[#q1]
     if not lastPos then
         -- Error handling if q1 is empty (should not happen)
         print("Error: Failed to generate path for first quadrant")
         return generateSerpentinePath(length, width) -- Fallback to simple pattern
     end
 
     table.insert(path, {x=lastPos.x, y=lastPos.y, action="turn_right"})
 
     -- Move to second quadrant
     for i = 1, (length - lastPos.x) do
         table.insert(path, {x=lastPos.x + i, y=lastPos.y, action="mine"})
     end
 
     -- Second quadrant (top-right)
     local q2 = generateSerpentinePath(quadLength, quadWidth)
     for _, move in ipairs(q2) do
         -- Adjust coordinates for this quadrant
         local adjusted = {
             x = move.x + quadLength,
             y = move.y,
             action = move.action
         }
         table.insert(path, adjusted)
     end
 
     -- Add bridge to third quadrant (bottom-right)
     local lastPos2 = {x = q2[#q2].x + quadLength, y = q2[#q2].y}
     table.insert(path, {x=lastPos2.x, y=lastPos2.y, action="turn_right"})
 
     -- Move to third quadrant
     for i = 1, (width - lastPos2.y) do
         table.insert(path, {x=lastPos2.x, y=lastPos2.y + i, action="mine"})
     end
 
     -- Third quadrant (bottom-right)
     local q3 = generateSerpentinePath(quadLength, quadWidth)
     for _, move in ipairs(q3) do
         -- Adjust coordinates for this quadrant
         local adjusted = {
             x = move.x + quadLength,
             y = move.y + quadWidth,
             action = move.action
         }
         table.insert(path, adjusted)
     end
 
     -- Add bridge to fourth quadrant (bottom-left)
     local lastPos3 = {x = q3[#q3].x + quadLength, y = q3[#q3].y + quadWidth}
     table.insert(path, {x=lastPos3.x, y=lastPos3.y, action="turn_right"})
 
     -- Move to fourth quadrant
     for i = 1, (lastPos3.x - 1) do
         table.insert(path, {x=lastPos3.x - i, y=lastPos3.y, action="mine"})
     end
 
     -- Fourth quadrant (bottom-left)
     local q4 = generateSerpentinePath(quadLength, quadWidth)
     for _, move in ipairs(q4) do
         -- Adjust coordinates for this quadrant
         local adjusted = {
             x = move.x,
             y = move.y + quadWidth,
             action = move.action
         }
         table.insert(path, adjusted)
     end
 
     return path
 end
 
 -- Generate path for a square or rectangular room
 local function generatePath(length, width)
     local path = {}
 
     -- Determine the best path strategy based on dimensions
     if length == width and length % 2 == 1 then
         -- Square with odd dimensions - use spiral
         print("Using spiral pattern for square with odd dimensions")
         return generateSpiralPath(length, width)
     elseif length >= 16 and width >= 16 then
         -- Large area (chunk size) - use chunk pattern
         print("Using optimized chunk mining pattern")
         return generateChunkPattern(length, width)
     elseif length % 2 == 0 and width % 2 == 0 then
         -- Even x Even - use serpentine
         print("Using improved serpentine for even×even dimensions")
         return generateSerpentinePath(length, width)
     else
         -- Mixed dimensions - use adaptive pattern
         print("Using adaptive pattern for mixed dimensions")
         return generateAdaptivePath(length, width)
     end
 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"
 
 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
 -- Add extra margin for fuel based on path complexity
 local fuelNeeded = totalBlocks * 1.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
 
 -- Check for blocking material
 local hasBlockingMaterial = false
 for slot = 1, 16 do
     local item = turtle.getItemDetail(slot)
     if item and (item.name == "minecraft:cobblestone" or item.name == "minecraft:dirt" or item.name == "minecraft:cobbled_deepslate") then
         hasBlockingMaterial = true
         break
     end
 end
 
 if not hasBlockingMaterial then
     print("Warning: No blocks available for liquid handling")
     print("Recommend having cobblestone, dirt, or cobbled deepslate")
     print("Continue anyway? (y/n)")
     local response = read():lower()
     if response ~= "y" then
         return
     end
 end
 
 print(string.format("Mining room %d×%d×%d using optimized algorithm", length, width, height))
 
 -- Mine each layer
 for layer = 1, height do
     print("Mining layer " .. layer .. " of " .. height)
 
     -- Generate optimized path for this layer
     local path = generatePath(length, width)
 
     -- Execute the path
     if not executePath(path) then
         print("Mining operation aborted at layer " .. layer)
         break
     end
 
     if layer < height then
         -- Move up/down to next layer
         local moveFunc, digFunc, direction = moveVertical(verticalDir)
         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
     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