Tremaux (resolver laberintos)

-- programa para resolver un laberinto por el algoritmo de tremaux
-- hay que cargar lana amarilla en la primera mitad del inventario
-- y roja en la segunda mitad

-- marca de la salida
success, dataExit = turtle.inspectDown()
exitName = dataExit.name
exitMeta = dataExit.metadata

-- marca de camino recorrido 1 vez (lana amarilla)
oneName = "minecraft:wool"
oneMeta = 4

-- marca de camino recorrido 2 veces (lana roja)
twoName = "minecraft:wool"
twoMeta = 14

-- funcion para colocar un bloque del siguiente slot con recursos
-- si no quedan recursos devuelve false, en caso contrario true
function placeBlock(n)
    -- si n = 1 coloca un bloque de la pimera mitad del inventario (una marca)
    -- si n = 2 coloca un bloque de la segunda mitad del inventario (dos marcas)

    if n == 1 then
        turtle.select(1)
        maxSlot = 8
    else
        turtle.select(9)
        maxSlot = 16
    end

    while turtle.getItemCount() == 0 do
        turtle.select(turtle.getSelectedSlot() + 1)

        if turtle.getSelectedSlot() == maxSlot and turtle.getItemCount() == 0 then
            print("nasti")
            return false
        end
    end
    turtle.place()
    turtle.select(1)
    return true
end


-- funcion para detectar en que direcciones hay caminos
-- devuelve:
-- paths: un vector de cuatro componentes con la informacion de las cuatro direcciones
--  0: si no hay nada, 1: una marca, 2: dos marcas, 3: otro bloque
-- nPaths: un vector de cuatro componentes con el numero de caminos concurrentes de cada tipo
--  1a: una marca, 2: dos marcas, 3: otro bloque (pared), 4: nada
-- IMPORTANTE: la tortuga termina mirando hacia la izquierda
function isPath()
    -- pahts = {delante, derecha, detras, izquierda}
    paths  = {0,0,0,0}
    nPaths = {0,0,0,0}

    -- para cada uno de los lados
    for k = 1, 4 do
        -- detectamos si hay un bloque delante
        if turtle.detect() then
            -- si lo hay, lo inspeccionamos
            success, dataPath = turtle.inspect()
            dataName = dataPath.name
            dataMeta = dataPath.metadata

            -- apuntamos si es una marca o una pared
            if dataName == oneName and dataMeta == oneMeta then
                paths[k] = 1
                nPaths[1] = nPaths[1] + 1
            elseif dataName == twoName and dataMeta == twoMeta then
                paths[k] = 2
                nPaths[2] = nPaths[2] + 1
            else
                paths[k] = 3
                nPaths[3] = nPaths[3] + 1
            end
        else
            -- si no hay bloque lo apuntamos que hay un bloque vacio
            nPaths[4] = nPaths[4] + 1
        end

        -- en la ultima direccion no hace falta girar (acabamos mirando hacia la izquierda)
        if k < 4 then
            turtle.turnRight()
        end
    end

    return paths, nPaths
end


-- funcion para avanzar y poner una marca en el suelo
-- devuelve true si hemos terminado y false en caso contrario
function move(mark)
    -- mark = 0: solo avanza, 1: pone una marca, 2: pone dos marcas

    -- si encontramos un bloque lo quitamos
    if turtle.detect() then
        turtle.dig()
    end

    -- avanzamos una casilla
    turtle.forward()

    -- inspeccionamos el bloque bajo la tortuga para ver si hemos salido
    success, dataDown = turtle.inspectDown()
    finish = dataDown.name ~= exitName or dataDown.metadata ~= exitMeta

    -- si no hemos salido
    if finish then
        -- avanzamos otra casilla
        turtle.forward()

        -- si hay que colocar una marca
        if mark ~= 0 then
            -- damos la vuelta
            turtle.turnRight()
            turtle.turnRight()

            -- colocamos un nuevo bloque
            finish = placeBlock(mark)
            print("place: ",finish)


            -- volvemos a dar la vuelta para mirar hacia delante
            turtle.turnRight()
            turtle.turnRight()

        end
    end

    print("end: ",finish)
    return finish

end


-- bucle principal
turtle.forward()
success, dataDown = turtle.inspectDown()
finish = dataDown.name ~= exitName or dataDown.metadata ~= exitMeta

-- guardo en una variable cuantas veces he recorrido el camino actual
nTimes = 1

while finish do
    -- miramos que caminos hay alrededor
    paths, nPaths = isPath()

    -- guardamos que hay en el camino que vamos a tomar
    --  0: si no hay nada, 1: una marca, 2: dos marcas, 3: otro bloque (pared)
    nextBlock = 0

    -- si hay no hay cruce (numero de paredes = 2)
    if nPaths[3] == 2 then
        -- NOTA: terminamos la busqueda de caminos mirando a la izquierda
        if paths[1] ~= 3 then
            -- si no hay pared delante
            turtle.turnRight()

            nextBlock = paths[1]

        elseif paths[2] ~= 3 then
            -- si no hay pared a la derecha
            turtle.turnRight()
            turtle.turnRight()

            nextBlock = paths[2]

        elseif paths[4] ~= 3 then
            -- si no hay pared a la izquierda
            nextBlock = paths[4]
        end

        finish = move(0)

    elseif nPaths[3] == 3 then
        -- si llegamos a un callejón sin salida (numero de paredes = 3)
        -- volvemos hacia atrás
        turtle.turnLeft()

        -- guardamos que estamos recorriendo el camino por segunda vez
        nTimes = 2

        -- nos movemos
        finish = move(0)

    else
        -- en caso contrario estamos en un cruce (numero de paredes < 2)
        -- primero cerramos el camino por el que hemos venido con la marca correspondiente
        turtle.turnLeft()
        if not placeBlock(nTimes) then
            return
        end


        -- guardamos el camino por el que hemos venido con la marca que hemos puesto
        paths[3] = nTimes

        -- nos quedamos mirando hacia atras
        -- buscamos si hay algun camino que no hayamos recorrido previamente
        -- si no hay, buscamos uno que solo hayamos recorrido solo una vez
        -- lo haremos en el orden que nos permita movernos haciendo menos giros
        -- modificamos la variable que almacena las veces que hemos recorrido un camino en consecuencia
        if paths[2] == 0 then
            -- si vamos por la derecha
            turtle.turnLeft()
            nTimes = 1
        elseif paths[4] == 0 then
            -- si vamos por la izquierda
            turtle.turnRight()
            nTimes = 1
        elseif paths[1] == 0 then
            -- si vamos hacia delante
            turtle.turnRight()
            turtle.turnRight()
            nTimes = 1
        elseif paths[3] == 1 then
            -- si volvemos hacia atras
            nTimes = 2
        elseif paths[2] == 1 then
            -- si volvemos a ir por la derecha
            turtle.turnLeft()
            nTimes = 2
        elseif paths[4] == 1 then
            -- si volvemos a ir por la izquierda
            turtle.turnRight()
            nTimes = 2
        elseif paths[1] == 1 then
            -- si volvemos a ir hacia delante
            turtle.turnRight()
            turtle.turnRight()
            nTimes = 2
        end

        -- avanzamos y colocamos la marca correspondiente
        finish = move(nTimes)

    end
end