roads.lua

-- roads.lua
-- Converts worldgen roads to asphalt on map load.

local ASPHALT_TOKEN = "INORGANIC:ASPHALT"

local ASPHALT_MAT_TYPE
local ASPHALT_MAT_INDEX

local CONSTRUCTED_FLOOR_TT = (function()
    local floor_shape = df.tiletype_shape_basic.Floor
    local constr_mat = df.tiletype_material.CONSTRUCTION
    for i = 0, 1000 do
        local attrs = df.tiletype.attrs[i]
        if attrs and attrs.shape == floor_shape and attrs.material == constr_mat then
            return i
        end
    end
    return nil
end)()

local S = rawget(_G, "__roads_state")
if not S then
    S = {
        debug = false,
        last_map_key = nil,
        watcher_enabled = false,
        watcher_gen = 0,
        watcher_interval = 20,
    }
    _G.__roads_state = S
end

local function log(msg)
    print("[roads] " .. msg)
end

local function dlog(msg)
    if S.debug then
        log("DIAG: " .. msg)
    end
end

local function find_asphalt()
    local info = dfhack.matinfo.find(ASPHALT_TOKEN)
    if not info then
        log(ASPHALT_TOKEN .. " material not found in raws")
        return false
    end
    ASPHALT_MAT_TYPE = info.type
    ASPHALT_MAT_INDEX = info.index
    return true
end

local function is_path_tile(tt)
    local name = df.tiletype[tt]
    return name ~= nil and name:find("Path") ~= nil
end

local function is_natural_floor_or_ramp(tt)
    local attrs = df.tiletype.attrs[tt]
    if not attrs then return false end
    return attrs.shape == df.tiletype_shape_basic.Floor or attrs.shape == df.tiletype_shape_basic.Ramp
end

local function map_key()
    if not dfhack.isMapLoaded() then return nil end
    local wm = df.global.world.map
    local cons = df.global.world.event.constructions
    return ("%d,%d,%d,%d,%d,%d"):format(
        wm.region_x, wm.region_y, wm.x_count, wm.y_count, #wm.map_blocks, #cons)
end

local function block_key(x, y, z)
    local bx = x - (x % 16)
    local by = y - (y % 16)
    return ("%d,%d,%d"):format(bx, by, z)
end

local function get_block_and_local(block_cache, x, y, z)
    local bk = block_key(x, y, z)
    local block = block_cache[bk]
    if block == nil then
        block = dfhack.maps.getTileBlock(x, y, z)
        block_cache[bk] = block or false
    elseif block == false then
        block = nil
    end
    if not block then return nil end
    return block, x % 16, y % 16
end

local function key_xyz(x, y, z)
    return ("%d,%d,%d"):format(x, y, z)
end

local function is_building_tile(block, lx, ly)
    local occ = block.occupancy[lx][ly]
    return occ and occ.building
end

local function likely_worldgen_road_construction(c, block_cache)
    local block, lx, ly = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
    if not block then return false end

    local outside = block.designation[lx][ly].outside
    if not outside then return false end

    local tt = block.tiletype[lx][ly]
    -- Do not treat generic constructed floors as roads.
    if is_path_tile(tt) then
        return true
    end

    if c.original_tile and c.original_tile >= 0 then
        if is_path_tile(c.original_tile) or is_natural_floor_or_ramp(c.original_tile) then
            return true
        end
    end

    return false
end

local function convert_roads(force, quiet)
    if not dfhack.isMapLoaded() then
        if quiet then return end
        log("No map loaded.")
        return
    end

    if not find_asphalt() then return end
    if not CONSTRUCTED_FLOOR_TT then
        log("ERROR: cannot find constructed floor tiletype in enum")
        return
    end

    local this_map_key = map_key()
    if not force and S.last_map_key == this_map_key then
        if quiet then return end
        log("Already processed this map; skipping. Use 'roads force' to run again.")
        return
    end

    local wm = df.global.world.map
    local map_blocks = wm.map_blocks
    local constructions = df.global.world.event.constructions
    local block_cache = {}

    local x_max = wm.x_count - 1
    local y_max = wm.y_count - 1

    local existing = {}
    for i = 0, #constructions - 1 do
        local c = constructions[i]
        if c.pos.x >= 0 and c.pos.x <= x_max and c.pos.y >= 0 and c.pos.y <= y_max then
            existing[key_xyz(c.pos.x, c.pos.y, c.pos.z)] = c
        end
    end

    dlog(("region_x=%d region_y=%d blocks=%d cons=%d"):format(
        wm.region_x, wm.region_y, #map_blocks, #constructions))

    local updated = 0
    local inserted = 0
    local already_asphalt = 0
    local path_tiles = 0

    -- Pass 1: update existing likely worldgen road constructions.
    for _, c in pairs(existing) do
        if likely_worldgen_road_construction(c, block_cache) then
            if c.mat_type == ASPHALT_MAT_TYPE and c.mat_index == ASPHALT_MAT_INDEX then
                already_asphalt = already_asphalt + 1
            else
                c.mat_type = ASPHALT_MAT_TYPE
                c.mat_index = ASPHALT_MAT_INDEX
                updated = updated + 1
            end

            local block, lx, ly = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
            if block then
                block.tiletype[lx][ly] = CONSTRUCTED_FLOOR_TT
            end
        end
    end

    -- Pass 2: path-tile fallback for roads that do not yet have construction records.
    for _, block in ipairs(map_blocks) do
        for lx = 0, 15 do
            for ly = 0, 15 do
                local tt = block.tiletype[lx][ly]
                if is_path_tile(tt) then
                    if is_building_tile(block, lx, ly) then
                        goto continue_tile
                    end
                    if not block.designation[lx][ly].outside then
                        goto continue_tile
                    end

                    path_tiles = path_tiles + 1
                    local x = block.map_pos.x + lx
                    local y = block.map_pos.y + ly
                    local z = block.map_pos.z
                    local k = key_xyz(x, y, z)
                    local c = existing[k]

                    if c then
                        if c.mat_type == ASPHALT_MAT_TYPE and c.mat_index == ASPHALT_MAT_INDEX then
                            already_asphalt = already_asphalt + 1
                        else
                            c.mat_type = ASPHALT_MAT_TYPE
                            c.mat_index = ASPHALT_MAT_INDEX
                            updated = updated + 1
                        end
                    else
                        c = df.construction:new()
                        c.pos.x = x
                        c.pos.y = y
                        c.pos.z = z
                        c.mat_type = ASPHALT_MAT_TYPE
                        c.mat_index = ASPHALT_MAT_INDEX
                        c.original_tile = tt
                        if dfhack.constructions.insert(c) then
                            inserted = inserted + 1
                            existing[k] = c
                        end
                    end

                    block.tiletype[lx][ly] = CONSTRUCTED_FLOOR_TT
                end
                ::continue_tile::
            end
        end
    end

    S.last_map_key = this_map_key

    log(("Converted roads to asphalt: updated=%d inserted=%d already_asphalt=%d path_tiles_seen=%d"):format(
        updated, inserted, already_asphalt, path_tiles))
end

local function tick_watch(gen)
    if not S.watcher_enabled then return end
    if gen ~= S.watcher_gen then return end

    if dfhack.isMapLoaded() then
        convert_roads(false, true)
    end

    dfhack.timeout(S.watcher_interval, "ticks", function()
        tick_watch(gen)
    end)
end

local function start_watcher()
    if S.watcher_enabled then return end
    S.watcher_enabled = true
    S.watcher_gen = S.watcher_gen + 1
    tick_watch(S.watcher_gen)
end

local function stop_watcher()
    if not S.watcher_enabled then return end
    S.watcher_enabled = false
    S.watcher_gen = S.watcher_gen + 1
end

local function status()
    log(("Status: debug=%s watcher=%s interval=%d last_map_key=%s"):format(
        tostring(S.debug), tostring(S.watcher_enabled), S.watcher_interval, tostring(S.last_map_key)))
end

local args = {...}
local cmd = args[1] or "enable"

if cmd == "enable" then
    convert_roads(false)
    start_watcher()
elseif cmd == "force" then
    convert_roads(true)
elseif cmd == "disable" then
    stop_watcher()
elseif cmd == "status" then
    status()
elseif cmd == "debug" then
    local mode = args[2] or "toggle"
    if mode == "on" then
        S.debug = true
    elseif mode == "off" then
        S.debug = false
    else
        S.debug = not S.debug
    end
    log("Debug " .. (S.debug and "ON" or "OFF"))
else
    log("Usage: roads [enable|force|disable|status|debug [on|off]]")
end