World and Player API

local tile_map = world:get_tile_map()
local size = tile_map:get_size()
logger.info("Width: {}, Height: {}", size.x, size.y)

local tile_map = world:get_tile_map()
local tiles = tile_map:get_tiles()

for i, tile in ipairs(tiles) do
    logger.info("Tile {} - FG: {}, BG: {}", i, tile.foreground, tile.background)
end

local object_map = world:get_object_map()
local objects = object_map:get_objects()

for i, obj in ipairs(objects) do
    logger.info("Object {} - ID: {}, Amount: {}", i, obj.item_id, obj.amount)
end

command.register("pos", "Show your position", function(ctx)
    local player = world:get_local_player()
    
    if not player then
        ctx:reply("`4Error: ``Not in a world")
        return false
    end
    
    ctx:reply("`2Position: ``({}, {})", player.position.x, player.position.y)
    ctx:reply("`2Net ID: ``{}", player.net_id)
    
    return true
end)

command.register("players", "List all players", function(ctx)
    local players = world:get_players()
    local count = 0
    
    for net_id, player in pairs(players) do
        count = count + 1
    end
    
    ctx:reply("`2Players in world: ``{}", count)
    
    for net_id, player in pairs(players) do
        local marker = player.is_local and "`2(You)`` " or ""
        ctx:reply("  {}[{}] {}", marker, net_id, player.name)
    end
    
    return true
end)

local last_position = nil

scheduler.schedule_periodic(1000, function()
    local player = world:get_local_player()
    
    if player then
        local current_pos = player.position
        
        if last_position then
            local dx = current_pos.x - last_position.x
            local dy = current_pos.y - last_position.y
            local distance = math.sqrt(dx * dx + dy * dy)
            
            if distance > 0 then
                logger.info("Moved {:.2f} tiles", distance)
            end
        end
        
        last_position = { x = current_pos.x, y = current_pos.y }
    end
    
    return true
end)

event.on("server:SendMapData", function(ctx)
    if ctx:has_packet() then
        local tile_map = world:get_tile_map()
        local size = tile_map:get_size()
        
        logger.info("World loaded: {}x{}", size.x, size.y)
        logger.info("World version: {}", world:get_version())
        
        local object_map = world:get_object_map()
        local objects = object_map:get_objects()
        logger.info("Dropped items: {}", #objects)
    end
end)

command.register("findplayer", "Find a player by name", function(ctx)
    if #ctx.args < 1 then
        ctx:reply("Usage: /findplayer <name>")
        return false
    end
    
    local search_name = ctx.args[1]:lower()
    local players = world:get_players()
    local found = {}
    
    for net_id, player in pairs(players) do
        if player.name:lower():find(search_name) then
            table.insert(found, player)
        end
    end
    
    if #found == 0 then
        ctx:reply("`4No players found matching '{}'", ctx.args[1])
    else
        ctx:reply("`2Found {} player(s):", #found)
        for _, player in ipairs(found) do
            ctx:reply("  [{}] {} ({})", player.net_id, player.name, player.country_code)
        end
    end
    
    return true
end)

command.register("scan", "Scan world for blocks", function(ctx)
    if #ctx.args < 1 then
        ctx:reply("Usage: /scan <item_id>")
        return false
    end
    
    local item_id = tonumber(ctx.args[1])
    if not item_id then
        ctx:reply("`4Error: ``Invalid item ID")
        return false
    end
    
    local tile_map = world:get_tile_map()
    local tiles = tile_map:get_tiles()
    local count = 0
    
    for i, tile in ipairs(tiles) do
        if tile.foreground == item_id or tile.background == item_id then
            count = count + 1
        end
    end
    
    ctx:reply("`2Found {} tiles with item ID {}", count, item_id)
    return true
end)

command.register("objects", "List dropped objects", function(ctx)
    local object_map = world:get_object_map()
    local objects = object_map:get_objects()
    
    if #objects == 0 then
        ctx:reply("`4No objects in world")
        return true
    end
    
    ctx:reply("`2Dropped objects: ``{}", #objects)
    
    local item_counts = {}
    for _, obj in ipairs(objects) do
        item_counts[obj.item_id] = (item_counts[obj.item_id] or 0) + obj.amount
    end
    
    for item_id, amount in pairs(item_counts) do
        local item = item_database:get_item(item_id)
        local name = item and item.item_name or "Unknown"
        ctx:reply("  {} x{}", name, amount)
    end
    
    return true
end)

local spawn_times = {}

event.on("OnSpawn", function(ctx)
    if ctx:has_packet() then
        local pkt = ctx:get_packet()
        spawn_times[pkt.net_id] = os.time()
        
        local player = world:get_player(pkt.net_id)
        if player then
            logger.info("Player {} spawned at ({}, {})",
                player.name,
                player.position.x,
                player.position.y
            )
        end
    end
end)

command.register("uptime", "Show player uptime", function(ctx)
    local player = world:get_local_player()
    if not player then
        ctx:reply("`4Error: ``Not in a world")
        return false
    end
    
    local spawn_time = spawn_times[player.net_id]
    if spawn_time then
        local uptime = os.time() - spawn_time
        local minutes = math.floor(uptime / 60)
        local seconds = uptime % 60
        
        ctx:reply("`2Uptime: ``{}m {}s", minutes, seconds)
    else
        ctx:reply("`4No spawn time recorded")
    end
    
    return true
end)