ChatGPT's well digger

----------------------------------------------------------------
-- Script pour creuser un puits vertical (CC:Tweaked) de dimensions X par Y
-- Zone de creusage de [1,0,-1] à [1+X, Y, bedrock]
-- Auto-dumping et auto-refuel uniquement lorsque l'inventaire est presque plein.
--
-- Hypothèses :
-- - La Turtle démarre en [0,0,0], face +X.
-- - Un coffre est à gauche ([0,-1,0]) pour le dump (sauf items "coal" ou "charcoal").
-- - Un coffre est à droite ([0,1,0]) pour le re‑fuel (contenant du coal ou charcoal).
----------------------------------------------------------------

-- Variables de suivi de position et orientation
local pos = {x = 0, y = 0, z = 0}
-- Orientations : 0 = est (+X), 1 = nord (+Y), 2 = ouest (-X), 3 = sud (-Y)
local facing = 0

-------------------------------------------------
-- Fonctions de mise à jour de la position et rotation
-------------------------------------------------
local function updatePos(dx, dy, dz)
  pos.x = pos.x + dx
  pos.y = pos.y + dy
  pos.z = pos.z + dz
end

local function turnLeft()
  turtle.turnLeft()
  facing = (facing + 1) % 4
end

local function turnRight()
  turtle.turnRight()
  facing = (facing + 3) % 4
end

local function turnAround()
  turnLeft()
  turnLeft()
end

-------------------------------------------------
-- Fonctions de déplacement avec creusage si besoin
-------------------------------------------------
local function forward()
  while not turtle.forward() do
    if turtle.detect() then
      turtle.dig()
    else
      sleep(0.5)
    end
  end
  if facing == 0 then updatePos(1,0,0)
  elseif facing == 2 then updatePos(-1,0,0)
  elseif facing == 1 then updatePos(0,1,0)
  elseif facing == 3 then updatePos(0,-1,0)
  end
end

local function up()
  while not turtle.up() do
    if turtle.detectUp() then turtle.digUp() else sleep(0.5) end
  end
  updatePos(0,0,1)
end

local function down()
  while not turtle.down() do
    if turtle.detectDown() then turtle.digDown() else sleep(0.5) end
  end
  updatePos(0,0,-1)
end

-------------------------------------------------
-- Déplacement vers une destination donnée
-- On déplace d'abord en X, puis en Y, enfin en Z
-------------------------------------------------
local function faceDirection(targetDir)
  local diff = (targetDir - facing) % 4
  if diff == 1 then
    turnLeft()
  elseif diff == 2 then
    turnAround()
  elseif diff == 3 then
    turnRight()
  end
end

local function goTo(targetX, targetY, targetZ)
  -- Déplacement en X
  local dx = targetX - pos.x
  if dx ~= 0 then
    if dx > 0 then
      faceDirection(0)
      for i = 1, math.abs(dx) do forward() end
    else
      faceDirection(2)
      for i = 1, math.abs(dx) do forward() end
    end
  end
  -- Déplacement en Y
  local dy = targetY - pos.y
  if dy ~= 0 then
    if dy > 0 then
      faceDirection(1)
      for i = 1, math.abs(dy) do forward() end
    else
      faceDirection(3)
      for i = 1, math.abs(dy) do forward() end
    end
  end
  -- Déplacement en Z
  local dz = targetZ - pos.z
  if dz > 0 then
    for i = 1, dz do up() end
  elseif dz < 0 then
    for i = 1, -dz do down() end
  end
end

-------------------------------------------------
-- Gestion de l'inventaire : dump et refuel
-------------------------------------------------
local function dumpInventory()
  print("Dump de l'inventaire...")
  -- Se tourner vers la gauche (coffre de dump)
  faceDirection(1)
  turtle.forward()  -- Aller dans le coffre
  for slot = 1, 16 do
    local item = turtle.getItemDetail(slot)
    if item then
      -- Conserver les items de fuel (coal/charcoal)
      if not (string.find(item.name, "coal") or string.find(item.name, "charcoal")) then
        turtle.select(slot)
        turtle.drop()
      end
    end
  end
  turtle.select(1)
  turnAround()
  while not turtle.forward() do sleep(0.5) end
  faceDirection(0)
end

local function refuelIfNeeded()
  if turtle.getFuelLevel() == "unlimited" then return end
  local fuelLevel = turtle.getFuelLevel()
  if fuelLevel < 100 then  -- Seuil modifiable selon les besoins
    print("Fuel insuffisant ("..fuelLevel.."). Refuel en cours...")
    faceDirection(3)  -- se tourner vers la droite
    turtle.forward()  -- Aller dans le coffre de fuel
    for i = 1, 16 do turtle.suck() end
    for slot = 1, 16 do
      turtle.select(slot)
      turtle.refuel()
    end
    turtle.select(1)
    turnAround()
    while not turtle.forward() do sleep(0.5) end
    faceDirection(0)
  end
end

-------------------------------------------------
-- Retour à la base pour dump et refuel, avec possibilité de reprendre à une position donnée
-------------------------------------------------
local function returnToStart(resumeX, resumeY, resumeZ)
  print("Retour au point de départ pour dump & refuel...")
  goTo(0,0,0)
  dumpInventory()
  refuelIfNeeded()
  if resumeX and resumeY and resumeZ then
    goTo(resumeX, resumeY, resumeZ)
  end
end

-------------------------------------------------
-- Fonction utilitaire pour vérifier si l'inventaire est presque plein
-------------------------------------------------
local function inventoryAlmostFull(threshold)
  local freeSlots = 0
  for slot = 1, 16 do
    if not turtle.getItemDetail(slot) then
      freeSlots = freeSlots + 1
    end
  end
  return freeSlots < threshold
end

-------------------------------------------------
-- Excavation d'une couche horizontale de la zone
-- La zone est balayée en zigzag et, à chaque déplacement,
-- on vérifie que l'inventaire n'est pas presque plein.
-------------------------------------------------
local function digLayer(X, Y)
  -- La zone de creusage commence en [1,0] (plan local)
  for j = 0, Y - 1 do
    for i = 1, X do
      -- Creuser le bloc situé en dessous s'il est présent
      while turtle.detectDown() do
        turtle.digDown()
        sleep(0.2)
      end

      if i < X then
        forward()
        -- Vérifier l'inventaire après un déplacement
        if inventoryAlmostFull(3) then
          print("Inventaire presque plein au niveau de la couche. Dump en cours...")
          local resumeX, resumeY, resumeZ = pos.x, pos.y, pos.z
          returnToStart(resumeX, resumeY, resumeZ)
        end
      end
    end
    -- Si ce n'est pas la dernière rangée, passer à la rangée suivante en zigzag
    if j < Y - 1 then
      if (j % 2 == 0) then
        turnRight()
        forward()
        turnRight()
      else
        turnLeft()
        forward()
        turnLeft()
      end
      if inventoryAlmostFull(3) then
        print("Inventaire presque plein entre les rangées. Dump en cours...")
        local resumeX, resumeY, resumeZ = pos.x, pos.y, pos.z
        returnToStart(resumeX, resumeY, resumeZ)
      end
    end
  end
  -- Repositionnement pour revenir au coin de départ de la couche
  if (Y % 2 == 0) then
    faceDirection(2)
    for i = 1, X - 1 do forward() end
  end
end

-------------------------------------------------
-- Vérification de la présence de bedrock en dessous
-------------------------------------------------
local function isBedrockBelow()
  local success, data = turtle.inspectDown()
  if success and data.name == "minecraft:bedrock" then
    return true
  end
  return false
end

-------------------------------------------------
-- Programme principal
-------------------------------------------------
local function main()
  if #arg < 2 then
    print("Usage: lua well.lua <X> <Y>")
    return
  end

  local X = tonumber(arg[1])
  local Y = tonumber(arg[2])
  if not X or not Y then
    print("Dimensions invalides.")
    return
  end

  print("Début de l'excavation d'un puits de dimension "..X.."x"..Y)

  -- Se positionner au coin en haut à gauche de la zone de creusage
  goTo(1, 0, 0)
  -- Descendre d'une case pour commencer à la couche z = -1
  down()

  local layer = 1
  while true do
    print("Creusage de la couche "..layer.." (z = "..pos.z..")")
    digLayer(X, Y)

    -- Vérifier si le bedrock est présent sous la couche actuelle
    if isBedrockBelow() then
      print("Bedrock détecté. Fin de l'excavation.")
      break
    end

    -- Fin de la couche : retourner au point de départ pour dump/refuel si nécessaire
    returnToStart()
    goTo(1, 0, pos.z)
    down()
    layer = layer + 1
  end

  returnToStart()
  print("Puits terminé en profondeur "..(-pos.z).." blocs.")
end

main()