[CC] obsidian.lua

local slots = {
    fuel = 1;
    water = 2;
}
local log_comp = 8302

if peripheral and rednet then
    peripheral.find('modem', rednet.open)
end
local function log(...)
    print(...)
    if rednet then
        rednet.send(log_comp, table.pack(...), 'cpup/log1')
    end
end

if not turtle then
    turtle = {
        getSelectedSlot = function() return 1 end;
        getFuelLevel = function() return 'unlimited' end;
        getItemDetail = function() end;
        dig = function() return false end;
        digUp = function() return false end;
        digDown = function() return false end;
    }
    for _, name in ipairs{'up', 'down', 'forward', 'back', 'turnLeft', 'turnRight', 'place', 'placeUp', 'placeDown', 'select', 'refuel'} do
        turtle[name] = function() return true end
    end
end

local function checkInvSpace()
    for i = 1, 16 do
        if not turtle.getItemDetail(i) then
            return true
        end
    end
    return false
end
local function assertInvSpace()
    if not checkInvSpace() then
        error 'no inventory space'
    end
end

local function digger(f) return function()
    assertInvSpace()
    local s = turtle.getSelectedSlot()
    turtle.select(1)
    while f() do
    end
    turtle.select(s)
end end
local dig = digger(turtle.dig)
local digUp = digger(turtle.digUp)
local digDown = digger(turtle.digDown)

local function refuel()
    if turtle.getFuelLevel() == 0 then
        local s = turtle.getSelectedSlot()
        turtle.select(slots.fuel)
        turtle.refuel(1)
        turtle.select(s)
    end
end

local cur_pos = {0, 0, 0}
local cur_rot = 0

local function pos_add(...)
    local pos = {0, 0, 0}
    for i = 1, select('#', ...) do
        local p = select(i, ...)
        pos[1] = pos[1] + p[1]
        pos[2] = pos[2] + p[2]
        pos[3] = pos[3] + p[3]
    end
    return pos
end
local function pos_scale(n, pos)
    return {n * pos[1], n * pos[2], n * pos[3]}
end
local function rot_rel_pos(rot)
    local pos = {0, 0, 0}
    pos[rot % 2 + 1] = math.ceil(rot / 2) == 0 and 1 or -1
    return pos
end
local function pos_str(pos)
    return table.concat(pos, ',')
end

local function mover(f, fb, ud) return function()
    refuel()
    if not f() then
        error('couldn\'t move')
    end
        cur_pos = pos_add(cur_pos, {0, 0, ud}, pos_scale(fb, rot_rel_pos(cur_rot)))
end end
local down = mover(turtle.down, 0, -1)
local up = mover(turtle.up, 0, 1)
local forward = mover(turtle.forward, 1, 0)
local back = mover(turtle.back, -1, 0)

local function turner(f, r) return function()
    cur_rot = (cur_rot + r) % 4
    f()
end end
local turnLeft = turner(turtle.turnLeft, 1)
local turnRight = turner(turtle.turnRight, -1)

local function turnTo(dir)
    local rel = (dir - cur_rot) % 4
    if rel == 0 then
    elseif rel == 1 then
        turnLeft()
    elseif rel == 2 then
        turnLeft()
        turnLeft()
    elseif rel == 3 then
        turnRight()
    end
end

local function placer(f) return function(slot)
    local s = turtle.getSelectedSlot()
    turtle.select(slot)
    f()
    turtle.select(s)
end end
local place = placer(turtle.place)
local placeDown = placer(turtle.placeDown)
local placeUp = placer(turtle.placeUp)

local function vertical()
    -- return 1
    local level = 0
    while true do
            local is, id = turtle.inspectDown()
            if is and id.name == 'minecraft:lava' then
                    digUp()
                    up()
                    placeDown(slots.water)
                    placeDown(slots.water)
                    down()
            elseif is and id.name == 'minecraft:obsidian' then
                    digDown()
                    down()
                    level = level + 1
            else
                    for i = 1, level do
                            up()
                    end
                    return level
            end
    end
end

forward()

local pos_states = {[pos_str(cur_pos)] = 'todo';}
local dir = 0
local history = {}
local backtracked = false
while true do
    local backtracking = false

    local n
    if not backtracked then
        n = vertical()
        pos_states[pos_str(cur_pos)] = 'done'
    end

    local chosen_dir
    if backtracked or n > 0 then -- dug some obsidian so look for more
        for _, rel_dir in ipairs{-1, 0, 1, 2} do
            local dir_ = (dir + rel_dir) % 4
            local pos = pos_add(cur_pos, rot_rel_pos(dir_))
            local st = pos_states[pos_str(pos)]

            log('dir', dir_)
            log('pos', pos_str(pos))
            log('st', st)

            if st == nil then
                st = 'todo'
                pos_states[pos_str(pos)] = 'todo'
            end
            if not chosen_dir and st == 'todo' then
                chosen_dir = dir_
            end
        end
    end
    if chosen_dir then -- if we chose a direction, go there
        log('chosen_dir', chosen_dir, pos_str(pos_add(cur_pos, rot_rel_pos(chosen_dir))))
        history[#history + 1] = {
            went = chosen_dir;
            was = dir;
        }
        turnTo(chosen_dir)
        dig()
        forward()
    else -- otherwise backtrack
        log 'backtracking'
        local h = history[#history]
        history[#history] = nil
        turnTo(h.went)
        back()
        dir = h.was
        backtracking = true
    end

    backtracked = backtracking
    -- break
end