roads_old.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,
    }
    _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_constructed_floor_tile(tt)
    local attrs = df.tiletype.attrs[tt]
    return attrs and attrs.shape == df.tiletype_shape_basic.Floor and
           attrs.material == df.tiletype_material.CONSTRUCTION
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
    return ("%d,%d,%d,%d,%d"):format(
        wm.region_x, wm.region_y, wm.x_count, wm.y_count, #wm.map_blocks)
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 build_block_index(map_blocks)
    local idx = {}
    for _, block in ipairs(map_blocks) do
        idx[block_key(block.map_pos.x, block.map_pos.y, block.map_pos.z)] = block
    end
    return idx
end

local function get_block_and_local(block_idx, x, y, z)
    local block = block_idx[block_key(x, y, z)]
    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 likely_worldgen_road_construction(c, block_idx)
    local block, lx, ly = get_block_and_local(block_idx, 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]
    if is_path_tile(tt) or is_constructed_floor_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_constructed_floor_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)
    if not dfhack.isMapLoaded() then
        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
        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_idx = build_block_index(map_blocks)

    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 (covers most dirt-road cases).
    for _, c in pairs(existing) do
        if likely_worldgen_road_construction(c, block_idx) 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_idx, 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
                    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
            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 status()
    log(("Status: debug=%s last_map_key=%s"):format(
        tostring(S.debug), tostring(S.last_map_key)))
end

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

if cmd == "enable" then
    convert_roads(false)
elseif cmd == "force" then
    convert_roads(true)
elseif cmd == "disable" then
    -- no-op, conversion persists for current session
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