xabbo-scripts/User Collector Hopper Advanced.csx

/// @name User Collector + Auto Hopper
/// @desc Sammelt User-Namen und hoppt automatisch durch Raeume
/// @author OpenCode
/// @scripter 1.0.0-beta.136

// ============ EINSTELLUNGEN ============
int minUsers = 5;           // Minimum User im Raum
int waitInRoom = 6000;      // Wie lange in jedem Raum bleiben (ms)
int delayBetweenRooms = 2000; // Pause zwischen Raumwechsel (ms)
// ========================================

// Pfad zur Ausgabedatei auf dem Desktop
var desktopPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
var outputFile = Path.Combine(desktopPath, "HabboUserList.txt");

// HashSet um Duplikate zu vermeiden
var collectedUsers = new HashSet<string>();

// Besuchte Raeume tracken
var visitedRooms = new HashSet<long>();

// Raeume Queue - sortiert nach User-Anzahl
var roomQueue = new List<(long Id, string Name, int UserCount)>();

// Lade bereits gesammelte User aus der Datei (falls vorhanden)
if (File.Exists(outputFile))
{
    var lines = File.ReadAllLines(outputFile);
    foreach (var line in lines)
    {
        if (!string.IsNullOrWhiteSpace(line))
            collectedUsers.Add(line.Trim());
    }
    Log($"Loaded: {collectedUsers.Count} users from file");
}

Log("=================================");
Log("User Collector + Auto Hopper");
Log($"Min. users per room: {minUsers}");
Log("=================================");
Log("HOW TO USE:");
Log("1. Open Navigator in game");
Log("2. Click 'Rooms' -> 'Popular'");
Log("3. Script catches the rooms");
Log("4. Type :start to begin hopping");
Log("=================================");
Log("Commands: :start :stop :status :reset");
Log("=================================");

// Hopping aktiv?
bool isHopping = false;

// Event: Wenn jemand den Raum betritt
OnEntityAdded(e => {
    if (e.Entity is IRoomUser user)
    {
        var userName = user.Name;
        if (collectedUsers.Add(userName))
        {
            File.AppendAllText(outputFile, userName + "\n");
            Log($"+ {userName}");
        }
    }
});

// Intercept Navigator Suchergebnisse (Navigator2)
OnIntercept(In.Navigator2SearchResultBlocks, e => {
    try 
    {
        var packet = e.Packet;
        var searchCode = packet.ReadString();
        var filterText = packet.ReadString();
        var blockCount = packet.ReadInt();
        
        int foundRooms = 0;
        
        for (int b = 0; b < blockCount; b++)
        {
            var blockCode = packet.ReadString();
            var blockText = packet.ReadString();
            var actionAllowed = packet.ReadInt();
            var forceClosed = packet.ReadBool();
            var roomCount = packet.ReadInt();
            
            for (int r = 0; r < roomCount; r++)
            {
                var roomId = packet.ReadLong();
                var roomName = packet.ReadString();
                var ownerId = packet.ReadLong();
                var ownerName = packet.ReadString();
                var doorMode = packet.ReadInt();
                var userCount = packet.ReadInt();
                var maxUsers = packet.ReadInt();
                var description = packet.ReadString();
                var tradeMode = packet.ReadInt();
                var score = packet.ReadInt();
                var ranking = packet.ReadInt();
                var categoryId = packet.ReadInt();
                
                // Tags
                var tagCount = packet.ReadInt();
                for (int t = 0; t < tagCount; t++)
                    packet.ReadString();
                
                // Flags
                var flags = packet.ReadInt();
                if ((flags & 1) != 0) packet.ReadString();
                if ((flags & 2) != 0) packet.ReadString();
                if ((flags & 4) != 0) { packet.ReadString(); packet.ReadLong(); packet.ReadString(); }
                
                // Raum hinzufuegen
                if (userCount >= minUsers && !visitedRooms.Contains(roomId))
                {
                    if (!roomQueue.Any(x => x.Id == roomId))
                    {
                        roomQueue.Add((roomId, roomName, userCount));
                        foundRooms++;
                    }
                }
            }
        }
        
        if (foundRooms > 0)
        {
            // Sort by user count (most first)
            roomQueue = roomQueue.OrderByDescending(x => x.UserCount).ToList();
            Log($"+ {foundRooms} new rooms found! (Total: {roomQueue.Count})");
            Status($"Queue: {roomQueue.Count} rooms | Users: {collectedUsers.Count}");
        }
    }
    catch (Exception ex)
    {
        Log($"Parse-Fehler: {ex.Message}");
    }
});

// Chat-Befehl zum Starten
OnIntercept(Out.Chat, e => {
    var msg = e.Packet.ReadString(0);
    if (msg == ":start")
    {
        e.Block();
        if (roomQueue.Count > 0)
        {
            isHopping = true;
            Log($"Starting hopping through {roomQueue.Count} rooms...");
        }
        else
        {
            Log("No rooms in queue! Open Navigator -> Popular");
        }
    }
    else if (msg == ":stop")
    {
        e.Block();
        isHopping = false;
        Log("Hopping stopped.");
    }
    else if (msg == ":status")
    {
        e.Block();
        Log($"Queue: {roomQueue.Count} | Visited: {visitedRooms.Count} | Users: {collectedUsers.Count}");
    }
    else if (msg == ":reset")
    {
        e.Block();
        visitedRooms.Clear();
        roomQueue.Clear();
        Log("Reset! Open Navigator again.");
    }
});

// Hauptschleife
while (Run)
{
    // User im aktuellen Raum sammeln
    if (IsInRoom)
    {
        foreach (var user in Users)
        {
            if (collectedUsers.Add(user.Name))
            {
                File.AppendAllText(outputFile, user.Name + "\n");
                Log($"+ {user.Name}");
            }
        }
    }
    
    // Hopping wenn aktiv
    if (isHopping && roomQueue.Count > 0)
    {
        var room = roomQueue[0];
        roomQueue.RemoveAt(0);
        
        if (!visitedRooms.Contains(room.Id))
        {
            visitedRooms.Add(room.Id);
            Log($">>> {room.Name} ({room.UserCount} User)");
            
            Send(Out.GoToFlat, room.Id, "", -1);
            Delay(3500);
            
            if (IsInRoom)
            {
                // User sammeln
                foreach (var user in Users)
                {
                    if (collectedUsers.Add(user.Name))
                    {
                        File.AppendAllText(outputFile, user.Name + "\n");
                        Log($"+ {user.Name}");
                    }
                }
                
                Status($"Users: {collectedUsers.Count} | Rooms: {visitedRooms.Count} | Queue: {roomQueue.Count}");
                
                // Warten
                Delay(waitInRoom);
                
                // Nochmal sammeln (fuer Joiner)
                foreach (var user in Users)
                {
                    if (collectedUsers.Add(user.Name))
                    {
                        File.AppendAllText(outputFile, user.Name + "\n");
                        Log($"+ {user.Name}");
                    }
                }
            }
            
            Delay(delayBetweenRooms);
        }
    }
    else if (isHopping && roomQueue.Count == 0)
    {
        isHopping = false;
        Log($"=== DONE! ===");
        Log($"Visited: {visitedRooms.Count} rooms");
        Log($"Collected: {collectedUsers.Count} users");
        Log("Open Navigator for more rooms, then :start");
    }
    
    Status($"Users: {collectedUsers.Count} | Queue: {roomQueue.Count}");
    Delay(1000);
}