building_backup.lua

-- building.lua
-- Converts NPC site building materials on map load:
--   hardwood logs -> earthenware bricks
--   non-ceramic stone -> concrete
--
-- DFHack tiletype reference: https://github.com/DFHack/dfhack/blob/master/library/TileTypes.cpp

local CONCRETE_TOKEN = "INORGANIC:CONCRETE"
local EARTHENWARE_TOKEN = "INORGANIC:CERAMIC_EARTHENWARE"
local STONEWARE_TOKEN = "INORGANIC:CERAMIC_STONEWARE"
local GLASS_CLEAR_TOKEN = "GLASS_CLEAR"
local IRON_TOKEN = "INORGANIC:IRON"
local HARDWOOD_LOG_TOKEN = "PLANT:HARDWOOD_TREE:WOOD"
local HARDWOOD_LOG_TOKEN_LEGACY = "PLANT_MAT:HARDWOOD_TREE:WOOD"
local HAMLET_HARDWOOD_CONVERT_PERCENT = 30
local INITIAL_FORCE_DELAY_TICKS = 100

local CONCRETE_MAT_TYPE
local CONCRETE_MAT_INDEX
local EARTHENWARE_MAT_TYPE
local EARTHENWARE_MAT_INDEX
local STONEWARE_MAT_TYPE
local STONEWARE_MAT_INDEX
local GLASS_CLEAR_MAT_TYPE
local GLASS_CLEAR_MAT_INDEX
local IRON_MAT_TYPE
local IRON_MAT_INDEX
local HARDWOOD_MAT_TYPE
local HARDWOOD_MAT_INDEX
-- Maps LRUD connection suffix → ConstructedWall<suffix> tiletype index.
-- Used to preserve connection direction when rewriting stone wall tiles.
local constructed_wall_by_suffix = (function()
    local t = {}
    local constr_mat = df.tiletype_material.CONSTRUCTION
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat then
            local suffix = tostring(name):match("^ConstructedWall([LRUD]*)$")
            if suffix ~= nil then
                t[suffix] = i
            end
        end
    end
    return t
end)()

-- Maps LRUD connection suffix → ConstructedFortification<suffix> tiletype index.
local constructed_fortification_by_suffix = (function()
    local t = {}
    local constr_mat = df.tiletype_material.CONSTRUCTION
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat then
            local suffix = tostring(name):match("^ConstructedFortification([LRUD]*)$")
            if suffix ~= nil then
                t[suffix] = i
            end
        end
    end
    return t
end)()

-- ── STONE CONSTRUCTION TILE RULES ─────────────────────────────────────────────
-- Add/remove entries here to control which worldgen stone tiles get converted.
--   pattern      : Lua pattern matched against the tiletype name
--   inside_only  : true = skip tile if designation.outside is true (natural surface)
--   target_fn    : function(name) → target tiletype index (nil = add record, skip rewrite)
-- ──────────────────────────────────────────────────────────────────────────────
local STONE_CONSTR_RULES  -- defined after constructs (moved there)

local CONSTRUCTED_RAMP_TT = (function()
    local constr_mat = df.tiletype_material.CONSTRUCTION
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat and tostring(name):find("^ConstructedRamp") then
            return i
        end
    end
    return nil
end)()

local CONSTRUCTED_FLOOR_TT = (function()
    local constr_mat = df.tiletype_material.CONSTRUCTION
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat and tostring(name) == "ConstructedFloor" then
            return i
        end
    end
    return nil
end)()

local CONSTRUCTED_PILLAR_TT = (function()
    local constr_mat = df.tiletype_material.CONSTRUCTION
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat and tostring(name) == "ConstructedPillar" then
            return i
        end
    end
    return nil
end)()

local CONSTRUCTED_WALL_TT = (function()
    local constr_mat = df.tiletype_material.CONSTRUCTION

    -- Prefer the canonical connected constructed wall token if present.
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat and tostring(name) == "ConstructedWallLRUD" then
            return i
        end
    end

    -- Fallback to any ConstructedWall* token in this raws/tileset.
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat and tostring(name):find("^ConstructedWall") then
            return i
        end
    end

    -- Final fallback: classic wall-shape construction.
    local wall_shape = df.tiletype_shape_basic.Wall
    for i = 0, 1000 do
        local attrs = df.tiletype.attrs[i]
        if attrs and attrs.shape == wall_shape and attrs.material == constr_mat then
            return i
        end
    end
    return nil
end)()

STONE_CONSTR_RULES = { -- assigned here; cache built immediately after
    { pattern = "WallSmooth",   inside_only = false, target_fn = function(name)
        local suffix = name:match("([LRUD]*)$") or ""
        return constructed_wall_by_suffix[suffix] or CONSTRUCTED_WALL_TT
    end },
    { pattern = "Fortif",       inside_only = false, target_fn = function(name)
        local suffix = name:match("([LRUD]*)$") or ""
        return constructed_fortification_by_suffix[suffix] or constructed_fortification_by_suffix[""] or CONSTRUCTED_WALL_TT
    end },
    { pattern = "Pillar",       inside_only = true,  target_fn = function(_)
        return CONSTRUCTED_PILLAR_TT or CONSTRUCTED_WALL_TT
    end },
    { pattern = "Ramp",         inside_only = true,  target_fn = function(_)
        return CONSTRUCTED_RAMP_TT
    end },
}

-- Precomputed per-tiletype lookup built from STONE_CONSTR_RULES.
-- Avoids all string operations in the Pass 2 hot path: one table lookup per tile.
-- Value: {target=tiletype_index_or_nil, inside_only=bool}, or nil if not a candidate.
local stone_constr_tt_cache = (function()
    local t = {}
    local constr_mat = df.tiletype_material.CONSTRUCTION
    for tt = 0, 65535 do
        local name = tostring(df.tiletype[tt] or "")
        local attrs = df.tiletype.attrs[tt]
        if attrs and attrs.material ~= constr_mat then
            local sp = name:find("^Stone") or name:find("^Lava") or
                       name:find("^Mineral") or name:find("^Feature")
            if sp then
                for _, rule in ipairs(STONE_CONSTR_RULES) do
                    if name:find(rule.pattern) then
                        t[tt] = {target = rule.target_fn(name), inside_only = rule.inside_only}
                        break
                    end
                end
            end
        end
    end
    return t
end)()

local S = rawget(_G, "__building_state")
if not S then
    S = {
        debug = false,
        last_map_key = nil,
        watcher_enabled = false,
        watcher_gen = 0,
        watcher_interval = 5,
        init_force_gen = 0,
        processed_blocks = {},  -- block keys already scanned by Pass 2
        last_site_id = nil,     -- site id when processed_blocks was last reset
    }
    _G.__building_state = S
end

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

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

local function add_count(tbl, key)
    if not key then key = "<nil>" end
    tbl[key] = (tbl[key] or 0) + 1
end

local function log_top_counts(prefix, tbl, limit)
    local rows = {}
    for k, v in pairs(tbl) do
        rows[#rows + 1] = {k = k, v = v}
    end
    table.sort(rows, function(a, b)
        if a.v == b.v then
            return tostring(a.k) < tostring(b.k)
        end
        return a.v > b.v
    end)
    local n = math.min(limit or 10, #rows)
    if n == 0 then
        dlog(prefix .. ": none")
        return
    end
    for i = 1, n do
        dlog(("%s [%d] %s = %d"):format(prefix, i, tostring(rows[i].k), rows[i].v))
    end
end

local function hash_percent(site_id, a, b, c)
    local mod = 2147483647
    local h = 1234567
    h = (h * 1103515245 + (site_id or 0) + 12345) % mod
    h = (h * 1103515245 + (a or 0) + 12345) % mod
    h = (h * 1103515245 + (b or 0) + 12345) % mod
    h = (h * 1103515245 + (c or 0) + 12345) % mod
    return h % 100
end

local function get_current_site()
    if dfhack.world and dfhack.world.getCurrentSite then
        return dfhack.world.getCurrentSite()
    end
    if df.global.plotinfo and df.global.plotinfo.site_id and df.global.plotinfo.site_id >= 0 then
        return df.world_site.find(df.global.plotinfo.site_id)
    end
    return nil
end

local function get_site_policy()
    local site = get_current_site()
    local site_id = site and site.id or -1
    local site_type = site and df.world_site_type[site.type] or "NONE"
    local site_type_l = tostring(site_type):lower()
    local is_hamlet = (site_type_l:find("hamlet") ~= nil) or (site_type_l:find("hillock") ~= nil)
    return {
        site = site,
        site_id = site_id,
        site_type = tostring(site_type),
        is_hamlet = is_hamlet,
        hardwood_percent = is_hamlet and HAMLET_HARDWOOD_CONVERT_PERCENT or 100,
    }
end

local function should_convert_hardwood_id(site_id, id_a, id_b, id_c, percent)
    if percent >= 100 then return true end
    return hash_percent(site_id, id_a, id_b, id_c) < percent
end

local function find_materials()
    local concrete = dfhack.matinfo.find(CONCRETE_TOKEN)
    if not concrete then
        log(CONCRETE_TOKEN .. " material not found in raws")
        return false
    end
    local earthenware = dfhack.matinfo.find(EARTHENWARE_TOKEN)
    if not earthenware then
        log(EARTHENWARE_TOKEN .. " material not found in raws")
        return false
    end
    local stoneware = dfhack.matinfo.find(STONEWARE_TOKEN)
    if not stoneware then
        log(STONEWARE_TOKEN .. " material not found in raws")
        return false
    end
    local hardwood = dfhack.matinfo.find(HARDWOOD_LOG_TOKEN)
        or dfhack.matinfo.find(HARDWOOD_LOG_TOKEN_LEGACY)
    if not hardwood then
        log("WARNING: hardwood material not found; natural floors will not be converted")
    end

    CONCRETE_MAT_TYPE = concrete.type
    CONCRETE_MAT_INDEX = concrete.index
    EARTHENWARE_MAT_TYPE = earthenware.type
    EARTHENWARE_MAT_INDEX = earthenware.index
    STONEWARE_MAT_TYPE = stoneware.type
    STONEWARE_MAT_INDEX = stoneware.index
    if hardwood then
        HARDWOOD_MAT_TYPE = hardwood.type
        HARDWOOD_MAT_INDEX = hardwood.index
    end

    local glass = dfhack.matinfo.find(GLASS_CLEAR_TOKEN)
    if not glass then
        log("WARNING: " .. GLASS_CLEAR_TOKEN .. " not found; glass block walls will not be placed")
    else
        GLASS_CLEAR_MAT_TYPE = glass.type
        GLASS_CLEAR_MAT_INDEX = glass.index
    end

    local iron = dfhack.matinfo.find(IRON_TOKEN)
    if not iron then
        log("WARNING: " .. IRON_TOKEN .. " not found; iron fortifications will not be placed")
    else
        IRON_MAT_TYPE = iron.type
        IRON_MAT_INDEX = iron.index
    end

    return true
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 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 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

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

    local tt = block.tiletype[lx][ly]
    -- Building conversion should only exclude true path road tiles.
    return is_path_tile(tt)
end

local function decode_token(mat_type, mat_index)
    local info = dfhack.matinfo.decode(mat_type, mat_index)
    if not info then return nil, nil end
    return info:getToken(), info
end

local function is_stone_for_concrete(info)
    if not info or not info.material or not info.material.flags then
        return false
    end
    local f = info.material.flags
    return f.IS_STONE and not f.IS_CERAMIC
end

local function is_builtin_inorganic(token, info)
    return info and info.mode == "builtin" and token == "INORGANIC"
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)
    return block.occupancy[lx][ly].building ~= 0
end

local function set_construction_material(c, mat_type, mat_index)
    if c.mat_type == mat_type and c.mat_index == mat_index then
        return false
    end
    c.mat_type = mat_type
    c.mat_index = mat_index
    return true
end

local function diag_walls(radius)
    if not dfhack.isMapLoaded() then
        log("No map loaded.")
        return
    end
    local adv = dfhack.world.getAdventurer()
    if not adv or not adv.pos then
        log("No active adventurer found for diag scan.")
        return
    end
    local r = tonumber(radius) or 20
    local cx, cy, cz = adv.pos.x, adv.pos.y, adv.pos.z
    local constructions = df.global.world.event.constructions
    local existing = {}
    for i = 0, #constructions - 1 do
        local c = constructions[i]
        existing[key_xyz(c.pos.x, c.pos.y, c.pos.z)] = c
    end

    local walls_seen = 0
    local walls_with_construction = 0
    local by_name = {}
    local by_name_with_construction = {}

    for y = cy - r, cy + r do
        for x = cx - r, cx + r do
            local block = dfhack.maps.getTileBlock(x, y, cz)
            if block then
                local lx, ly = x % 16, y % 16
                local tt = block.tiletype[lx][ly]
                local attrs = df.tiletype.attrs[tt]
                if attrs and (attrs.shape == df.tiletype_shape_basic.Wall or attrs.shape == df.tiletype_shape_basic.Fortification) then
                    walls_seen = walls_seen + 1
                    local name = tostring(df.tiletype[tt] or ("tt_" .. tostring(tt)))
                    add_count(by_name, name)
                    if existing[key_xyz(x, y, cz)] then
                        walls_with_construction = walls_with_construction + 1
                        add_count(by_name_with_construction, name)
                    end
                end
            end
        end
    end

    log(("Diag walls around adventurer r=%d: walls_seen=%d walls_with_construction=%d"):format(
        r, walls_seen, walls_with_construction))
    if S.debug then
        log_top_counts("diag wall tiletype", by_name, 20)
        log_top_counts("diag wall tiletype with construction", by_name_with_construction, 20)
    end
end

local function convert_map_constructions(policy, force)
    local wm = df.global.world.map

    local constructions = df.global.world.event.constructions
    local block_cache = {}
    local road_cache = {}
    local mat_cache = {}

    local changed_hardwood = 0
    local skipped_hardwood = 0
    local changed_stone = 0
    local already_target = 0
    local skipped_roads = 0
    local considered = 0
    local token_counts = {}
    local mode_counts = {}
    local unresolved_counts = {}
    local matpair_counts = {}
    local hardwood_keys = {}
    local existing = {}
    local fallback_wall_changed = 0
    local fallback_wall_inserted = 0
    local fallback_wall_candidates = 0
    local natural_floor_inserted = 0
    local glass_walls_placed = 0
    local iron_fortifications_placed = 0

    local function get_matinfo(mat_type, mat_index)
        local mk = ("%d:%d"):format(mat_type, mat_index)
        local cached = mat_cache[mk]
        if cached ~= nil then
            if cached == false then return nil, nil end
            return cached.token, cached.info
        end
        local token, info = decode_token(mat_type, mat_index)
        if not token or not info then
            mat_cache[mk] = false
            return nil, nil
        end
        mat_cache[mk] = {token = token, info = info}
        return token, info
    end

    local function is_road(c)
        local k = key_xyz(c.pos.x, c.pos.y, c.pos.z)
        local v = road_cache[k]
        if v ~= nil then return v end
        v = likely_worldgen_road_construction(c, block_cache)
        road_cache[k] = v
        return v
    end

    local function is_loaded_construction(c)
        return dfhack.maps.getTileBlock(c.pos) ~= nil
    end

    -- Build connected hardwood groups so hamlet policy applies per-house, not per-tile.
    if policy.is_hamlet then
        local hardwood_lookup = {}
        for i = 0, #constructions - 1 do
            local c = constructions[i]
            if is_loaded_construction(c) then
                if not is_road(c) then
                    local token = get_matinfo(c.mat_type, c.mat_index)
                    if token == HARDWOOD_LOG_TOKEN or token == HARDWOOD_LOG_TOKEN_LEGACY then
                        local k = key_xyz(c.pos.x, c.pos.y, c.pos.z)
                        hardwood_lookup[k] = c
                    end
                end
            end
        end

        local seen = {}
        for root_k, root_c in pairs(hardwood_lookup) do
            if not seen[root_k] then
                local stack = {root_c}
                local component = {}
                seen[root_k] = true
                while #stack > 0 do
                    local cur = stack[#stack]
                    stack[#stack] = nil
                    local ck = key_xyz(cur.pos.x, cur.pos.y, cur.pos.z)
                    component[#component + 1] = cur
                    local nbrs = {
                        {cur.pos.x + 1, cur.pos.y, cur.pos.z},
                        {cur.pos.x - 1, cur.pos.y, cur.pos.z},
                        {cur.pos.x, cur.pos.y + 1, cur.pos.z},
                        {cur.pos.x, cur.pos.y - 1, cur.pos.z},
                        {cur.pos.x, cur.pos.y, cur.pos.z + 1},
                        {cur.pos.x, cur.pos.y, cur.pos.z - 1},
                    }
                    for _, n in ipairs(nbrs) do
                        local nk = key_xyz(n[1], n[2], n[3])
                        local nc = hardwood_lookup[nk]
                        if nc and not seen[nk] then
                            seen[nk] = true
                            stack[#stack + 1] = nc
                        end
                    end
                end

                local rep = component[1]
                local do_convert = should_convert_hardwood_id(
                    policy.site_id, rep.pos.x, rep.pos.y, rep.pos.z, policy.hardwood_percent)
                for _, cc in ipairs(component) do
                    hardwood_keys[key_xyz(cc.pos.x, cc.pos.y, cc.pos.z)] = do_convert
                end
            end
        end
    end

    -- Single pass: classify + convert non-road constructions.
    for i = 0, #constructions - 1 do
        local c = constructions[i]
        existing[key_xyz(c.pos.x, c.pos.y, c.pos.z)] = c
        if is_loaded_construction(c) then
            if is_road(c) then
                skipped_roads = skipped_roads + 1
            else
                considered = considered + 1
                local token, info = get_matinfo(c.mat_type, c.mat_index)
                if token then
                    add_count(token_counts, token)
                else
                    add_count(unresolved_counts, ("%d:%d"):format(c.mat_type, c.mat_index))
                end
                add_count(matpair_counts, ("%d:%d"):format(c.mat_type, c.mat_index))
                if info then
                    add_count(mode_counts, info.mode or "<nil>")
                else
                    add_count(mode_counts, "<unresolved>")
                end
                if token == HARDWOOD_LOG_TOKEN or token == HARDWOOD_LOG_TOKEN_LEGACY then
                    local allow = true
                    if policy.is_hamlet then
                        local hk = key_xyz(c.pos.x, c.pos.y, c.pos.z)
                        allow = hardwood_keys[hk] == true
                    end
                    if allow then
                        -- Classify by tile shape: floor→stoneware/hardwood, else→earthenware wall.
                        local block2, lx2, ly2 = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
                        local shape2 = nil
                        if block2 then
                            local attrs2 = df.tiletype.attrs[block2.tiletype[lx2][ly2]]
                            if attrs2 then shape2 = attrs2.shape end
                        end
                        if shape2 == df.tiletype_shape_basic.Floor then
                            -- Check tile above: open sky above = roof, solid/walled above = interior floor.
                            local is_roof = false
                            local block_a, lx_a, ly_a = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z + 1)
                            if block_a then
                                local tt_a = block_a.tiletype[lx_a][ly_a]
                                local attrs_a = df.tiletype.attrs[tt_a]
                                if attrs_a and attrs_a.shape == df.tiletype_shape_basic.Open
                                    and block_a.designation[lx_a][ly_a].outside then
                                    is_roof = true
                                end
                            else
                                -- No block loaded above: assume open sky (roof).
                                is_roof = true
                            end
                            if is_roof then
                                -- Roof → stoneware tile.
                                if set_construction_material(c, STONEWARE_MAT_TYPE, STONEWARE_MAT_INDEX) then
                                    c.item_type = df.item_type.BLOCKS
                                    changed_hardwood = changed_hardwood + 1
                                else
                                    already_target = already_target + 1
                                end
                            else
                                -- Ground floor → keep hardwood material, fix item_type.
                                if c.item_type ~= df.item_type.BLOCKS then
                                    c.item_type = df.item_type.BLOCKS
                                    changed_hardwood = changed_hardwood + 1
                                else
                                    already_target = already_target + 1
                                end
                            end
                        else
                            -- Wall, ramp, stair, etc. → earthenware.
                            if set_construction_material(c, EARTHENWARE_MAT_TYPE, EARTHENWARE_MAT_INDEX) then
                                c.item_type = df.item_type.BLOCKS
                                changed_hardwood = changed_hardwood + 1
                            else
                                already_target = already_target + 1
                            end
                        end
                    else
                        skipped_hardwood = skipped_hardwood + 1
                    end
                elseif is_stone_for_concrete(info) or is_builtin_inorganic(token, info)
                    or c.item_type == df.item_type.BOULDER then
                    if set_construction_material(c, CONCRETE_MAT_TYPE, CONCRETE_MAT_INDEX) then
                        changed_stone = changed_stone + 1
                    else
                        already_target = already_target + 1
                    end
                elseif not token then
                    -- unresolvable material: if the tile is a construction-type wall, assume stone → concrete
                    local block2, lx2, ly2 = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
                    if block2 then
                        local tt2 = block2.tiletype[lx2][ly2]
                        local attrs2 = df.tiletype.attrs[tt2]
                        if attrs2 and attrs2.material == df.tiletype_material.CONSTRUCTION then
                            local shape2 = attrs2.shape
                            if shape2 == df.tiletype_shape_basic.Wall or shape2 == df.tiletype_shape_basic.Fortification then
                                if set_construction_material(c, CONCRETE_MAT_TYPE, CONCRETE_MAT_INDEX) then
                                    changed_stone = changed_stone + 1
                                else
                                    already_target = already_target + 1
                                end
                            end
                        end
                    end
                end
            end
        end
    end

    -- Pass 2: natural stone wall tiles without construction records.
    -- Uses stone_constr_tt_cache (precomputed from STONE_CONSTR_RULES) for O(1) per-tile lookup.

    -- Reset block cache on site change or explicit force.
    if force or policy.site_id ~= S.last_site_id then
        S.processed_blocks = {}
        S.last_site_id = policy.site_id
    end

    for _, block in ipairs(wm.map_blocks) do
        local bk = ("%d,%d,%d"):format(block.map_pos.x, block.map_pos.y, block.map_pos.z)
        if not S.processed_blocks[bk] then
        S.processed_blocks[bk] = true
        for lx = 0, 15 do
            for ly = 0, 15 do
                local tt = block.tiletype[lx][ly]
                local cached = stone_constr_tt_cache[tt]
                local target_tt = false
                if cached and (not cached.inside_only or not block.designation[lx][ly].outside) then
                    target_tt = cached.target  -- nil = record only, number = rewrite tiletype
                end
                if target_tt ~= false then
                    local x = block.map_pos.x + lx
                    local y = block.map_pos.y + ly
                    local z = block.map_pos.z
                    fallback_wall_candidates = fallback_wall_candidates + 1
                    local k = key_xyz(x, y, z)
                    if not existing[k] then
                        local c2 = df.construction:new()
                        c2.pos.x = x; c2.pos.y = y; c2.pos.z = z
                        c2.mat_type = CONCRETE_MAT_TYPE
                        c2.mat_index = CONCRETE_MAT_INDEX
                        c2.original_tile = tt
                        if dfhack.constructions.insert(c2) then
                            fallback_wall_inserted = fallback_wall_inserted + 1
                            existing[k] = c2
                        end
                        if target_tt then
                            block.tiletype[lx][ly] = target_tt
                        end
                    elseif target_tt then
                        -- Record exists but tiletype not yet rewritten.
                        block.tiletype[lx][ly] = target_tt
                    end
                elseif HARDWOOD_MAT_TYPE then
                    -- Natural floor tiles inside surface buildings → hardwood wood floor.
                    local attrs_f = df.tiletype.attrs[tt]
                    if attrs_f and attrs_f.shape == df.tiletype_shape_basic.Floor then
                        local mat_f = attrs_f.material
                        if mat_f ~= df.tiletype_material.CONSTRUCTION
                            and mat_f ~= df.tiletype_material.GRASS
                            and mat_f ~= df.tiletype_material.PLANT then
                            local desig_f = block.designation[lx][ly]
                            if not desig_f.outside and not desig_f.subterranean then
                                local x_f = block.map_pos.x + lx
                                local y_f = block.map_pos.y + ly
                                local z_f = block.map_pos.z
                                local k_f = key_xyz(x_f, y_f, z_f)
                                if not existing[k_f] then
                                    local cf = df.construction:new()
                                    cf.pos.x = x_f; cf.pos.y = y_f; cf.pos.z = z_f
                                    cf.mat_type = HARDWOOD_MAT_TYPE
                                    cf.mat_index = HARDWOOD_MAT_INDEX
                                    cf.original_tile = tt
                                    cf.item_type = df.item_type.BLOCKS
                                    if dfhack.constructions.insert(cf) then
                                        natural_floor_inserted = natural_floor_inserted + 1
                                        existing[k_f] = cf
                                        if CONSTRUCTED_FLOOR_TT then
                                            block.tiletype[lx][ly] = CONSTRUCTED_FLOOR_TT
                                        end
                                    end
                                end
                            end
                        end
                    end
                end
            end
        end
        end -- if not S.processed_blocks[bk]
    end

    -- Pass 3: Glass fortifications in earthenware buildings; iron fortifications in concrete buildings.
    -- Runs every map_key change. Already-processed components are detected by adjacency to
    -- existing glass/iron-fortification tiles, so they are skipped without a separate cache.

    local function is_wall_name(name)
        return name:find("Wall") ~= nil or name:find("Fortif") ~= nil or name:find("Pillar") ~= nil
    end

    local function is_perimeter_wall(x, y, z)
        for _, d in ipairs({{1,0},{-1,0},{0,1},{0,-1}}) do
            local nb, nlx, nly = get_block_and_local(block_cache, x+d[1], y+d[2], z)
            if not nb then return true end
            local tt_name = tostring(df.tiletype[nb.tiletype[nlx][nly]] or "")
            if not is_wall_name(tt_name) then return true end
        end
        return false
    end

    local function build_wall_components(mat_type, mat_index)
        local wall_pos = {}
        for k, c in pairs(existing) do
            if c.mat_type == mat_type and c.mat_index == mat_index then
                local b, lx, ly = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
                if b then
                    local tt_name = tostring(df.tiletype[b.tiletype[lx][ly]] or "")
                    if tt_name:find("^ConstructedWall") then
                        wall_pos[k] = c
                    end
                end
            end
        end
        local comps, visited = {}, {}
        for k, c in pairs(wall_pos) do
            if not visited[k] then
                local comp, stack = {}, {c}
                visited[k] = true
                while #stack > 0 do
                    local cur = stack[#stack]; stack[#stack] = nil
                    comp[#comp+1] = cur
                    for _, d in ipairs({{1,0,0},{-1,0,0},{0,1,0},{0,-1,0},{0,0,1},{0,0,-1}}) do
                        local nk = key_xyz(cur.pos.x+d[1], cur.pos.y+d[2], cur.pos.z+d[3])
                        if wall_pos[nk] and not visited[nk] then
                            visited[nk] = true
                            stack[#stack+1] = wall_pos[nk]
                        end
                    end
                end
                comps[#comps+1] = comp
            end
        end
        return comps
    end

    -- Returns true if any tile in comp has a 6-directional neighbor in key_set.
    local function comp_has_neighbor_in(comp, key_set)
        for _, c in ipairs(comp) do
            for _, d in ipairs({{1,0,0},{-1,0,0},{0,1,0},{0,-1,0},{0,0,1},{0,0,-1}}) do
                if key_set[key_xyz(c.pos.x+d[1], c.pos.y+d[2], c.pos.z+d[3])] then
                    return true
                end
            end
        end
        return false
    end

    local function is_door_construction(c)
        if c.item_type == df.item_type.DOOR then
            return true
        end
        local b, lx, ly = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
        if not b then return false end
        local tn = tostring(df.tiletype[b.tiletype[lx][ly]] or "")
        return tn:find("Door") ~= nil
    end

    -- Bridges are typically outside and doorless; require at least one
    -- building-like signal before placing iron fortifications.
    local function comp_looks_like_building(comp)
        for _, c in ipairs(comp) do
            for _, d in ipairs({{1,0,0},{-1,0,0},{0,1,0},{0,-1,0}}) do
                local nx, ny, nz = c.pos.x + d[1], c.pos.y + d[2], c.pos.z + d[3]
                local b, lx, ly = get_block_and_local(block_cache, nx, ny, nz)
                if b and not b.designation[lx][ly].outside then
                    return true
                end
                local ncons = existing[key_xyz(nx, ny, nz)]
                if ncons and is_door_construction(ncons) then
                    return true
                end
            end
        end
        return false
    end

    -- Some bridge constructions are represented with tile names containing
    -- "bridge". Skip these in the iron-fortification window pass.
    local function comp_is_bridge_named(comp)
        for _, c in ipairs(comp) do
            local b, lx, ly = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
            if b then
                local tn = tostring(df.tiletype[b.tiletype[lx][ly]] or ""):lower()
                if tn:find("bridge") then
                    return true
                end
            end
        end
        return false
    end

    -- Glass fortifications: 1–2 per earthenware building, on perimeter walls.
    if GLASS_CLEAR_MAT_TYPE then
        -- Build set of existing glass tiles to detect already-processed buildings.
        local glass_keys = {}
        for k, c in pairs(existing) do
            if c.mat_type == GLASS_CLEAR_MAT_TYPE and c.mat_index == GLASS_CLEAR_MAT_INDEX then
                glass_keys[k] = true
            end
        end
        for _, comp in ipairs(build_wall_components(EARTHENWARE_MAT_TYPE, EARTHENWARE_MAT_INDEX)) do
            if not comp_has_neighbor_in(comp, glass_keys) then
                local perimeter = {}
                for _, c in ipairs(comp) do
                    if is_perimeter_wall(c.pos.x, c.pos.y, c.pos.z) then
                        perimeter[#perimeter+1] = c
                    end
                end
                if #perimeter > 0 then
                    local rep = comp[1]
                    local count = (hash_percent(policy.site_id, rep.pos.x+1, rep.pos.y, rep.pos.z) % 2) + 1
                    table.sort(perimeter, function(a, b)
                        return hash_percent(policy.site_id, a.pos.x, a.pos.y, a.pos.z) <
                               hash_percent(policy.site_id, b.pos.x, b.pos.y, b.pos.z)
                    end)
                    for i = 1, math.min(count, #perimeter) do
                        local c = perimeter[i]
                        c.mat_type = GLASS_CLEAR_MAT_TYPE
                        c.mat_index = GLASS_CLEAR_MAT_INDEX
                        glass_keys[key_xyz(c.pos.x, c.pos.y, c.pos.z)] = true
                        local b, lx, ly = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
                        if b then
                            local cur_name = tostring(df.tiletype[b.tiletype[lx][ly]] or "")
                            local suffix = cur_name:match("ConstructedWall([LRUD]*)$") or ""
                            b.tiletype[lx][ly] = constructed_fortification_by_suffix[suffix]
                                or constructed_fortification_by_suffix[""]
                                or CONSTRUCTED_WALL_TT
                        end
                        glass_walls_placed = glass_walls_placed + 1
                    end
                end
            end
        end
    end

    -- Iron fortifications: 2–10 per concrete building, on ground-floor perimeter walls.
    if IRON_MAT_TYPE then
        -- Build set of existing iron-fortification tiles to detect already-processed buildings.
        local iron_fort_keys = {}
        for k, c in pairs(existing) do
            if c.mat_type == IRON_MAT_TYPE and c.mat_index == IRON_MAT_INDEX then
                local b, lx, ly = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
                if b then
                    local tn = tostring(df.tiletype[b.tiletype[lx][ly]] or "")
                    if tn:find("Fortif") then iron_fort_keys[k] = true end
                end
            end
        end
        for _, comp in ipairs(build_wall_components(CONCRETE_MAT_TYPE, CONCRETE_MAT_INDEX)) do
            if not comp_has_neighbor_in(comp, iron_fort_keys) then
                if not comp_is_bridge_named(comp) and comp_looks_like_building(comp) then
                    local candidates = {}
                    for _, c in ipairs(comp) do
                        if is_perimeter_wall(c.pos.x, c.pos.y, c.pos.z) then
                            local b_below, lx_b, ly_b = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z - 1)
                            local is_ground = true
                            if b_below then
                                local ab = df.tiletype.attrs[b_below.tiletype[lx_b][ly_b]]
                                if ab and ab.shape == df.tiletype_shape_basic.Open then
                                    is_ground = false
                                end
                            end
                            if is_ground then candidates[#candidates+1] = c end
                        end
                    end
                    if #candidates > 0 then
                        local rep = comp[1]
                        local count = (hash_percent(policy.site_id, rep.pos.x+1, rep.pos.y, rep.pos.z) % 9) + 2
                        table.sort(candidates, function(a, b)
                            return hash_percent(policy.site_id, a.pos.x, a.pos.y, a.pos.z) <
                                   hash_percent(policy.site_id, b.pos.x, b.pos.y, b.pos.z)
                        end)
                        for i = 1, math.min(count, #candidates) do
                            local c = candidates[i]
                            c.mat_type = IRON_MAT_TYPE
                            c.mat_index = IRON_MAT_INDEX
                            iron_fort_keys[key_xyz(c.pos.x, c.pos.y, c.pos.z)] = true
                            local b, lx, ly = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
                            if b then
                                local cur_name = tostring(df.tiletype[b.tiletype[lx][ly]] or "")
                                local suffix = cur_name:match("ConstructedWall([LRUD]*)$") or ""
                                b.tiletype[lx][ly] = constructed_fortification_by_suffix[suffix]
                                    or constructed_fortification_by_suffix[""]
                                    or CONSTRUCTED_WALL_TT
                            end
                            iron_fortifications_placed = iron_fortifications_placed + 1
                        end
                    end
                end
            end
        end
    end

    if S.debug then
        dlog(("construction material scan: considered=%d skipped_roads=%d unique_tokens=%d unique_unresolved=%d"):format(
            considered, skipped_roads, (function() local n=0 for _ in pairs(token_counts) do n=n+1 end return n end)(),
            (function() local n=0 for _ in pairs(unresolved_counts) do n=n+1 end return n end)()))
        log_top_counts("top token", token_counts, 20)
        log_top_counts("top mode", mode_counts, 10)
        log_top_counts("top mat_type:mat_index", matpair_counts, 20)
        log_top_counts("top unresolved mat_type:mat_index", unresolved_counts, 20)
    end

    return {
        considered = considered,
        skipped_roads = skipped_roads,
        changed_hardwood = changed_hardwood,
        skipped_hardwood = skipped_hardwood,
        changed_stone = changed_stone,
        fallback_wall_candidates = fallback_wall_candidates,
        fallback_wall_changed = fallback_wall_changed,
        fallback_wall_inserted = fallback_wall_inserted,
        natural_floor_inserted = natural_floor_inserted,
        glass_walls_placed = glass_walls_placed,
        iron_fortifications_placed = iron_fortifications_placed,
        already_target = already_target,
    }
end

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

    if not find_materials() then 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 'building force' to run again.")
        return
    end

    local policy = get_site_policy()
    local map_stats = convert_map_constructions(policy, force)

    S.last_map_key = this_map_key

    dlog(("site_policy: site_id=%d site_type=%s hamlet=%s hardwood_percent=%d"):format(
        policy.site_id, policy.site_type, tostring(policy.is_hamlet), policy.hardwood_percent))
    log(("Converted map constructions (roads skipped): considered=%d skipped_roads=%d hardwood_converted=%d hardwood_kept=%d stone_to_concrete=%d wall_fallback_candidates=%d wall_fallback_changed=%d wall_fallback_inserted=%d natural_floor_inserted=%d glass_walls=%d iron_fortifications=%d already_target=%d policy=%s/%d%%"):format(
        map_stats.considered, map_stats.skipped_roads, map_stats.changed_hardwood, map_stats.skipped_hardwood, map_stats.changed_stone, map_stats.fallback_wall_candidates, map_stats.fallback_wall_changed, map_stats.fallback_wall_inserted, map_stats.natural_floor_inserted, map_stats.glass_walls_placed, map_stats.iron_fortifications_placed, map_stats.already_target, policy.site_type, policy.hardwood_percent))
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_buildings(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 schedule_initial_force()
    S.init_force_gen = S.init_force_gen + 1
    local gen = S.init_force_gen
    dfhack.timeout(INITIAL_FORCE_DELAY_TICKS, "ticks", function()
        if gen ~= S.init_force_gen then return end
        if not dfhack.isMapLoaded() then return end
        convert_buildings(true, true)
    end)
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 function inspect_tiles(radius)
    if not dfhack.isMapLoaded() then log("No map loaded.") return end
    local adv = dfhack.world.getAdventurer()
    if not adv or not adv.pos then log("No active adventurer.") return end
    local r = tonumber(radius) or 3
    local constructions = df.global.world.event.constructions
    local existing = {}
    for i = 0, #constructions - 1 do
        local c = constructions[i]
        existing[key_xyz(c.pos.x, c.pos.y, c.pos.z)] = c
    end
    local cx, cy, cz = adv.pos.x, adv.pos.y, adv.pos.z
    for dy = -r, r do
        for dx = -r, r do
            local x, y, z = cx + dx, cy + dy, cz
            local block = dfhack.maps.getTileBlock(x, y, z)
            if block then
                local lx, ly = x % 16, y % 16
                local tt = block.tiletype[lx][ly]
                local attrs = df.tiletype.attrs[tt]
                if attrs then
                    local shape_basic = attrs.shape
                    local shape_str = tostring(df.tiletype_shape_basic[shape_basic] or shape_basic)
                    if shape_str ~= "Open" and shape_str ~= "Floor" and shape_str ~= "None" then
                        local mat_str = tostring(df.tiletype_material[attrs.material] or attrs.material)
                        local name = tostring(df.tiletype[tt] or "tt_" .. tostring(tt))
                        local bld = block.occupancy[lx][ly].building
                        local outside = block.designation[lx][ly].outside
                        local c = existing[key_xyz(x, y, z)]
                        local cinfo = "none"
                        if c then
                            local itype = tostring(df.item_type[c.item_type] or c.item_type)
                            cinfo = ("mat=%d:%d item_type=%s"):format(c.mat_type, c.mat_index, itype)
                        end
                        log(("  [%d,%d,%d] %s | mat=%s shape=%s | out=%s bld=%d | cons: %s"):format(
                            x, y, z, name, mat_str, shape_str, tostring(outside), bld, cinfo))
                    end
                end
            end
        end
    end
end

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

if cmd == "enable" then
    convert_buildings(false)
    start_watcher()
    schedule_initial_force()
elseif cmd == "force" then
    convert_buildings(true)
elseif cmd == "inspect" then
    inspect_tiles(args[2])
elseif cmd == "diagwalls" then
    diag_walls(args[2])
elseif cmd == "disable" then
    S.init_force_gen = S.init_force_gen + 1
    stop_watcher()
    S.last_map_key = nil
    S.processed_blocks = {}
    S.last_site_id = nil
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: building [enable|force|inspect [r]|diagwalls [r]|disable|status|debug [on|off]]")
end