tilecheck.lua

-- tilecheck.lua - diagnostics for roads and tiletypes

local args = {...}

local function print_cursor_tile_info()
    if not dfhack.isMapLoaded() then
        print("[tilecheck] No map loaded.")
        return
    end

    local p = df.global.cursor
    if not p or p.x == -30000 then
        print("[tilecheck] Put the in-game cursor on a tile first, then run: tilecheck cursor")
        return
    end

    local block = dfhack.maps.getTileBlock(p)
    if not block then
        print(("[tilecheck] No map block at cursor (%d,%d,%d)"):format(p.x, p.y, p.z))
        return
    end

    local lx, ly = p.x % 16, p.y % 16
    local tt = block.tiletype[lx][ly]
    local attrs = df.tiletype.attrs[tt]
    local name = df.tiletype[tt] or "nil"
    local shape = attrs and df.tiletype_shape_basic[attrs.shape] or "?"
    local mat = attrs and df.tiletype_material[attrs.material] or "?"
    local occ = block.occupancy[lx][ly]
    local des = block.designation[lx][ly]

    print(("[tilecheck] cursor=(%d,%d,%d) tiletype=%d name=%s shape=%s mat=%s outside=%s building=%s"):format(
        p.x, p.y, p.z, tt, tostring(name), tostring(shape), tostring(mat),
        tostring(des and des.outside or false), tostring(occ and occ.building or false)))
end

local function scan_nearby_walls(radius)
    if not dfhack.isMapLoaded() then
        print("[tilecheck] No map loaded.")
        return
    end

    local p = df.global.cursor
    if not p or p.x == -30000 then
        print("[tilecheck] Put the in-game cursor near the area you want to scan, then run: tilecheck near")
        return
    end

    local r = tonumber(radius) or 20
    local floor = df.tiletype_shape_basic.Floor
    local wall = df.tiletype_shape_basic.Wall
    local constr = df.tiletype_material.CONSTRUCTION

    local seen = {}
    local total = 0
    print(("[tilecheck] scanning radius=%d around (%d,%d,%d)"):format(r, p.x, p.y, p.z))

    for y = p.y - r, p.y + r do
        for x = p.x - r, p.x + r do
            local pos = {x = x, y = y, z = p.z}
            local block = dfhack.maps.getTileBlock(pos)
            if block then
                local lx, ly = x % 16, y % 16
                local tt = block.tiletype[lx][ly]
                local a = df.tiletype.attrs[tt]
                if a then
                    local is_wall = (a.shape == wall)
                    local is_constr = (a.material == constr)
                    if is_wall or is_constr then
                        total = total + 1
                        if not seen[tt] then
                            seen[tt] = true
                            local shape = df.tiletype_shape_basic[a.shape] or "?"
                            local mat = df.tiletype_material[a.material] or "?"
                            local name = df.tiletype[tt] or "nil"
                            local occ = block.occupancy[lx][ly]
                            local des = block.designation[lx][ly]
                            print(("  tt=%d name=%s shape=%s mat=%s outside=%s building=%s"):format(
                                tt, tostring(name), tostring(shape), tostring(mat),
                                tostring(des and des.outside or false), tostring(occ and occ.building or false)))
                        end
                    elseif a.shape == floor and a.material == constr then
                        -- Also useful reference: constructed floors nearby
                        if not seen[tt] then
                            seen[tt] = true
                            local shape = df.tiletype_shape_basic[a.shape] or "?"
                            local mat = df.tiletype_material[a.material] or "?"
                            local name = df.tiletype[tt] or "nil"
                            print(("  tt=%d name=%s shape=%s mat=%s"):format(
                                tt, tostring(name), tostring(shape), tostring(mat)))
                        end
                    end
                end
            end
        end
    end

    print(("[tilecheck] scan complete; matching tiles visited=%d unique tiletypes listed above"):format(total))
end

local function scan_at_position(cx, cy, cz, radius, tag)
    local r = tonumber(radius) or 20
    local floor = df.tiletype_shape_basic.Floor
    local wall = df.tiletype_shape_basic.Wall
    local constr = df.tiletype_material.CONSTRUCTION

    local seen = {}
    local total = 0
    print(("[tilecheck] %s radius=%d around (%d,%d,%d)"):format(tag, r, cx, cy, cz))

    for y = cy - r, cy + r do
        for x = cx - r, cx + r do
            local pos = {x = x, y = y, z = cz}
            local block = dfhack.maps.getTileBlock(pos)
            if block then
                local lx, ly = x % 16, y % 16
                local tt = block.tiletype[lx][ly]
                local a = df.tiletype.attrs[tt]
                if a then
                    local is_wall = (a.shape == wall)
                    local is_constr = (a.material == constr)
                    if is_wall or is_constr or (a.shape == floor and a.material == constr) then
                        total = total + 1
                        if not seen[tt] then
                            seen[tt] = true
                            local shape = df.tiletype_shape_basic[a.shape] or "?"
                            local mat = df.tiletype_material[a.material] or "?"
                            local name = df.tiletype[tt] or "nil"
                            local occ = block.occupancy[lx][ly]
                            local des = block.designation[lx][ly]
                            print(("  tt=%d name=%s shape=%s mat=%s outside=%s building=%s"):format(
                                tt, tostring(name), tostring(shape), tostring(mat),
                                tostring(des and des.outside or false), tostring(occ and occ.building or false)))
                        end
                    end
                end
            end
        end
    end

    print(("[tilecheck] %s complete; matching tiles visited=%d"):format(tag, total))
end

local function scan_adventurer_near(radius)
    if not dfhack.isMapLoaded() then
        print("[tilecheck] No map loaded.")
        return
    end
    local adv = dfhack.world.getAdventurer()
    if not adv or not adv.pos then
        print("[tilecheck] No active adventurer found.")
        return
    end
    scan_at_position(adv.pos.x, adv.pos.y, adv.pos.z, radius, "advnear")
end

local function build_surface_z_map(map_blocks)
    local OPEN_SPACE = 32
    local surface_z = {}
    for _, block in ipairs(map_blocks) do
        local bz = block.map_pos.z
        for lx = 0, 15 do
            for ly = 0, 15 do
                local tt = block.tiletype[lx][ly]
                if tt ~= OPEN_SPACE then
                    local x = block.map_pos.x + lx
                    local y = block.map_pos.y + ly
                    local k = ("%d,%d"):format(x, y)
                    local cur = surface_z[k]
                    if not cur or bz > cur then
                        surface_z[k] = bz
                    end
                end
            end
        end
    end
    return surface_z
end

local function scan_map_center_near(radius)
    if not dfhack.isMapLoaded() then
        print("[tilecheck] No map loaded.")
        return
    end

    local r = tonumber(radius) or 20
    local wm = df.global.world.map
    local cx = math.floor(wm.x_count / 2)
    local cy = math.floor(wm.y_count / 2)
    local surface_z = build_surface_z_map(wm.map_blocks)

    local floor = df.tiletype_shape_basic.Floor
    local wall = df.tiletype_shape_basic.Wall
    local constr = df.tiletype_material.CONSTRUCTION
    local seen = {}
    local total = 0

    print(("[tilecheck] mapnear radius=%d center=(%d,%d)"):format(r, cx, cy))

    for y = cy - r, cy + r do
        for x = cx - r, cx + r do
            local z = surface_z[("%d,%d"):format(x, y)]
            if z then
                local pos = {x = x, y = y, z = z}
                local block = dfhack.maps.getTileBlock(pos)
                if block then
                    local lx, ly = x % 16, y % 16
                    local tt = block.tiletype[lx][ly]
                    local a = df.tiletype.attrs[tt]
                    if a then
                        local is_wall = (a.shape == wall)
                        local is_constr = (a.material == constr)
                        if is_wall or is_constr or (a.shape == floor and a.material == constr) then
                            total = total + 1
                            if not seen[tt] then
                                seen[tt] = true
                                local shape = df.tiletype_shape_basic[a.shape] or "?"
                                local mat = df.tiletype_material[a.material] or "?"
                                local name = df.tiletype[tt] or "nil"
                                local occ = block.occupancy[lx][ly]
                                local des = block.designation[lx][ly]
                                print(("  tt=%d name=%s shape=%s mat=%s outside=%s building=%s z=%d"):format(
                                    tt, tostring(name), tostring(shape), tostring(mat),
                                    tostring(des and des.outside or false), tostring(occ and occ.building or false), z))
                            end
                        end
                    end
                end
            end
        end
    end

    print(("[tilecheck] mapnear complete; matching tiles visited=%d"):format(total))
end

local function scan_wall_enum()
    local wall = df.tiletype_shape_basic.Wall
    local constr = df.tiletype_material.CONSTRUCTION
    local count = 0
    print("[tilecheck] wallenum: scanning tiletype attrs for CONSTRUCTION+Wall")

    for i = 0, 65535 do
        local a = df.tiletype.attrs[i]
        if a and a.shape == wall and a.material == constr then
            local name = df.tiletype[i] or "nil"
            print(("  tt=%d name=%s shape=%s mat=%s"):format(
                i, tostring(name), tostring(df.tiletype_shape_basic[a.shape]), tostring(df.tiletype_material[a.material])))
            count = count + 1
        end
    end

    print(("[tilecheck] wallenum complete; matches=%d"):format(count))
end

local function scan_wall_names()
    local count = 0
    print("[tilecheck] wallnames: listing tiletypes named ConstructedWall*")
    for i = 0, 65535 do
        local name = df.tiletype[i]
        if name and tostring(name):find("^ConstructedWall") then
            local a = df.tiletype.attrs[i]
            local shape = a and df.tiletype_shape_basic[a.shape] or "?"
            local mat = a and df.tiletype_material[a.material] or "?"
            print(("  tt=%d name=%s shape=%s mat=%s"):format(i, tostring(name), tostring(shape), tostring(mat)))
            count = count + 1
        end
    end
    print(("[tilecheck] wallnames complete; matches=%d"):format(count))
end

if args[1] == "cursor" then
    print_cursor_tile_info()
    return
end

if args[1] == "near" then
    scan_nearby_walls(args[2])
    return
end

if args[1] == "advnear" then
    scan_adventurer_near(args[2])
    return
end

if args[1] == "mapnear" then
    scan_map_center_near(args[2])
    return
end

if args[1] == "wallenum" then
    scan_wall_enum()
    return
end

if args[1] == "wallnames" then
    scan_wall_names()
    return
end

local cons = df.global.world.world_data.constructions
local wm = df.global.world.map
local rx, ry = wm.region_x, wm.region_y

local ok_t0, t0 = pcall(function() return df.world_construction_type[0] end)
print("world_construction_type[0]:", ok_t0 and t0 or "ERROR")
print(("region_x=%d region_y=%d"):format(rx, ry))

-- Diagnostic: map block coordinate system and map size
local b0 = df.global.world.map.map_blocks[0]
print(("map_blocks[0].map_pos = (%d, %d, %d)"):format(b0.map_pos.x, b0.map_pos.y, b0.map_pos.z))
print(("x_count=%d y_count=%d"):format(wm.x_count, wm.y_count))

local wx1 = math.floor(rx / 16)
local wx2 = math.floor((rx + 47) / 16)
local wy1 = math.floor(ry / 16)
local wy2 = math.floor((ry + 47) / 16)
print(("Loaded world tiles: x[%d-%d] y[%d-%d]"):format(wx1, wx2, wy1, wy2))

-- Diagnostic: sample tiletypes at the first few Formula-A road positions
local sample_coords = {}
local function maybe_add_sample(lx, ly)
    if lx >= 0 and ly >= 0 and #sample_coords < 8 then
        sample_coords[#sample_coords + 1] = {lx, ly}
    end
end

print("--- Tiletype samples at Formula-A road positions ---")
-- (filled below after we scan constructions; printed at end)

for ci = 0, #cons.list - 1 do
    local c = cons.list[ci]
    if c:getType() == 0 then -- Road
        local sp = c.square_pos
        for i = 0, #sp.x - 1 do
            local sx, sy = sp.x[i], sp.y[i]
            if sx >= wx1 and sx <= wx2 and sy >= wy1 and sy <= wy2 then
                local lx_wt = (sx * 16 - rx) * 3
                local ly_wt = (sy * 16 - ry) * 3
                print(("Road cons[%d] sq[%d] world(%d,%d) wt_local(%d,%d)"):format(
                    ci, i, sx, sy, lx_wt, ly_wt))
                pcall(function()
                    local sq = c.square_obj[i]
                    local ex, ey = sq.embark_x, sq.embark_y
                    for j = 0, #ex - 1 do
                        local exj, eyj = ex[j], ey[j]
                        -- hypothesis A: embark tile offset within world tile (0-15)
                        local lx_A = lx_wt + exj * 3
                        local ly_A = ly_wt + eyj * 3
                        -- hypothesis B: global sub-tile coord
                        local lx_B = (exj - rx) * 3
                        local ly_B = (eyj - ry) * 3
                        print(("  [%d] ex=%d ey=%d | A:local(%d,%d) | B:local(%d,%d)"):format(
                            j, exj, eyj, lx_A, ly_A, lx_B, ly_B))
                        maybe_add_sample(lx_A, ly_A)
                    end
                end)
            end
        end
    end
end

-- Print tiletype at each sampled road position.
-- Find the highest z-level that is NOT OpenSpace (32) = the actual surface ground.
local OPEN_SPACE = 32
for _, coord in ipairs(sample_coords) do
    local sx, sy = coord[1], coord[2]
    local bx, by = math.floor(sx / 16), math.floor(sy / 16)
    local lx, ly = sx % 16, sy % 16
    local best_block, best_z = nil, -999
    for _, bl in ipairs(df.global.world.map.map_blocks) do
        if bl.map_pos.x == bx * 16 and bl.map_pos.y == by * 16 then
            local tt = bl.tiletype[lx][ly]
            if tt ~= OPEN_SPACE and bl.map_pos.z > best_z then
                best_block = bl
                best_z = bl.map_pos.z
            end
        end
    end
    if best_block then
        local tt = best_block.tiletype[lx][ly]
        local name = df.tiletype[tt] or "nil"
        local shape = df.tiletype.attrs[tt] and df.tiletype_shape_basic[df.tiletype.attrs[tt].shape] or "?"
        print(("  sample (%d,%d) z=%d tiletype=%d [%s] shape=%s"):format(
            sx, sy, best_z, tt, name, tostring(shape)))
    else
        print(("  sample (%d,%d) -> no non-OpenSpace block found at block_xy=(%d,%d)"):format(
            sx, sy, bx * 16, by * 16))
    end
end