🆙 Bump version to 4.2.25 [skip ci]

Dev

Database Updates/006_Allow_Housekeeping_in_Client.sql

@@ -0,0 +1,17 @@
+INSERT INTO `permission_definitions` (`permission_key`, `max_value`, `comment`, `rank_1`, `rank_2`, `rank_3`, `rank_4`, `rank_5`, `rank_6`, `rank_7`) VALUES ('acc_housekeeping', '1', 'Allow housekeeping in the client', '0', '0', '0', '0', '0', '0', '1');
+
+
+CREATE TABLE IF NOT EXISTS `housekeeping_log` (
+  `id` INT NOT NULL AUTO_INCREMENT,
+  `timestamp` INT NOT NULL,
+  `actor_id` INT NOT NULL,
+  `actor_name` VARCHAR(64) NOT NULL DEFAULT '',
+  `target_type` VARCHAR(16) NOT NULL DEFAULT 'user',
+  `target_id` INT NOT NULL DEFAULT 0,
+  `target_label` VARCHAR(128) NOT NULL DEFAULT '',
+  `action` VARCHAR(64) NOT NULL DEFAULT '',
+  `detail` VARCHAR(500) NOT NULL DEFAULT '',
+  `success` TINYINT NOT NULL DEFAULT 1,
+  PRIMARY KEY (`id`),
+  KEY `timestamp` (`timestamp`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

Database Updates/007_Frank.sql

@@ -0,0 +1,70 @@
+ALTER TABLE `bots`
+  MODIFY COLUMN `type` ENUM('generic','visitor_log','bartender','weapons_dealer','frank')
+  NOT NULL DEFAULT 'generic';
+
+INSERT INTO `permission_definitions`
+  (`permission_key`, `max_value`, `comment`,
+   `rank_1`, `rank_2`, `rank_3`, `rank_4`, `rank_5`, `rank_6`, `rank_7`)
+VALUES
+  ('acc_bot_frank', 1, 'Required to purchase the Frank mascot bot from the catalog.',
+   0, 0, 0, 0, 0, 0, 1)
+ON DUPLICATE KEY UPDATE `comment` = VALUES(`comment`);
+
+
+CREATE TABLE IF NOT EXISTS `bot_chat_responses` (
+  `id` INT NOT NULL AUTO_INCREMENT,
+  `bot_type` VARCHAR(32) NOT NULL,
+  `keys` VARCHAR(255) NOT NULL COMMENT 'semicolon-separated trigger words',
+  `responses` TEXT NOT NULL COMMENT 'newline-separated replies; bot picks one at random',
+  PRIMARY KEY (`id`),
+  KEY `bot_type` (`bot_type`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+INSERT INTO `bot_chat_responses` (`bot_type`, `keys`, `responses`) VALUES
+('frank', '__door_triggers', 'show me the door\nkick me\ni want to leave\nlet me out'),
+('frank', '__door_lines', 'Right this way - mind the step!\nAnd out you go. Come back soon!\nAllow me to escort you to the exit.\nThere''s the door. Farewell, true believer!'),
+('frank', '__busy_whisper', 'Sorry, I am currently busy. Please wait until I am available.'),
+('frank', 'frank',         'Hello, I''m Frank! Welcome to Habbo.'),
+('frank', 'help',          'What do you need help with?'),
+('frank', 'thanks;thank you', 'Just doing my job, true believer!'),
+('frank', 'new',           'Welcome to Habbo! I hope you have a great time here.'),
+('frank', 'rooms',         'Looking for somewhere fun? Try the Navigator - thousands of rooms to explore!'),
+('frank', 'sulake',        'Sulake is the company behind Habbo. Take a look: https://www.sulake.com'),
+('frank', 'vip;hc',        'VIP gets you more outfits, more furni, more everything. Worth it!'),
+('frank', 'music',         'Snoop Dogg, Frank Sinatra and a little Beethoven on Sundays.'),
+('frank', 'movie',         'I''m a Casablanca man. Black and white films are an underrated art.'),
+('frank', 'game',          'Battleship. Always Battleship.'),
+('frank', 'snowstorm',     'Honestly? I''m terrible at Snowstorm. Don''t tell anyone.'),
+('frank', 'furni',         'Best furniture maker in town - hands down, the folks at Sulake.'),
+('frank', 'animal;cat;pet','I have a cat called Mr. Whiskers. He runs the place, really.'),
+('frank', 'miranda',       'Miranda. The love of my life. Don''t get me started.'),
+('frank', 'frank black',   'Named after the man himself. Frank Black is a hero of mine.'),
+('frank', 'life',          'Life is like a bowl of popcorn - warm, salty and buttery.'),
+('frank', 'job;work',      'I''m sure you can find work in one of the guest rooms!'),
+('frank', 'snouthill',     'Snouthill... so many memories.'),
+('frank', 'wife',          'I had a wife once. She broke my stereo.'),
+('frank', 'baseball',      'Oh, I used to love to go down to the old ball park and watch Christy Mathewson and Honus Wagner at bat.'),
+('frank', 'mark',          'I don''t trust Mark.'),
+('frank', 'vietnam',       'Vietnam? Don''t ask. Worst trip of my life.'),
+('frank', 'pills;drugs',   'Drugs are bad, mmkay?');
+
+INSERT IGNORE INTO `bot_serves` (`keys`, `item`) VALUES
+('sunflower',                                          1002),
+('cola;habbo cola',                                    19),
+('rose',                                               1000),
+('book',                                               1003),
+('tea',                                                27),
+('coffee',                                             8),
+('migraine;headache;pills',                            1015),
+('radioactive liquid;radioactive',                     30),
+('turkey;can of turkey',                               70);
+
+-- VERY IMPORTANT !!!!
+-- First check if the items_base ID and catalog_items ID is not in use !
+-- After the SQL please go to the catalog_items table and change the page_id to where your BOTS are located
+
+INSERT IGNORE INTO `items_base` (`id`, `sprite_id`, `item_name`, `public_name`, `width`, `length`, `stack_height`, `allow_stack`, `allow_sit`, `allow_lay`, `allow_walk`, `allow_gift`, `allow_trade`, `allow_recycle`, `allow_marketplace_sell`, `allow_inventory_stack`, `type`, `interaction_type`, `interaction_modes_count`, `vending_ids`, `multiheight`, `customparams`)
+VALUES (19001, 0, 'bot_frank', 'Frank', 1, 1, 0.00, '0', '0', '0', '1', '0', '0', '0', '0', '0', 'r', 'default', 1, '0', '0', '0');
+
+INSERT IGNORE INTO `catalog_items` (`item_ids`, `page_id`, `offer_id`, `catalog_name`, `cost_credits`, `cost_points`, `points_type`, `amount`, `extradata`)
+VALUES ('19001', 8, 19001, 'Frank', 0, 0, 0, 1, 'name:Frank;motto:Welcome to Habbo!;figure:hr-3499-33.sh-290-90.ch-3971-72-73.lg-270-73.hd-205-1-1.fa-1206-67.ha-3409-73-72;gender:m');

Database Updates/008_soundboard_fortune_wheel.sql

@@ -0,0 +1,78 @@
+-- Soundboard
+-- The room flag column + sounds table are also created at boot by
+
+ALTER TABLE `rooms` ADD COLUMN IF NOT EXISTS `soundboard_enabled` TINYINT(1) NOT NULL DEFAULT 0;
+
+CREATE TABLE IF NOT EXISTS `soundboard_sounds` (
+    `id` INT(11) NOT NULL AUTO_INCREMENT,
+    `name` VARCHAR(64) NOT NULL DEFAULT '',            -- pad label shown in the client
+    `url` VARCHAR(255) NOT NULL DEFAULT '',            -- audio url (uploaded via CMS, like custom badges)
+    `enabled` TINYINT(1) NOT NULL DEFAULT 1,
+    `sort_order` INT(11) NOT NULL DEFAULT 0,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+
+-- Fortune Wheel
+-- Tables are also created at boot by WheelManager (CREATE TABLE IF NOT EXISTS),
+-- so applying this file is only needed to seed prizes + settings.
+
+CREATE TABLE IF NOT EXISTS `wheel_prizes` (
+    `id` INT(11) NOT NULL AUTO_INCREMENT,
+    `type` VARCHAR(16) NOT NULL DEFAULT 'nothing',   -- item | badge | credits | points | spin | nothing
+    `value` VARCHAR(64) NOT NULL DEFAULT '',          -- item: base item id ; badge: badge code ; others: unused
+    `amount` INT(11) NOT NULL DEFAULT 1,              -- item qty / credits / points / extra spins
+    `points_type` INT(11) NOT NULL DEFAULT 5,         -- for type=points (diamond default 5)
+    `weight` INT(11) NOT NULL DEFAULT 1,              -- relative probability
+    `label` VARCHAR(64) NOT NULL DEFAULT '',          -- slice label override (optional)
+    `enabled` TINYINT(1) NOT NULL DEFAULT 1,
+    `sort_order` INT(11) NOT NULL DEFAULT 0,
+    PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+CREATE TABLE IF NOT EXISTS `wheel_user_state` (
+    `user_id` INT(11) NOT NULL,
+    `free_spins` INT(11) NOT NULL DEFAULT 0,          -- remaining free spins for the current day
+    `extra_spins` INT(11) NOT NULL DEFAULT 0,         -- bought / won spins
+    `last_reset` INT(11) NOT NULL DEFAULT 0,          -- day index of last daily reset (unix / 86400)
+    PRIMARY KEY (`user_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+CREATE TABLE IF NOT EXISTS `wheel_recent_wins` (
+    `id` INT(11) NOT NULL AUTO_INCREMENT,
+    `user_id` INT(11) NOT NULL,
+    `username` VARCHAR(64) NOT NULL DEFAULT '',
+    `look` VARCHAR(255) NOT NULL DEFAULT '',
+    `prize_label` VARCHAR(64) NOT NULL DEFAULT '',
+    `won_at` INT(11) NOT NULL DEFAULT 0,
+    PRIMARY KEY (`id`),
+    KEY `idx_wheel_recent_wins_id` (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+INSERT INTO `emulator_settings` (`key`, `value`, `comment`) VALUES
+    ('wheel.free_spins_per_day', '1',  'Fortune wheel: free spins granted each day.')
+    ON DUPLICATE KEY UPDATE `comment` = VALUES(`comment`);
+INSERT INTO `emulator_settings` (`key`, `value`, `comment`) VALUES
+    ('wheel.spin_cost', '50',          'Fortune wheel: cost of one extra spin.')
+    ON DUPLICATE KEY UPDATE `comment` = VALUES(`comment`);
+INSERT INTO `emulator_settings` (`key`, `value`, `comment`) VALUES
+    ('wheel.spin_cost_type', '5',      'Fortune wheel: currency type for the spin cost (5 = diamonds; -1 = credits).')
+    ON DUPLICATE KEY UPDATE `comment` = VALUES(`comment`);
+
+
+INSERT INTO `wheel_prizes` (`type`, `amount`, `points_type`, `weight`, `label`, `sort_order`) VALUES
+    ('points',25, 5, 20, '25 diamonds',1),
+    ('points',50, 5, 12, '50 diamonds',2),
+    ('points',200, 5,  3, '200 diamonds',3),
+    ('credits',100, 0, 15, '100 credits',4),
+    ('spin',1, 0, 15, '1 Extra spin', 5),
+    ('spin',2, 0,  6, '2 Extra spins',6),
+    ('nothing',0, 0, 29, 'Oh to bad!',7);
+	
+INSERT INTO `permission_definitions`
+  (`permission_key`, `max_value`, `comment`,
+   `rank_1`, `rank_2`, `rank_3`, `rank_4`, `rank_5`, `rank_6`, `rank_7`)
+VALUES
+  ('acc_wheeladmin', 1, 'Required to open the Fortune Wheel settings popup and edit prize rows.',
+   0, 0, 0, 0, 0, 0, 1)
+ON DUPLICATE KEY UPDATE `comment` = VALUES(`comment`);

Emulator/pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.eu.habbo</groupId>
     <artifactId>Habbo</artifactId>
-    <version>4.2.17</version>
+    <version>4.2.25</version>
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
@@ -38,6 +38,7 @@
                     <archive>
                         <manifest>
                             <mainClass>com.eu.habbo.Emulator</mainClass>
+                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                         </manifest>
                     </archive>
                 </configuration>

Emulator/src/main/java/com/eu/habbo/Emulator.java

@@ -39,12 +39,23 @@ public final class Emulator {
     private static final String OS_NAME = (System.getProperty("os.name") != null ? System.getProperty("os.name") : "Unknown");
     private static final String CLASS_PATH = (System.getProperty("java.class.path") != null ? System.getProperty("java.class.path") : "Unknown");
 
+    // Fallback version, only used when running outside a packaged jar (e.g. from
+    // the IDE). In production the version comes from the jar manifest below.
     public final static int MAJOR = 4;
     public final static int MINOR = 1;
     public final static int BUILD = 0;
     public final static String PREVIEW = "";
 
-    public static final String version = "Arcturus Morningstar" + " " + MAJOR + "." + MINOR + "." + BUILD + " " + PREVIEW;
+    // Tied to the Maven project version: read from the jar manifest
+    // (Implementation-Version = ${project.version}, see pom assembly plugin).
+    private static String resolveVersionNumber() {
+        String implementation = Emulator.class.getPackage().getImplementationVersion();
+        if (implementation != null && !implementation.isEmpty()) return implementation;
+        String fallback = MAJOR + "." + MINOR + "." + BUILD;
+        return PREVIEW.isEmpty() ? fallback : fallback + " " + PREVIEW;
+    }
+
+    public static final String version = "Arcturus Morningstar Extended " + resolveVersionNumber();
     private static final String logo =
             "\n" +
                     "███╗   ███╗ ██████╗ ██████╗ ███╗   ██╗██╗███╗   ██╗ ██████╗ ███████╗████████╗ █████╗ ██████╗ \n" +

Emulator/src/main/java/com/eu/habbo/habbohotel/GameEnvironment.java

@@ -6,6 +6,8 @@ import com.eu.habbo.habbohotel.achievements.AchievementManager;
 import com.eu.habbo.habbohotel.bots.BotManager;
 import com.eu.habbo.habbohotel.campaign.calendar.CalendarManager;
 import com.eu.habbo.habbohotel.catalog.CatalogManager;
+import com.eu.habbo.habbohotel.wheel.WheelManager;
+import com.eu.habbo.habbohotel.soundboard.SoundboardManager;
 import com.eu.habbo.habbohotel.commands.CommandHandler;
 import com.eu.habbo.habbohotel.crafting.CraftingManager;
 import com.eu.habbo.habbohotel.guides.GuideManager;
@@ -64,6 +66,8 @@ public class GameEnvironment {
     private GoogleTranslateManager googleTranslateManager;
     private CustomBadgeManager customBadgeManager;
     private InfostandBackgroundManager infostandBackgroundManager;
+    private WheelManager wheelManager;
+    private SoundboardManager soundboardManager;
 
     public void load() throws Exception {
         LOGGER.info("GameEnvironment -> Loading...");
@@ -93,6 +97,8 @@ public class GameEnvironment {
         this.googleTranslateManager = new GoogleTranslateManager();
         this.customBadgeManager = new CustomBadgeManager();
         this.infostandBackgroundManager = new InfostandBackgroundManager();
+        this.wheelManager = new WheelManager();
+        this.soundboardManager = new SoundboardManager();
 
         this.roomManager.loadPublicRooms();
         this.navigatorManager.loadNavigator();
@@ -156,6 +162,14 @@ public class GameEnvironment {
         return this.catalogManager;
     }
 
+    public WheelManager getWheelManager() {
+        return this.wheelManager;
+    }
+
+    public SoundboardManager getSoundboardManager() {
+        return this.soundboardManager;
+    }
+
     public HotelViewManager getHotelViewManager() {
         return this.hotelViewManager;
     }

Emulator/src/main/java/com/eu/habbo/habbohotel/bots/Bot.java

@@ -189,11 +189,7 @@ public class Bot implements Runnable {
                         int timeOut = Emulator.getRandom().nextInt(20) * 2;
                         this.roomUnit.setWalkTimeOut((timeOut < 10 ? 5 : timeOut) + Emulator.getIntUnixTimestamp());
                     }
-                }/* else {
-                    for (RoomTile t : this.room.getLayout().getTilesAround(this.room.getLayout().getTile(this.getRoomUnit().getX(), this.getRoomUnit().getY()))) {
-                        WiredManager.handle(WiredTriggerType.BOT_REACHED_STF, this.roomUnit, this.room, this.room.getItemsAt(t).toArray());
-                    }
-                }*/
+                }
             }
 
             if (!this.chatLines.isEmpty() && this.chatTimeOut <= Emulator.getIntUnixTimestamp() && this.chatAuto) {
@@ -218,7 +214,7 @@ public class Bot implements Runnable {
                     } else {
                         this.lastChatIndex++;
                         if (this.lastChatIndex >= this.chatLines.size()) {
-                            this.lastChatIndex = 0; // start from scratch :-3
+                            this.lastChatIndex = 0;
                         }
                     }
 
@@ -310,9 +306,6 @@ public class Bot implements Runnable {
     public void setName(String name) {
         this.name = name;
         this.needsUpdate = true;
-
-        //if(this.room != null)
-        //this.room.sendComposer(new ChangeNameUpdatedComposer(this.getRoomUnit(), this.getName()).compose());
     }
 
     public String getMotto() {
@@ -539,5 +532,28 @@ public class Bot implements Runnable {
         }
     }
 
+    private static final short[] DEFAULT_OWNER_ACTION_IDS = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11};
 
+    public static final int ACTION_ROTATE = 11;
+
+    private static final long MIN_OWNER_ACTION_INTERVAL_MS = 200L;
+
+    private volatile long lastOwnerActionAt;
+
+    public short[] getOwnerActionIds() {
+        return DEFAULT_OWNER_ACTION_IDS;
+    }
+
+    public synchronized boolean tryAcquireOwnerActionSlot() {
+        long now = System.currentTimeMillis();
+        if (now - this.lastOwnerActionAt < MIN_OWNER_ACTION_INTERVAL_MS) {
+            return false;
+        }
+        this.lastOwnerActionAt = now;
+        return true;
+    }
+
+    public void onPostOwnerAction(int actionId) {
+        // no-op default
+    }
 }

Emulator/src/main/java/com/eu/habbo/habbohotel/bots/BotManager.java

@@ -41,6 +41,7 @@ public class BotManager {
         addBotDefinition("generic", Bot.class);
         addBotDefinition("bartender", ButlerBot.class);
         addBotDefinition("visitor_log", VisitorBot.class);
+        addBotDefinition(FrankBot.BOT_TYPE, FrankBot.class);
 
         this.reload();
 

Emulator/src/main/java/com/eu/habbo/habbohotel/bots/FrankBot.java

@@ -0,0 +1,455 @@
+package com.eu.habbo.habbohotel.bots;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.rooms.*;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.messages.outgoing.rooms.users.RoomUserStatusComposer;
+import com.eu.habbo.messages.outgoing.rooms.users.RoomUserWhisperComposer;
+import com.eu.habbo.threading.runnables.RoomUnitWalkToLocation;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.regex.Pattern;
+
+public class FrankBot extends ButlerBot {
+    private static final Logger LOGGER = LoggerFactory.getLogger(FrankBot.class);
+    public static final String BOT_TYPE = "frank";
+    public static final String PERMISSION_USE = "acc_bot_frank";
+    private static final String KEY_DOOR_LINES = "__door_lines";
+    private static final String KEY_BUSY_WHISPER = "__busy_whisper";
+    private static final String KEY_DOOR_TRIGGERS = "__door_triggers";
+    private static final List<String> DEFAULT_DOOR_LINES = List.of(
+            "Right this way - mind the step!",
+            "And out you go. Come back soon!",
+            "Allow me to escort you to the exit.",
+            "There's the door. Farewell, true believer!"
+    );
+    private static final String DEFAULT_BUSY_WHISPER =
+            "Sorry, I am currently busy. Please wait until I am available.";
+    private static final Pattern DEFAULT_DOOR_PATTERN = Pattern.compile(
+            "\\b(show me the door|kick me|i want to leave|let me out)\\b");
+
+    private static final ConcurrentHashMap<Pattern, List<String>> chatResponses = new ConcurrentHashMap<>();
+    private static volatile List<String> doorLines = DEFAULT_DOOR_LINES;
+    private static volatile String busyWhisper = DEFAULT_BUSY_WHISPER;
+    private static volatile Pattern doorTriggerPattern = DEFAULT_DOOR_PATTERN;
+
+    private static final Random RANDOM = new Random();
+
+    private static final int MAX_CHAT_KEYWORDS = 256;
+    private static final int MAX_DOOR_TRIGGERS = 32;
+    private static final int MAX_MESSAGE_LEN = 256;
+    private static final long BUSY_WHISPER_COOLDOWN_MS = 5000L;
+
+    private volatile RoomTile homeTile;
+    private volatile RoomUserRotation homeRotation;
+    private final AtomicBoolean busy = new AtomicBoolean(false);
+    private final AtomicBoolean returnScheduled = new AtomicBoolean(false);
+    private final ConcurrentHashMap<Integer, Long> lastBusyWhisperAt = new ConcurrentHashMap<>();
+
+    public FrankBot(ResultSet set) throws SQLException {
+        super(set);
+    }
+
+    public FrankBot(Bot bot) {
+        super(bot);
+    }
+
+    @Override
+    public void onPlace(Habbo habbo, Room room) {
+        super.onPlace(habbo, room);
+        if (this.getRoomUnit() != null) {
+            this.homeTile = this.getRoomUnit().getCurrentLocation();
+            this.homeRotation = this.getRoomUnit().getBodyRotation();
+        }
+    }
+
+    private static final short[] FRANK_OWNER_ACTIONS = { (short) Bot.ACTION_ROTATE };
+
+    @Override
+    public short[] getOwnerActionIds() {
+        return FRANK_OWNER_ACTIONS;
+    }
+
+    @Override
+    public void onPostOwnerAction(int actionId) {
+        if (actionId == ACTION_ROTATE && this.getRoomUnit() != null) {
+            this.homeRotation = this.getRoomUnit().getBodyRotation();
+        }
+    }
+
+    public static void initialise() {
+        chatResponses.clear();
+        doorLines = DEFAULT_DOOR_LINES;
+        busyWhisper = DEFAULT_BUSY_WHISPER;
+        doorTriggerPattern = DEFAULT_DOOR_PATTERN;
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             Statement statement = connection.createStatement();
+             ResultSet set = statement.executeQuery("SELECT `keys`, `responses` FROM bot_chat_responses WHERE bot_type = '" + BOT_TYPE + "'")) {
+            while (set.next()) {
+                String keysRaw = set.getString("keys");
+                String responsesRaw = set.getString("responses");
+
+                if (keysRaw == null || responsesRaw == null) continue;
+
+                List<String> responses = new ArrayList<>();
+                for (String line : responsesRaw.split("\n")) {
+                    String trimmed = line.trim();
+                    if (!trimmed.isEmpty()) responses.add(trimmed);
+                }
+
+                if (responses.isEmpty()) continue;
+
+                String firstKey = keysRaw.split(";", 2)[0].trim();
+                if (firstKey.startsWith("__")) {
+                    switch (firstKey) {
+                        case KEY_DOOR_LINES:
+                            doorLines = new CopyOnWriteArrayList<>(responses);
+                            break;
+                        case KEY_BUSY_WHISPER:
+                            busyWhisper = responses.get(0);
+                            break;
+                        case KEY_DOOR_TRIGGERS:
+                            doorTriggerPattern = buildDoorTriggerPattern(responses);
+                            break;
+                        default:
+                            LOGGER.warn("FrankBot: unknown system key '{}', ignored", firstKey);
+                    }
+                    continue;
+                }
+
+                List<String> shared = new CopyOnWriteArrayList<>(responses);
+
+                for (String key : keysRaw.split(";")) {
+                    if (chatResponses.size() >= MAX_CHAT_KEYWORDS) {
+                        LOGGER.warn("FrankBot: chat keyword cap ({}) reached, remaining rows ignored",
+                                MAX_CHAT_KEYWORDS);
+                        break;
+                    }
+                    String k = key == null ? "" : key.trim().toLowerCase();
+                    if (k.isEmpty()) continue;
+                    try {
+                        Pattern pattern = Pattern.compile("\\b" + Pattern.quote(k) + "\\b");
+                        chatResponses.put(pattern, shared);
+                    } catch (Exception e) {
+                        LOGGER.error("Failed to compile Frank chat keyword pattern: {}", k, e);
+                    }
+                }
+            }
+        } catch (SQLException e) {
+            LOGGER.warn("FrankBot: could not load bot_chat_responses ({}). Frank will still serve items.", e.getMessage());
+        }
+
+        ButlerBot.initialise();
+    }
+
+    public static void dispose() {
+        chatResponses.clear();
+        doorLines = DEFAULT_DOOR_LINES;
+        busyWhisper = DEFAULT_BUSY_WHISPER;
+        doorTriggerPattern = DEFAULT_DOOR_PATTERN;
+        ButlerBot.dispose();
+    }
+
+    private static Pattern buildDoorTriggerPattern(List<String> triggers) {
+        StringBuilder sb = new StringBuilder("\\b(");
+        boolean first = true;
+        int count = 0;
+        for (String trigger : triggers) {
+            if (count >= MAX_DOOR_TRIGGERS) {
+                LOGGER.warn("FrankBot: door trigger cap ({}) reached, extra entries ignored",
+                        MAX_DOOR_TRIGGERS);
+                break;
+            }
+            String t = trigger == null ? "" : trigger.trim().toLowerCase();
+            if (t.isEmpty()) continue;
+            if (!first) sb.append('|');
+            sb.append(Pattern.quote(t));
+            first = false;
+            count++;
+        }
+        sb.append(")\\b");
+
+        if (first) return DEFAULT_DOOR_PATTERN;
+
+        try {
+            return Pattern.compile(sb.toString());
+        } catch (Exception e) {
+            LOGGER.error("FrankBot: failed to compile door trigger pattern from {}, falling back to default", triggers, e);
+            return DEFAULT_DOOR_PATTERN;
+        }
+    }
+
+    @Override
+    public void onUserSay(final RoomChatMessage message) {
+        Room currentRoom = this.getRoom();
+        if (currentRoom == null) return;
+
+        Habbo asker = message.getHabbo();
+        if (asker == null || asker.getClient() == null) return;
+
+        if (this.getRoomUnit() == null) return;
+
+        String raw = message.getUnfilteredMessage();
+        if (raw != null && raw.length() > MAX_MESSAGE_LEN) return;
+
+        if (this.homeTile == null) {
+            this.homeTile = this.getRoomUnit().getCurrentLocation();
+            this.homeRotation = this.getRoomUnit().getBodyRotation();
+        }
+
+        if (this.busy.get() || this.getRoomUnit().hasStatus(RoomUnitStatus.MOVE)) {
+            this.whisperThrottled(asker, busyWhisper);
+            return;
+        }
+
+        if (raw != null) {
+            double distance = this.getRoomUnit().getCurrentLocation().distance(asker.getRoomUnit().getCurrentLocation());
+            int commandDistance = Emulator.getConfig().getInt("hotel.bot.butler.commanddistance");
+
+            if (distance <= commandDistance) {
+                String lower = raw.toLowerCase();
+
+                if (doorTriggerPattern.matcher(lower).find()) {
+                    if (!this.busy.compareAndSet(false, true)) {
+                        this.whisperThrottled(asker, busyWhisper);
+                        return;
+                    }
+                    this.showToTheDoor(asker);
+                    return;
+                }
+
+                for (java.util.Map.Entry<Pattern, List<String>> entry : chatResponses.entrySet()) {
+                    if (entry.getKey().matcher(lower).find()) {
+                        List<String> options = entry.getValue();
+                        if (options.isEmpty()) continue;
+
+                        String reply = options.get(RANDOM.nextInt(options.size()));
+                        this.talk(reply);
+                        return;
+                    }
+                }
+            }
+        }
+
+        if (!this.busy.compareAndSet(false, true)) {
+            this.whisperThrottled(asker, busyWhisper);
+            return;
+        }
+        super.onUserSay(message);
+        this.schedulePostServeReturn(currentRoom.getId(), 0);
+    }
+
+    private void whisperThrottled(Habbo target, String text) {
+        if (target == null || text == null || text.isEmpty() || this.getRoomUnit() == null) return;
+        int userId = target.getHabboInfo().getId();
+        long now = System.currentTimeMillis();
+        Long last = lastBusyWhisperAt.get(userId);
+        if (last != null && (now - last) < BUSY_WHISPER_COOLDOWN_MS) return;
+        lastBusyWhisperAt.put(userId, now);
+        RoomChatMessage msg = new RoomChatMessage(text, this.getRoomUnit(), RoomChatMessageBubbles.BOT);
+        target.getClient().sendResponse(new RoomUserWhisperComposer(msg));
+    }
+
+    private void showToTheDoor(final Habbo target) {
+        final Room room = this.getRoom();
+        if (room == null || room.getLayout() == null || target == null) {
+            this.busy.set(false);
+            return;
+        }
+
+        final RoomTile doorTile = room.getLayout().getDoorTile();
+        if (doorTile == null) {
+            this.busy.set(false);
+            return;
+        }
+
+        this.lookAt(target);
+        List<String> lines = doorLines;
+        String line = lines.isEmpty() ? DEFAULT_DOOR_LINES.get(RANDOM.nextInt(DEFAULT_DOOR_LINES.size()))
+                : lines.get(RANDOM.nextInt(lines.size()));
+        this.talk(line);
+
+        final int targetId = target.getHabboInfo().getId();
+        final int roomId = room.getId();
+        final AtomicBoolean fired = new AtomicBoolean(false);
+
+        final Runnable kickThenReturn = () -> {
+            if (!fired.compareAndSet(false, true)) return;
+            Room currentRoom = this.getRoom();
+            if (currentRoom == null || currentRoom.getId() != roomId) {
+                this.busy.set(false);
+                return;
+            }
+            Habbo stillHere = currentRoom.getHabbo(targetId);
+            if (stillHere != null) {
+                currentRoom.kickHabbo(stillHere, false);
+            }
+            this.scheduleReturnHome(targetId, roomId, 0);
+        };
+
+        if (this.getRoomUnit().canWalk() && !this.getRoomUnit().getCurrentLocation().equals(doorTile)) {
+            List<Runnable> onArrive = new ArrayList<>();
+            onArrive.add(kickThenReturn);
+
+            List<Runnable> onFail = new ArrayList<>();
+            onFail.add(() -> Emulator.getThreading().run(kickThenReturn, 1500));
+
+            this.getRoomUnit().setGoalLocation(doorTile);
+            Emulator.getThreading().run(
+                    new RoomUnitWalkToLocation(this.getRoomUnit(), doorTile, room, onArrive, onFail));
+        } else {
+            Emulator.getThreading().run(kickThenReturn, 1500);
+        }
+    }
+
+    private static final int RETURN_HOME_POLL_MS = 500;
+    private static final int RETURN_HOME_MAX_WAIT_MS = 8000;
+    private static final int POST_SERVE_POLL_MS = 750;
+    private static final int POST_SERVE_MAX_WAIT_MS = 30000;
+
+    private void schedulePostServeReturn(final int roomId, final int waitedMs) {
+        if (waitedMs == 0 && !this.returnScheduled.compareAndSet(false, true)) {
+            return;
+        }
+        if (waitedMs >= POST_SERVE_MAX_WAIT_MS) {
+            this.returnScheduled.set(false);
+            this.busy.set(false);
+            return;
+        }
+        if (this.homeTile == null) {
+            this.returnScheduled.set(false);
+            this.busy.set(false);
+            return;
+        }
+
+        Emulator.getThreading().run(() -> {
+            Room r = this.getRoom();
+            if (r == null || r.getId() != roomId || this.getRoomUnit() == null || this.homeTile == null) {
+                this.returnScheduled.set(false);
+                this.busy.set(false);
+                return;
+            }
+
+            if (this.getRoomUnit().getCurrentLocation().equals(this.homeTile)) {
+                if (this.homeRotation != null && this.getRoomUnit().getBodyRotation() != this.homeRotation) {
+                    this.getRoomUnit().setRotation(this.homeRotation);
+                    r.sendComposer(new RoomUserStatusComposer(this.getRoomUnit()).compose());
+                    this.persistPosition();
+                } else {
+                    this.busy.set(false);
+                }
+                this.returnScheduled.set(false);
+                return;
+            }
+
+            boolean stillWalking = this.getRoomUnit().hasStatus(RoomUnitStatus.MOVE)
+                    || (this.getRoomUnit().getPath() != null && !this.getRoomUnit().getPath().isEmpty());
+
+            if (stillWalking) {
+                this.schedulePostServeReturn(roomId, waitedMs + POST_SERVE_POLL_MS);
+                return;
+            }
+
+            this.returnScheduled.set(false);
+            this.returnHome(-1, false);
+        }, POST_SERVE_POLL_MS);
+    }
+
+    private void scheduleReturnHome(final int kickedHabboId, final int roomId, final int waitedMs) {
+        Room currentRoom = this.getRoom();
+        if (currentRoom == null || currentRoom.getId() != roomId) return;
+
+        boolean stillEscorting = currentRoom.getHabbo(kickedHabboId) != null;
+
+        if (!stillEscorting || waitedMs >= RETURN_HOME_MAX_WAIT_MS) {
+            this.returnHome(kickedHabboId, true);
+            return;
+        }
+
+        Emulator.getThreading().run(
+                () -> this.scheduleReturnHome(kickedHabboId, roomId, waitedMs + RETURN_HOME_POLL_MS),
+                RETURN_HOME_POLL_MS);
+    }
+
+    private void returnHome(int kickedHabboId, boolean alwaysTeleport) {
+        final Room room = this.getRoom();
+        if (room == null || this.homeTile == null || this.getRoomUnit() == null) {
+            this.busy.set(false);
+            return;
+        }
+
+        final Runnable teleportHome = () -> {
+            Room r = this.getRoom();
+            if (r == null || this.getRoomUnit() == null) return;
+
+            double homeZ = r.getTopHeightAt(this.homeTile.x, this.homeTile.y);
+
+            this.getRoomUnit().stopWalking();
+            this.getRoomUnit().setZ(homeZ);
+            this.getRoomUnit().setLocation(this.homeTile);
+            this.getRoomUnit().setPreviousLocationZ(homeZ);
+            if (this.homeRotation != null) {
+                this.getRoomUnit().setRotation(this.homeRotation);
+            }
+            this.getRoomUnit().statusUpdate(true);
+            r.sendComposer(new RoomUserStatusComposer(this.getRoomUnit()).compose());
+            this.persistPosition();
+        };
+
+        if (this.getRoomUnit().getCurrentLocation().equals(this.homeTile)) {
+            if (this.homeRotation != null) {
+                this.getRoomUnit().setRotation(this.homeRotation);
+                room.sendComposer(new RoomUserStatusComposer(this.getRoomUnit()).compose());
+            }
+            this.persistPosition();
+            return;
+        }
+
+        boolean hasOtherWatchers = false;
+        for (Habbo h : room.getCurrentHabbos().values()) {
+            if (h.getHabboInfo().getId() != kickedHabboId) {
+                hasOtherWatchers = true;
+                break;
+            }
+        }
+
+        if (alwaysTeleport || !hasOtherWatchers || !this.getRoomUnit().canWalk()) {
+            teleportHome.run();
+            return;
+        }
+
+        List<Runnable> onArrive = new ArrayList<>();
+        onArrive.add(() -> {
+            if (this.homeRotation != null && this.getRoom() != null) {
+                this.getRoomUnit().setRotation(this.homeRotation);
+                this.getRoom().sendComposer(new RoomUserStatusComposer(this.getRoomUnit()).compose());
+            }
+            this.persistPosition();
+        });
+
+        List<Runnable> onFail = new ArrayList<>();
+        onFail.add(teleportHome);
+
+        this.getRoomUnit().setGoalLocation(this.homeTile);
+        Emulator.getThreading().run(
+                new RoomUnitWalkToLocation(this.getRoomUnit(), this.homeTile, room, onArrive, onFail));
+    }
+
+    private void persistPosition() {
+        this.needsUpdate(true);
+        this.run();
+        this.busy.set(false);
+    }
+}

Emulator/src/main/java/com/eu/habbo/habbohotel/catalog/CatalogManager.java

@@ -202,6 +202,8 @@ public class CatalogManager {
     public final Item ecotronItem;
     public final THashMap<Integer, CatalogLimitedConfiguration> limitedNumbers;
     private final List<Voucher> vouchers;
+    // spriteId -> [credits, points, pointsType], derived from catalog_items (see loadFurnitureValues)
+    public final TIntObjectMap<int[]> furnitureValues;
 
     public CatalogManager() {
         long millis = System.currentTimeMillis();
@@ -219,6 +221,7 @@ public class CatalogManager {
         this.buildersClubOfferDefs = new TIntIntHashMap();
         this.vouchers = new ArrayList<>();
         this.limitedNumbers = new THashMap<>();
+        this.furnitureValues = new TIntObjectHashMap<>();
 
         this.initialize();
 
@@ -243,6 +246,56 @@ public class CatalogManager {
         this.loadClothing();
         this.loadRecycler();
         this.loadGiftWrappers();
+        this.loadFurnitureValues();
+    }
+
+    // Builds spriteId -> [credits, points, pointsType] from catalog_items so the
+    // client can show a furni's "value" (toolbar price guide + infostand line).
+    // Only single-item, single-amount FLOOR/WALL sales are considered, so bundles
+    // and multi-packs don't pollute the per-rare price. First clean entry wins.
+    private synchronized void loadFurnitureValues() {
+        this.furnitureValues.clear();
+        final int diamondType = Emulator.getConfig().getInt("seasonal.currency.diamond", 5);
+
+        for (CatalogPage page : this.catalogPages.valueCollection()) {
+            for (CatalogItem catalogItem : page.getCatalogItems().valueCollection()) {
+                if (catalogItem.getAmount() != 1)
+                    continue;
+
+                int credits = catalogItem.getCredits();
+                int points = catalogItem.getPoints();
+                int pointsType = catalogItem.getPointsType();
+
+                // Only diamond-priced items — both the "Valore Rari" panel and the
+                // infostand value line show diamonds only.
+                if (points <= 0 || pointsType != diamondType)
+                    continue;
+
+                THashSet<Item> baseItems = catalogItem.getBaseItems();
+
+                if (baseItems.size() != 1)
+                    continue;
+
+                for (Item item : baseItems) {
+                    FurnitureType type = item.getType();
+
+                    if (type != FurnitureType.FLOOR && type != FurnitureType.WALL)
+                        continue;
+
+                    int spriteId = item.getSpriteId();
+
+                    if (spriteId > 0 && !this.furnitureValues.containsKey(spriteId)) {
+                        this.furnitureValues.put(spriteId, new int[]{credits, points, pointsType});
+                    }
+                }
+            }
+        }
+
+        LOGGER.info("Furniture Values -> Loaded! ({} entries)", this.furnitureValues.size());
+    }
+
+    public TIntObjectMap<int[]> getFurnitureValues() {
+        return this.furnitureValues;
     }
 
     private synchronized void loadLimitedNumbers() {
@@ -1046,10 +1099,22 @@ public class CatalogManager {
                     for (Item baseItem : item.getBaseItems()) {
                         for (int k = 0; k < item.getItemAmount(baseItem.getId()); k++) {
                             if (baseItem.getName().startsWith("rentable_bot_") || baseItem.getName().startsWith("bot_")) {
+                                String baseName = baseItem.getName();
                                 String type = item.getName().replace("rentable_bot_", "");
                                 type = type.replace("bot_", "");
                                 type = type.replace("visitor_logger", "visitor_log");
 
+                                // Permission gate keyed on the canonical base-item name
+                                // (admin-controlled but stable), not the catalog page name
+                                // which can be renamed and bypass the check.
+                                if (("bot_" + com.eu.habbo.habbohotel.bots.FrankBot.BOT_TYPE).equals(baseName)
+                                        || ("rentable_bot_" + com.eu.habbo.habbohotel.bots.FrankBot.BOT_TYPE).equals(baseName)) {
+                                    if (!habbo.getClient().getHabbo().hasPermission(com.eu.habbo.habbohotel.bots.FrankBot.PERMISSION_USE)) {
+                                        habbo.getClient().sendResponse(new AlertPurchaseFailedComposer(AlertPurchaseFailedComposer.SERVER_ERROR).compose());
+                                        return;
+                                    }
+                                }
+
                                 THashMap<String, String> data = new THashMap<>();
 
                                 for (String s : item.getExtradata().split(";")) {

Emulator/src/main/java/com/eu/habbo/habbohotel/items/Item.java

@@ -48,6 +48,12 @@ public class Item implements ISerialize {
         return item.getName().toLowerCase().startsWith("a0 pet");
     }
 
+    public static boolean isBot(Item item) {
+        if (item == null) return false;
+        String name = item.getName();
+        return name != null && (name.startsWith("bot_") || name.startsWith("rentable_bot_"));
+    }
+
     public static double getCurrentHeight(HabboItem item) {
         if (item instanceof InteractionMultiHeight && item.getBaseItem().getMultiHeights().length > 0) {
             if (item.getExtradata().isEmpty()) {

Emulator/src/main/java/com/eu/habbo/habbohotel/permissions/Permission.java

@@ -8,6 +8,7 @@ public class Permission {
     public static String ACC_SEE_WHISPERS = "acc_see_whispers";
     public static String ACC_SEE_TENTCHAT = "acc_see_tentchat";
     public static String ACC_SUPERWIRED = "acc_superwired";
+    public static String ACC_HOUSEKEEPING = "acc_housekeeping";
     public static String ACC_SUPPORTTOOL = "acc_supporttool";
     public static String ACC_UNKICKABLE = "acc_unkickable";
     public static String ACC_GUILDGATE = "acc_guildgate";

Emulator/src/main/java/com/eu/habbo/habbohotel/rooms/Room.java

@@ -197,6 +197,7 @@ public class Room implements Comparable<Room>, ISerialize, Runnable {
   private int wiredInspectMask = WIRED_ACCESS_DEFAULT_INSPECT_MASK;
   private int wiredModifyMask = WIRED_ACCESS_DEFAULT_MODIFY_MASK;
   private boolean youtubeEnabled = false;
+  private boolean soundboardEnabled = false;
   private String youtubeCurrentVideo = "";
   private String youtubeSenderName = "";
   private final java.util.List<String> youtubePlaylist = new java.util.concurrent.CopyOnWriteArrayList<>();
@@ -204,6 +205,8 @@ public class Room implements Comparable<Room>, ISerialize, Runnable {
 
   public boolean isYoutubeEnabled() { return this.youtubeEnabled; }
   public void setYoutubeEnabled(boolean enabled) { this.youtubeEnabled = enabled; }
+  public boolean isSoundboardEnabled() { return this.soundboardEnabled; }
+  public void setSoundboardEnabled(boolean enabled) { this.soundboardEnabled = enabled; }
   public String getYoutubeCurrentVideo() { return this.youtubeCurrentVideo; }
   public String getYoutubeSenderName() { return this.youtubeSenderName; }
   public java.util.List<String> getYoutubePlaylist() { return this.youtubePlaylist; }
@@ -250,6 +253,7 @@ public class Room implements Comparable<Room>, ISerialize, Runnable {
     this.allowWalkthrough = set.getBoolean("allow_walkthrough");
     this.hideWall = set.getBoolean("allow_hidewall");
     try { this.youtubeEnabled = set.getBoolean("youtube_enabled"); } catch (Exception e) { this.youtubeEnabled = false; }
+    try { this.soundboardEnabled = set.getBoolean("soundboard_enabled"); } catch (Exception e) { this.soundboardEnabled = false; }
     this.chatMode = set.getInt("chat_mode");
     this.chatWeight = set.getInt("chat_weight");
     this.chatSpeed = set.getInt("chat_speed");

Emulator/src/main/java/com/eu/habbo/habbohotel/rooms/RoomManager.java

@@ -1020,6 +1020,10 @@ public class RoomManager {
                     room.getYoutubeWatchers()).compose());
         }
 
+        habbo.getClient().sendResponse(new com.eu.habbo.messages.outgoing.soundboard.SoundboardSettingsComposer(
+                room.isSoundboardEnabled(),
+                Emulator.getGameEnvironment().getSoundboardManager().getSounds()).compose());
+
         WiredManager.triggerUserEntersRoom(room, habbo.getRoomUnit());
         room.habboEntered(habbo);
 

Emulator/src/main/java/com/eu/habbo/habbohotel/soundboard/SoundboardManager.java

@@ -0,0 +1,78 @@
+package com.eu.habbo.habbohotel.soundboard;
+
+import com.eu.habbo.Emulator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+public class SoundboardManager {
+    private static final Logger LOGGER = LoggerFactory.getLogger(SoundboardManager.class);
+
+    private final List<SoundboardSound> sounds = new ArrayList<>();
+
+    public SoundboardManager() {
+        long millis = System.currentTimeMillis();
+        this.bootstrap();
+        this.reload();
+        LOGGER.info("Soundboard Manager -> Loaded! ({} MS, {} sounds)", System.currentTimeMillis() - millis, this.sounds.size());
+    }
+
+    // Self-bootstrap: room flag column + sounds table, so the feature works even
+    // before the manual migration is applied.
+    private void bootstrap() {
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             Statement statement = connection.createStatement()) {
+            statement.execute("ALTER TABLE `rooms` ADD COLUMN IF NOT EXISTS `soundboard_enabled` TINYINT(1) NOT NULL DEFAULT 0");
+            statement.execute("CREATE TABLE IF NOT EXISTS `soundboard_sounds` (" +
+                    "`id` INT(11) NOT NULL AUTO_INCREMENT, `name` VARCHAR(64) NOT NULL DEFAULT '', " +
+                    "`url` VARCHAR(255) NOT NULL DEFAULT '', `enabled` TINYINT(1) NOT NULL DEFAULT 1, " +
+                    "`sort_order` INT(11) NOT NULL DEFAULT 0, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4");
+        } catch (SQLException e) {
+            LOGGER.error("Failed to bootstrap soundboard schema", e);
+        }
+    }
+
+    public void reload() {
+        this.sounds.clear();
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("SELECT id, name, url FROM soundboard_sounds WHERE enabled = 1 ORDER BY sort_order ASC, id ASC");
+             ResultSet set = statement.executeQuery()) {
+            while (set.next()) {
+                this.sounds.add(new SoundboardSound(set));
+            }
+        } catch (SQLException e) {
+            LOGGER.error("Failed to load soundboard sounds", e);
+        }
+    }
+
+    public List<SoundboardSound> getSounds() {
+        return this.sounds;
+    }
+
+    public SoundboardSound getSound(int id) {
+        for (SoundboardSound sound : this.sounds) {
+            if (sound.id == id) return sound;
+        }
+        return null;
+    }
+
+    // Owner toggle — persists the room flag with a dedicated UPDATE (kept out of
+    // the big room-settings save to avoid touching that statement).
+    public void setRoomEnabled(int roomId, boolean enabled) {
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("UPDATE rooms SET soundboard_enabled = ? WHERE id = ? LIMIT 1")) {
+            statement.setString(1, enabled ? "1" : "0");
+            statement.setInt(2, roomId);
+            statement.executeUpdate();
+        } catch (SQLException e) {
+            LOGGER.error("Failed to set soundboard_enabled for room {}", roomId, e);
+        }
+    }
+}

Emulator/src/main/java/com/eu/habbo/habbohotel/soundboard/SoundboardSound.java

@@ -0,0 +1,17 @@
+package com.eu.habbo.habbohotel.soundboard;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+// One soundboard pad: a named audio clip served from a URL (uploaded via the CMS).
+public class SoundboardSound {
+    public final int id;
+    public final String name;
+    public final String url;
+
+    public SoundboardSound(ResultSet set) throws SQLException {
+        this.id = set.getInt("id");
+        this.name = set.getString("name");
+        this.url = set.getString("url");
+    }
+}

Emulator/src/main/java/com/eu/habbo/habbohotel/users/HabboStats.java

@@ -89,6 +89,7 @@ public class HabboStats implements Runnable {
     public long lastTradeTimestamp = Emulator.getIntUnixTimestamp();
     public long lastGiftTimestamp = Emulator.getIntUnixTimestamp();
     public long lastPurchaseTimestamp = Emulator.getIntUnixTimestamp();
+    public long lastFloorplanSaveTimestamp = 0;
     public int uiFlags;
     public boolean hasGottenDefaultSavedSearches;
     private HabboInfo habboInfo;

Emulator/src/main/java/com/eu/habbo/habbohotel/wheel/WheelManager.java

@@ -0,0 +1,366 @@
+package com.eu.habbo.habbohotel.wheel;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.items.Item;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.habbohotel.users.HabboItem;
+import gnu.trove.set.hash.THashSet;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class WheelManager {
+    private static final Logger LOGGER = LoggerFactory.getLogger(WheelManager.class);
+    private static final int RECENT_KEEP = 50;
+    private static final int SECONDS_PER_DAY = 86400;
+
+    public static final Set<String> VALID_PRIZE_TYPES = Set.of(
+            "credits", "points", "spin", "item", "badge", "nothing");
+    public static final int MAX_PRIZES_PER_SAVE = 64;
+    public static final int MAX_STRING_LEN = 64;
+    public static final int MAX_PRIZE_AMOUNT = 1_000_000;
+    public static final int MAX_ITEM_QUANTITY = 100;
+    public static final int MAX_WEIGHT = 1_000_000;
+    public static final int MAX_EXTRA_SPINS = 10_000;
+    private static final long MIN_SPIN_INTERVAL_MS = 1500L;
+
+    private final List<WheelPrize> prizes = new ArrayList<>();
+    private int totalWeight = 0;
+    private int freeSpinsPerDay = 1;
+    private int spinCost = 50;
+    private int spinCostType = 5;
+
+    private final ConcurrentHashMap<Integer, Long> lastSpinAt = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<Integer, WheelUserState> userStateCache = new ConcurrentHashMap<>();
+    private final java.util.concurrent.CopyOnWriteArrayList<WheelRecentWin> recentWinsCache = new java.util.concurrent.CopyOnWriteArrayList<>();
+
+    public WheelManager() {
+        long millis = System.currentTimeMillis();
+        this.reload();
+        LOGGER.info("Wheel Manager -> Loaded! ({} MS)", System.currentTimeMillis() - millis);
+    }
+
+    public void reload() {
+        this.loadSettings();
+        this.loadPrizes();
+        this.loadRecentWins();
+    }
+
+    private void loadSettings() {
+        this.freeSpinsPerDay = Emulator.getConfig().getInt("wheel.free_spins_per_day", 1);
+        this.spinCost = Emulator.getConfig().getInt("wheel.spin_cost", 50);
+        this.spinCostType = Emulator.getConfig().getInt("wheel.spin_cost_type", 5);
+    }
+
+    private void loadPrizes() {
+        this.prizes.clear();
+        this.totalWeight = 0;
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("SELECT * FROM wheel_prizes WHERE enabled = 1 ORDER BY sort_order ASC, id ASC");
+             ResultSet set = statement.executeQuery()) {
+            while (set.next()) {
+                WheelPrize prize = new WheelPrize(set);
+                this.prizes.add(prize);
+                this.totalWeight += prize.weight;
+            }
+        } catch (SQLException e) {
+            LOGGER.error("Failed to load fortune wheel prizes", e);
+        }
+    }
+
+    public List<WheelPrize> getPrizes() {
+        return this.prizes;
+    }
+
+    public int getSpinCost() {
+        return this.spinCost;
+    }
+
+    public int getSpinCostType() {
+        return this.spinCostType;
+    }
+
+    private int today() {
+        return Emulator.getIntUnixTimestamp() / SECONDS_PER_DAY;
+    }
+
+    public synchronized WheelUserState getUserState(int userId) {
+        int today = this.today();
+        WheelUserState cached = this.userStateCache.get(userId);
+
+        if (cached != null) {
+            if (cached.lastReset != today) {
+                cached.freeSpins = this.freeSpinsPerDay;
+                cached.lastReset = today;
+                this.persistUserState(userId, cached);
+            }
+            return cached;
+        }
+
+        WheelUserState state = new WheelUserState();
+        boolean exists = false;
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("SELECT free_spins, extra_spins, last_reset FROM wheel_user_state WHERE user_id = ?")) {
+            statement.setInt(1, userId);
+            try (ResultSet set = statement.executeQuery()) {
+                if (set.next()) {
+                    state.freeSpins = set.getInt("free_spins");
+                    state.extraSpins = set.getInt("extra_spins");
+                    state.lastReset = set.getInt("last_reset");
+                    exists = true;
+                }
+            }
+        } catch (SQLException e) {
+            LOGGER.error("Failed to read wheel state for user {}", userId, e);
+        }
+
+        if (!exists) {
+            state.freeSpins = this.freeSpinsPerDay;
+            state.extraSpins = 0;
+            state.lastReset = today;
+            this.persistUserState(userId, state);
+        } else if (state.lastReset != today) {
+            state.freeSpins = this.freeSpinsPerDay;
+            state.lastReset = today;
+            this.persistUserState(userId, state);
+        }
+
+        this.userStateCache.put(userId, state);
+        return state;
+    }
+
+    private void persistUserState(int userId, WheelUserState state) {
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement(
+                     "INSERT INTO wheel_user_state (user_id, free_spins, extra_spins, last_reset) VALUES (?, ?, ?, ?) " +
+                             "ON DUPLICATE KEY UPDATE free_spins = VALUES(free_spins), extra_spins = VALUES(extra_spins), last_reset = VALUES(last_reset)")) {
+            statement.setInt(1, userId);
+            statement.setInt(2, state.freeSpins);
+            statement.setInt(3, state.extraSpins);
+            statement.setInt(4, state.lastReset);
+            statement.executeUpdate();
+        } catch (SQLException e) {
+            LOGGER.error("Failed to persist wheel state for user {}", userId, e);
+        }
+    }
+
+    public synchronized WheelPrize spin(Habbo habbo) {
+        int userId = habbo.getHabboInfo().getId();
+        long now = System.currentTimeMillis();
+        Long last = this.lastSpinAt.get(userId);
+        if (last != null && (now - last) < MIN_SPIN_INTERVAL_MS) return null;
+        this.lastSpinAt.put(userId, now);
+
+        WheelUserState state = this.getUserState(userId);
+
+        boolean usedFree;
+        if (state.freeSpins > 0) {
+            state.freeSpins--;
+            usedFree = true;
+        } else if (state.extraSpins > 0) {
+            state.extraSpins--;
+            usedFree = false;
+        } else {
+            return null;
+        }
+
+        WheelPrize prize = this.pickWeighted();
+        if (prize == null) {
+            if (usedFree) state.freeSpins++; else state.extraSpins++;
+            return null;
+        }
+
+        this.giveReward(habbo, prize, state);
+        this.persistUserState(userId, state);
+        this.recordWin(habbo, prize);
+
+        return prize;
+    }
+
+    private WheelPrize pickWeighted() {
+        if (this.prizes.isEmpty() || this.totalWeight <= 0) return null;
+
+        int roll = ThreadLocalRandom.current().nextInt(this.totalWeight);
+        int acc = 0;
+        for (WheelPrize prize : this.prizes) {
+            acc += prize.weight;
+            if (roll < acc) return prize;
+        }
+        return this.prizes.get(this.prizes.size() - 1);
+    }
+
+    private void giveReward(Habbo habbo, WheelPrize prize, WheelUserState state) {
+        int amount = Math.max(0, Math.min(prize.amount, MAX_PRIZE_AMOUNT));
+
+        switch (prize.type) {
+            case "credits":
+                if (amount > 0) habbo.giveCredits(amount);
+                break;
+            case "points":
+                if (amount > 0) habbo.givePoints(prize.pointsType, amount);
+                break;
+            case "spin":
+                int room = Math.max(0, MAX_EXTRA_SPINS - state.extraSpins);
+                state.extraSpins += Math.min(amount, room);
+                break;
+            case "item":
+                this.giveItem(habbo, prize, Math.min(amount, MAX_ITEM_QUANTITY));
+                break;
+            case "badge":
+                if (prize.value != null && !prize.value.isEmpty()) {
+                    habbo.addBadge(prize.value, "Fortune Wheel");
+                }
+                break;
+            case "nothing":
+            default:
+                break;
+        }
+    }
+
+    private void giveItem(Habbo habbo, WheelPrize prize, int quantity) {
+        if (quantity <= 0 || prize.value == null) return;
+
+        int baseId;
+        try {
+            baseId = Integer.parseInt(prize.value.trim());
+        } catch (NumberFormatException e) {
+            return;
+        }
+
+        Item base = Emulator.getGameEnvironment().getItemManager().getItem(baseId);
+        if (base == null) return;
+
+        THashSet<HabboItem> items = new THashSet<>();
+        for (int i = 0; i < quantity; i++) {
+            HabboItem item = Emulator.getGameEnvironment().getItemManager().createItem(habbo.getHabboInfo().getId(), base, 0, 0, "");
+            if (item != null) items.add(item);
+        }
+
+        if (!items.isEmpty()) {
+            habbo.addFurniture(items);
+        }
+    }
+
+    private void recordWin(Habbo habbo, WheelPrize prize) {
+        WheelRecentWin win = new WheelRecentWin(
+                habbo.getHabboInfo().getUsername(),
+                habbo.getHabboInfo().getLook(),
+                prize.label);
+
+        this.recentWinsCache.add(0, win);
+        while (this.recentWinsCache.size() > RECENT_KEEP) {
+            this.recentWinsCache.remove(this.recentWinsCache.size() - 1);
+        }
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection()) {
+            try (PreparedStatement statement = connection.prepareStatement(
+                    "INSERT INTO wheel_recent_wins (user_id, username, look, prize_label, won_at) VALUES (?, ?, ?, ?, ?)")) {
+                statement.setInt(1, habbo.getHabboInfo().getId());
+                statement.setString(2, habbo.getHabboInfo().getUsername());
+                statement.setString(3, habbo.getHabboInfo().getLook());
+                statement.setString(4, prize.label);
+                statement.setInt(5, Emulator.getIntUnixTimestamp());
+                statement.executeUpdate();
+            }
+
+            try (PreparedStatement trim = connection.prepareStatement(
+                    "DELETE FROM wheel_recent_wins WHERE id < (SELECT id FROM (SELECT id FROM wheel_recent_wins ORDER BY id DESC LIMIT 1 OFFSET ?) t)")) {
+                trim.setInt(1, RECENT_KEEP - 1);
+                trim.executeUpdate();
+            }
+        } catch (SQLException e) {
+            LOGGER.error("Failed to record wheel win", e);
+        }
+    }
+
+    public List<WheelRecentWin> getRecentWins(int limit) {
+        if (limit <= 0) return new ArrayList<>();
+        int size = this.recentWinsCache.size();
+        if (size == 0) return new ArrayList<>();
+        int take = Math.min(limit, size);
+        return new ArrayList<>(this.recentWinsCache.subList(0, take));
+    }
+
+    private void loadRecentWins() {
+        this.recentWinsCache.clear();
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("SELECT username, look, prize_label FROM wheel_recent_wins ORDER BY id DESC LIMIT ?")) {
+            statement.setInt(1, RECENT_KEEP);
+            try (ResultSet set = statement.executeQuery()) {
+                while (set.next()) {
+                    this.recentWinsCache.add(new WheelRecentWin(
+                            set.getString("username"),
+                            set.getString("look"),
+                            set.getString("prize_label")));
+                }
+            }
+        } catch (SQLException e) {
+            LOGGER.error("Failed to load wheel recent wins", e);
+        }
+    }
+
+    public synchronized boolean buySpin(Habbo habbo) {
+        if (this.spinCost <= 0) return false;
+
+        int userId = habbo.getHabboInfo().getId();
+        WheelUserState state = this.getUserState(userId);
+        if (state.extraSpins >= MAX_EXTRA_SPINS) return false;
+
+        if (this.spinCostType == -1) {
+            if (habbo.getHabboInfo().getCredits() < this.spinCost) return false;
+            habbo.giveCredits(-this.spinCost);
+        } else {
+            if (habbo.getHabboInfo().getCurrencyAmount(this.spinCostType) < this.spinCost) return false;
+            habbo.givePoints(this.spinCostType, -this.spinCost);
+        }
+
+        state.extraSpins++;
+        this.persistUserState(userId, state);
+        return true;
+    }
+
+    public void savePrize(int id, String type, String value, int amount, int pointsType, int weight, String label) {
+        String safeType = (type != null && VALID_PRIZE_TYPES.contains(type)) ? type : "nothing";
+        String safeValue = truncate(value, MAX_STRING_LEN);
+        String safeLabel = truncate(label, MAX_STRING_LEN);
+        int safeAmount = clamp(amount, 0, MAX_PRIZE_AMOUNT);
+        int safeWeight = clamp(weight, 0, MAX_WEIGHT);
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement(
+                     "UPDATE wheel_prizes SET type = ?, value = ?, amount = ?, points_type = ?, weight = ?, label = ? WHERE id = ?")) {
+            statement.setString(1, safeType);
+            statement.setString(2, safeValue);
+            statement.setInt(3, safeAmount);
+            statement.setInt(4, pointsType);
+            statement.setInt(5, safeWeight);
+            statement.setString(6, safeLabel);
+            statement.setInt(7, id);
+            statement.executeUpdate();
+        } catch (SQLException e) {
+            LOGGER.error("Failed to save wheel prize {}", id, e);
+        }
+    }
+
+    private static String truncate(String s, int max) {
+        if (s == null) return "";
+        return s.length() <= max ? s : s.substring(0, max);
+    }
+
+    private static int clamp(int value, int min, int max) {
+        if (value < min) return min;
+        if (value > max) return max;
+        return value;
+    }
+}

Emulator/src/main/java/com/eu/habbo/habbohotel/wheel/WheelPrize.java

@@ -0,0 +1,44 @@
+package com.eu.habbo.habbohotel.wheel;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.items.Item;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+// One slice of the wheel. type = item | badge | credits | points | spin | nothing.
+public class WheelPrize {
+    public final int id;
+    public final String type;
+    public final String value;   // item: base item id ; badge: badge code ; others: unused
+    public final int amount;     // item qty / credits / points / extra spins
+    public final int pointsType; // for type=points
+    public final int weight;
+    public final String label;
+    public final int spriteId;   // resolved for item prizes so the client can render the furni icon
+
+    public WheelPrize(ResultSet set) throws SQLException {
+        this.id = set.getInt("id");
+        this.type = set.getString("type");
+        this.value = set.getString("value");
+        this.amount = set.getInt("amount");
+        this.pointsType = set.getInt("points_type");
+        this.weight = Math.max(0, set.getInt("weight"));
+        this.label = set.getString("label");
+        this.spriteId = resolveSpriteId(this.type, this.value);
+    }
+
+    private static int resolveSpriteId(String type, String value) {
+        if (!"item".equals(type) || value == null) return 0;
+        try {
+            Item item = Emulator.getGameEnvironment().getItemManager().getItem(Integer.parseInt(value.trim()));
+            return item != null ? item.getSpriteId() : 0;
+        } catch (NumberFormatException e) {
+            return 0;
+        }
+    }
+
+    public String badgeCode() {
+        return "badge".equals(this.type) && this.value != null ? this.value : "";
+    }
+}

Emulator/src/main/java/com/eu/habbo/habbohotel/wheel/WheelRecentWin.java

@@ -0,0 +1,14 @@
+package com.eu.habbo.habbohotel.wheel;
+
+// A row in the "latest winners" panel. Denormalized (username/look stored at win time).
+public class WheelRecentWin {
+    public final String username;
+    public final String look;
+    public final String prizeLabel;
+
+    public WheelRecentWin(String username, String look, String prizeLabel) {
+        this.username = username != null ? username : "";
+        this.look = look != null ? look : "";
+        this.prizeLabel = prizeLabel != null ? prizeLabel : "";
+    }
+}

Emulator/src/main/java/com/eu/habbo/habbohotel/wheel/WheelUserState.java

@@ -0,0 +1,12 @@
+package com.eu.habbo.habbohotel.wheel;
+
+// Per-user spin balance. freeSpins resets daily (lazy, on access); extraSpins persist.
+public class WheelUserState {
+    public int freeSpins;
+    public int extraSpins;
+    public int lastReset; // day index (unix / 86400) of the last daily reset
+
+    public int totalSpins() {
+        return this.freeSpins + this.extraSpins;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/PacketManager.java

@@ -719,5 +719,42 @@ public class PacketManager {
         this.registerHandler(Incoming.YouTubeRoomPlayEvent, com.eu.habbo.messages.incoming.rooms.youtube.YouTubeRoomPlayEvent.class);
         this.registerHandler(Incoming.YouTubeRoomWatchingEvent, com.eu.habbo.messages.incoming.rooms.youtube.YouTubeRoomWatchingEvent.class);
         this.registerHandler(Incoming.YouTubeRoomSettingsEvent, com.eu.habbo.messages.incoming.rooms.youtube.YouTubeRoomSettingsEvent.class);
+
+        // Housekeeping (in-client admin panel)
+        this.registerHandler(Incoming.HousekeepingFindUserByNameEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingFindUserByNameEvent.class);
+        this.registerHandler(Incoming.HousekeepingFindUserByIdEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingFindUserByIdEvent.class);
+        this.registerHandler(Incoming.HousekeepingBanUserEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingBanUserEvent.class);
+        this.registerHandler(Incoming.HousekeepingUnbanUserEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingUnbanUserEvent.class);
+        this.registerHandler(Incoming.HousekeepingMuteUserEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingMuteUserEvent.class);
+        this.registerHandler(Incoming.HousekeepingKickUserEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingKickUserEvent.class);
+        this.registerHandler(Incoming.HousekeepingForceDisconnectUserEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingForceDisconnectUserEvent.class);
+        this.registerHandler(Incoming.HousekeepingSetUserRankEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingSetUserRankEvent.class);
+        this.registerHandler(Incoming.HousekeepingTradeLockUserEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingTradeLockUserEvent.class);
+        this.registerHandler(Incoming.HousekeepingResetUserPasswordEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingResetUserPasswordEvent.class);
+        this.registerHandler(Incoming.HousekeepingFindRoomByIdEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingFindRoomByIdEvent.class);
+        this.registerHandler(Incoming.HousekeepingSearchRoomsEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingSearchRoomsEvent.class);
+        this.registerHandler(Incoming.HousekeepingRoomStateEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingRoomStateEvent.class);
+        this.registerHandler(Incoming.HousekeepingMuteRoomEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingMuteRoomEvent.class);
+        this.registerHandler(Incoming.HousekeepingKickAllFromRoomEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingKickAllFromRoomEvent.class);
+        this.registerHandler(Incoming.HousekeepingTransferRoomOwnershipEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingTransferRoomOwnershipEvent.class);
+        this.registerHandler(Incoming.HousekeepingDeleteRoomEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingDeleteRoomEvent.class);
+        this.registerHandler(Incoming.HousekeepingGiveCreditsEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingGiveCreditsEvent.class);
+        this.registerHandler(Incoming.HousekeepingGiveCurrencyEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingGiveCurrencyEvent.class);
+        this.registerHandler(Incoming.HousekeepingGrantItemEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingGrantItemEvent.class);
+        this.registerHandler(Incoming.HousekeepingSetHcSubscriptionEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingSetHcSubscriptionEvent.class);
+        this.registerHandler(Incoming.HousekeepingSendHotelAlertEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingSendHotelAlertEvent.class);
+        this.registerHandler(Incoming.HousekeepingGetDashboardEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingGetDashboardEvent.class);
+        this.registerHandler(Incoming.HousekeepingListActionLogEvent, com.eu.habbo.messages.incoming.housekeeping.HousekeepingListActionLogEvent.class);
+
+        this.registerHandler(Incoming.RequestRareValuesEvent, com.eu.habbo.messages.incoming.rarevalues.RequestRareValuesEvent.class);
+
+        this.registerHandler(Incoming.WheelOpenEvent, com.eu.habbo.messages.incoming.wheel.WheelOpenEvent.class);
+        this.registerHandler(Incoming.WheelSpinEvent, com.eu.habbo.messages.incoming.wheel.WheelSpinEvent.class);
+        this.registerHandler(Incoming.WheelBuySpinEvent, com.eu.habbo.messages.incoming.wheel.WheelBuySpinEvent.class);
+        this.registerHandler(Incoming.WheelAdminGetPrizesEvent, com.eu.habbo.messages.incoming.wheel.WheelAdminGetPrizesEvent.class);
+        this.registerHandler(Incoming.WheelAdminSavePrizesEvent, com.eu.habbo.messages.incoming.wheel.WheelAdminSavePrizesEvent.class);
+
+        this.registerHandler(Incoming.SoundboardPlayEvent, com.eu.habbo.messages.incoming.soundboard.SoundboardPlayEvent.class);
+        this.registerHandler(Incoming.SoundboardSetEnabledEvent, com.eu.habbo.messages.incoming.soundboard.SoundboardSetEnabledEvent.class);
     }
 }

Emulator/src/main/java/com/eu/habbo/messages/incoming/Incoming.java

@@ -460,4 +460,40 @@ public class Incoming {
     public static final int YouTubeRoomPlayEvent = 8001;
     public static final int YouTubeRoomWatchingEvent = 8002;
     public static final int YouTubeRoomSettingsEvent = 8003;
+
+    // Housekeeping (in-client admin panel) — IDs 9100..9199 reserved
+    public static final int HousekeepingFindUserByNameEvent = 9100;
+    public static final int HousekeepingFindUserByIdEvent = 9101;
+    public static final int HousekeepingBanUserEvent = 9102;
+    public static final int HousekeepingUnbanUserEvent = 9103;
+    public static final int HousekeepingMuteUserEvent = 9104;
+    public static final int HousekeepingKickUserEvent = 9105;
+    public static final int HousekeepingForceDisconnectUserEvent = 9106;
+    public static final int HousekeepingSetUserRankEvent = 9107;
+    public static final int HousekeepingTradeLockUserEvent = 9108;
+    public static final int HousekeepingResetUserPasswordEvent = 9109;
+    public static final int HousekeepingFindRoomByIdEvent = 9110;
+    public static final int HousekeepingSearchRoomsEvent = 9111;
+    public static final int HousekeepingRoomStateEvent = 9112;
+    public static final int HousekeepingMuteRoomEvent = 9113;
+    public static final int HousekeepingKickAllFromRoomEvent = 9114;
+    public static final int HousekeepingTransferRoomOwnershipEvent = 9115;
+    public static final int HousekeepingDeleteRoomEvent = 9116;
+    public static final int HousekeepingGiveCreditsEvent = 9117;
+    public static final int HousekeepingGiveCurrencyEvent = 9118;
+    public static final int HousekeepingGrantItemEvent = 9119;
+    public static final int HousekeepingSetHcSubscriptionEvent = 9120;
+    public static final int HousekeepingSendHotelAlertEvent = 9121;
+    public static final int HousekeepingGetDashboardEvent = 9122;
+    public static final int HousekeepingListActionLogEvent = 9123;
+
+    // Custom features — IDs 9300+ reserved
+    public static final int RequestRareValuesEvent = 9300;
+    public static final int WheelOpenEvent = 9301;
+    public static final int WheelSpinEvent = 9302;
+    public static final int WheelBuySpinEvent = 9303;
+    public static final int WheelAdminGetPrizesEvent = 9304;
+    public static final int WheelAdminSavePrizesEvent = 9305;
+    public static final int SoundboardPlayEvent = 9306;
+    public static final int SoundboardSetEnabledEvent = 9307;
 }

Emulator/src/main/java/com/eu/habbo/messages/incoming/catalog/CatalogBuyItemAsGiftEvent.java

@@ -175,6 +175,19 @@ public class CatalogBuyItemAsGiftEvent extends MessageHandler {
 
                     CatalogItem item = page.getCatalogItem(itemId);
 
+                    // Search-results gift sends the catalog offer_id as
+                    // itemId, not catalog_items.id - see the same fix in
+                    // CatalogBuyItemEvent. Fall back to scanning the
+                    // page for the matching offer_id.
+                    if (item == null) {
+                        for (CatalogItem candidate : page.getCatalogItems().valueCollection()) {
+                            if (candidate != null && candidate.getOfferId() == itemId) {
+                                item = candidate;
+                                break;
+                            }
+                        }
+                    }
+
                     if (item == null) {
                         LOGGER.debug("catalog item null -> {}", itemId);
                         this.client.sendResponse(new AlertPurchaseFailedComposer(AlertPurchaseFailedComposer.SERVER_ERROR).compose());

Emulator/src/main/java/com/eu/habbo/messages/incoming/catalog/CatalogBuyItemEvent.java

@@ -5,6 +5,7 @@ import com.eu.habbo.habbohotel.bots.BotManager;
 import com.eu.habbo.habbohotel.catalog.*;
 import com.eu.habbo.habbohotel.catalog.layouts.*;
 import com.eu.habbo.habbohotel.items.FurnitureType;
+import com.eu.habbo.habbohotel.items.Item;
 import com.eu.habbo.habbohotel.permissions.Permission;
 import com.eu.habbo.habbohotel.pets.PetManager;
 import com.eu.habbo.habbohotel.rooms.BuildersClubRoomSupport;
@@ -201,15 +202,48 @@ public class CatalogBuyItemEvent extends MessageHandler {
 
             else
                 item = page.getCatalogItem(itemId);
-            // temp patch, can a dev with better knowledge than me look into this asap pls.
-            if (page instanceof  BotsLayout) {
-                if (!this.client.getHabbo().hasPermission(Permission.ACC_UNLIMITED_BOTS) && this.client.getHabbo().getInventory().getBotsComponent().getBots().size() >= BotManager.MAXIMUM_BOT_INVENTORY_SIZE) {
-                    this.client.getHabbo().alert(Emulator.getTexts().getValue("error.bots.max.inventory").replace("%amount%", BotManager.MAXIMUM_BOT_INVENTORY_SIZE + ""));
-                    return;
+
+            // Search-results buy sends the catalog offer_id as itemId
+            // (FurnitureOffer.offerId is derived from furnidata's
+            // purchaseOfferId, which matches `catalog_items.offer_id`),
+            // not the `catalog_items.id` primary key that getCatalogItem
+            // expects. Fall back to scanning the page for the matching
+            // offer_id so the search → buy flow works.
+            if (item == null && !(page instanceof RecentPurchasesLayout)) {
+                for (CatalogItem candidate : page.getCatalogItems().valueCollection()) {
+                    if (candidate != null && candidate.getOfferId() == itemId) {
+                        item = candidate;
+                        break;
+                    }
                 }
             }
-            if (page instanceof PetsLayout) {
-                if (!this.client.getHabbo().hasPermission(Permission.ACC_UNLIMITED_PETS) && this.client.getHabbo().getInventory().getPetsComponent().getPets().size() >= PetManager.MAXIMUM_PET_INVENTORY_SIZE) {
+            // Inventory cap check based on the actual base items the
+            // purchase will create, not the page layout - bots/pets
+            // can legitimately live on bundle pages, search results,
+            // recent-purchases, etc., and the layout-instanceof check
+            // missed all those paths. Mirrors the bot/pet branches
+            // inside CatalogManager.purchaseItem (Item.isBot / isPet
+            // and the same prefix check) so detection stays in sync.
+            boolean itemHasBot = false;
+            boolean itemHasPet = false;
+
+            if (item != null) {
+                for (Item baseItem : item.getBaseItems()) {
+                    if (baseItem == null) continue;
+                    if (Item.isBot(baseItem)) itemHasBot = true;
+                    if (Item.isPet(baseItem)) itemHasPet = true;
+                }
+            }
+
+            if (itemHasBot && !this.client.getHabbo().hasPermission(Permission.ACC_UNLIMITED_BOTS)
+                    && this.client.getHabbo().getInventory().getBotsComponent().getBots().size() >= BotManager.MAXIMUM_BOT_INVENTORY_SIZE) {
+                this.client.getHabbo().alert(Emulator.getTexts().getValue("error.bots.max.inventory").replace("%amount%", BotManager.MAXIMUM_BOT_INVENTORY_SIZE + ""));
+                return;
+            }
+
+            if (itemHasPet) {
+                if (!this.client.getHabbo().hasPermission(Permission.ACC_UNLIMITED_PETS)
+                        && this.client.getHabbo().getInventory().getPetsComponent().getPets().size() >= PetManager.MAXIMUM_PET_INVENTORY_SIZE) {
                     this.client.getHabbo().alert(Emulator.getTexts().getValue("error.pets.max.inventory").replace("%amount%", PetManager.MAXIMUM_PET_INVENTORY_SIZE + ""));
                     return;
                 }

Emulator/src/main/java/com/eu/habbo/messages/incoming/floorplaneditor/FloorPlanEditorSaveEvent.java

@@ -4,23 +4,36 @@ import com.eu.habbo.Emulator;
 import com.eu.habbo.habbohotel.permissions.Permission;
 import com.eu.habbo.habbohotel.rooms.*;
 import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.habbohotel.users.HabboItem;
 import com.eu.habbo.messages.ServerMessage;
 import com.eu.habbo.messages.incoming.MessageHandler;
 import com.eu.habbo.messages.outgoing.generic.alerts.BubbleAlertComposer;
 import com.eu.habbo.messages.outgoing.generic.alerts.BubbleAlertKeys;
 import com.eu.habbo.messages.outgoing.generic.alerts.GenericAlertComposer;
+import com.eu.habbo.messages.outgoing.inventory.AddHabboItemComposer;
+import com.eu.habbo.messages.outgoing.inventory.InventoryRefreshComposer;
 import com.eu.habbo.messages.outgoing.rooms.ForwardToRoomComposer;
 import gnu.trove.set.hash.THashSet;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.StringJoiner;
+import java.util.regex.Pattern;
 
 public class FloorPlanEditorSaveEvent extends MessageHandler {
+    private static final Logger LOGGER = LoggerFactory.getLogger(FloorPlanEditorSaveEvent.class);
+
     public static int MAXIMUM_FLOORPLAN_WIDTH_LENGTH = 64;
     public static int MAXIMUM_FLOORPLAN_SIZE = 64 * 64;
 
+    private static final int SAVE_COOLDOWN_SECONDS = 3;
+    private static final int MAX_AUTO_PICKUP_ITEMS = 500;
+    private static final Pattern ALLOWED_MAP_CHARS = Pattern.compile("[a-zA-Z0-9\r]+");
+
     @Override
     public int getRatelimit() {
         return 500;
@@ -38,153 +51,244 @@ public class FloorPlanEditorSaveEvent extends MessageHandler {
         if (room == null)
             return;
 
-        if (room.getOwnerId() == this.client.getHabbo().getHabboInfo().getId() || this.client.getHabbo().hasPermission(Permission.ACC_ANYROOMOWNER)) {
-            StringJoiner errors = new StringJoiner("<br />");
-            String map = this.packet.readString();
-            map = map.replace("X", "x");
+        if (!(room.getOwnerId() == this.client.getHabbo().getHabboInfo().getId() || this.client.getHabbo().hasPermission(Permission.ACC_ANYROOMOWNER))) {
+            return;
+        }
 
-            String[] mapRows = map.split("\r");
+        long now = Emulator.getIntUnixTimestamp();
+        if (now - this.client.getHabbo().getHabboStats().lastFloorplanSaveTimestamp < SAVE_COOLDOWN_SECONDS) {
+            this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FLOORPLAN_EDITOR_ERROR.key, "Please wait a few seconds before saving again."));
+            return;
+        }
 
-            int firstRowSize = mapRows[0].length();
+        StringJoiner errors = new StringJoiner("<br />");
+        String map = this.packet.readString();
 
-            if (Emulator.getConfig().getBoolean("hotel.room.floorplan.check.enabled")) {
-                if (!map.matches("[a-zA-Z0-9\r]+")) errors.add("${notification.floorplan_editor.error.title}");
+        if (map == null || map.length() > MAXIMUM_FLOORPLAN_SIZE) {
+            LOGGER.warn("Floorplan save rejected (oversize): user={} room={} mapLen={}",
+                    this.client.getHabbo().getHabboInfo().getId(), room.getId(), map == null ? 0 : map.length());
+            return;
+        }
 
-                Arrays.stream(mapRows)
-                        .filter(line -> line.length() != firstRowSize)
-                        .findAny()
-                        .ifPresent(s -> errors.add("(General): Line " + (Arrays.asList(mapRows).indexOf(s) + 1) + " is of different length than line 1"));
+        if (!ALLOWED_MAP_CHARS.matcher(map).matches()) {
+            LOGGER.warn("Floorplan save rejected (illegal chars): user={} room={}",
+                    this.client.getHabbo().getHabboInfo().getId(), room.getId());
+            return;
+        }
 
-                if (map.isEmpty() || map.replace("x", "").replace("\r", "").isEmpty()) {
-                    errors.add("${notification.floorplan_editor.error.message.effective_height_is_0}");
+        map = map.replace("X", "x");
+
+        String[] mapRows = map.split("\r");
+
+        if (mapRows.length == 0 || mapRows.length > MAXIMUM_FLOORPLAN_WIDTH_LENGTH) {
+            return;
+        }
+
+        int firstRowSize = mapRows[0].length();
+
+        if (firstRowSize == 0 || firstRowSize > MAXIMUM_FLOORPLAN_WIDTH_LENGTH) {
+            return;
+        }
+
+        for (String row : mapRows) {
+            if (row.length() != firstRowSize) {
+                return;
+            }
+        }
+
+        if (Emulator.getConfig().getBoolean("hotel.room.floorplan.check.enabled")) {
+            if (map.replace("x", "").replace("\r", "").isEmpty()) {
+                errors.add("${notification.floorplan_editor.error.message.effective_height_is_0}");
+            }
+        }
+
+        int doorX = this.packet.readInt();
+        int doorY = this.packet.readInt();
+
+        if (doorX < 0 || doorX >= firstRowSize || doorY < 0 || doorY >= mapRows.length) {
+            errors.add("${notification.floorplan_editor.error.message.entry_tile_outside_map}");
+        } else if (mapRows[doorY].charAt(doorX) == 'x') {
+            errors.add("${notification.floorplan_editor.error.message.entry_not_on_tile}");
+        }
+
+        int doorRotation = this.packet.readInt();
+        if (doorRotation < 0 || doorRotation > 7) {
+            errors.add("${notification.floorplan_editor.error.message.invalid_entry_tile_direction}");
+        }
+
+        int wallSize = this.packet.readInt();
+        if (wallSize < -2 || wallSize > 1) {
+            errors.add("${notification.floorplan_editor.error.message.invalid_wall_thickness}");
+        }
+        int floorSize = this.packet.readInt();
+        if (floorSize < -2 || floorSize > 1) {
+            errors.add("${notification.floorplan_editor.error.message.invalid_floor_thickness}");
+        }
+
+        int wallHeight = -1;
+        if (this.packet.bytesAvailable() >= 4)
+            wallHeight = this.packet.readInt();
+
+        if (wallHeight < -1 || wallHeight > 15) {
+            errors.add("${notification.floorplan_editor.error.message.invalid_walls_fixed_height}");
+        }
+
+        boolean autoPickup = false;
+        if (this.packet.bytesAvailable() >= 1) {
+            autoPickup = this.packet.readBoolean();
+        }
+
+        if (errors.length() > 0) {
+            this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FLOORPLAN_EDITOR_ERROR.key, errors.toString()));
+            return;
+        }
+
+        THashSet<RoomTile> locked_tileList = room.getLockedTiles();
+        THashSet<RoomTile> new_tileList = new THashSet<>();
+        THashSet<HabboItem> itemsToPickup = new THashSet<>();
+        int blockedX = -1;
+        int blockedY = -1;
+        blockingRoomItemScan:
+        for (int y = 0; y < mapRows.length; y++) {
+            for (int x = 0; x < firstRowSize; x++) {
+
+                RoomTile tile = room.getLayout().getTile((short) x, (short) y);
+                new_tileList.add(tile);
+                String square = String.valueOf(mapRows[y].charAt(x));
+                short height;
+
+                if (square.equalsIgnoreCase("x") && room.getTopItemAt(x, y) != null) {
+                    if (autoPickup) {
+                        THashSet<HabboItem> here = room.getItemsAt(x, y);
+                        if (here != null) itemsToPickup.addAll(here);
+                        continue;
+                    }
+                    blockedX = x;
+                    blockedY = y;
+                    break blockingRoomItemScan;
                 }
 
-                if (map.length() > MAXIMUM_FLOORPLAN_SIZE) {
-                    errors.add("${notification.floorplan_editor.error.message.too_large_area}");
-                }
-
-                if (mapRows.length > MAXIMUM_FLOORPLAN_WIDTH_LENGTH) errors.add("${notification.floorplan_editor.error.message.too_large_height}");
-                else if (Arrays.stream(mapRows).anyMatch(l -> l.length() > MAXIMUM_FLOORPLAN_WIDTH_LENGTH || l.isEmpty())) errors.add("${notification.floorplan_editor.error.message.too_large_width}");
-
-                if (errors.length() > 0) {
-                    this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FLOORPLAN_EDITOR_ERROR.key, errors.toString()));
+                try {
+                    if (square.isEmpty()) {
+                        height = 0;
+                    } else if (Emulator.isNumeric(square)) {
+                        height = Short.parseShort(square);
+                    } else {
+                        int idx = "abcdefghijklmnopqrstuvwxyz".indexOf(square.toLowerCase());
+                        if (idx < 0) {
+                            return;
+                        }
+                        height = (short) Math.min(26, 10 + idx);
+                    }
+                } catch (NumberFormatException e) {
                     return;
                 }
-            }
 
-            int doorX = this.packet.readInt();
-            int doorY = this.packet.readInt();
-
-            if (doorX < 0 || doorX > firstRowSize || doorY < 0 || doorY >= mapRows.length) {
-                errors.add("${notification.floorplan_editor.error.message.entry_tile_outside_map}");
-            }
-
-            if (doorY < mapRows.length && doorX < mapRows[doorY].length() && mapRows[doorY].charAt(doorX) == 'x') {
-                errors.add("${notification.floorplan_editor.error.message.entry_not_on_tile}");
-            }
-
-            int doorRotation = this.packet.readInt();
-            if (doorRotation < 0 || doorRotation > 7) {
-                errors.add("${notification.floorplan_editor.error.message.invalid_entry_tile_direction}");
-            }
-
-            int wallSize = this.packet.readInt();
-            if (wallSize < -2 || wallSize > 1) {
-                errors.add("${notification.floorplan_editor.error.message.invalid_wall_thickness}");
-            }
-            int floorSize = this.packet.readInt();
-            if (floorSize < -2 || floorSize > 1) {
-                errors.add("${notification.floorplan_editor.error.message.invalid_floor_thickness}");
-            }
-
-            int wallHeight = -1;
-            if (this.packet.bytesAvailable() >= 4)
-                wallHeight = this.packet.readInt();
-
-            if (wallHeight < -1 || wallHeight > 15) {
-                errors.add("${notification.floorplan_editor.error.message.invalid_walls_fixed_height}");
-            }
-
-            THashSet<RoomTile> locked_tileList = room.getLockedTiles();
-            THashSet<RoomTile> new_tileList = new THashSet<>();
-            blockingRoomItemScan:
-            for (int y = 0; y < mapRows.length; y++) {
-                for (int x = 0; x < firstRowSize; x++) {
-
-                    RoomTile tile = room.getLayout().getTile((short) x, (short) y);
-                    new_tileList.add(tile);
-                    String square = String.valueOf(mapRows[y].charAt(x));
-                    short height;
-
-                    if (square.equalsIgnoreCase("x") && room.getTopItemAt(x, y) != null) {
-                        errors.add("${notification.floorplan_editor.error.message.change_blocked_by_room_item}");
-                        break blockingRoomItemScan;
-                    } else {
-                        if (square.isEmpty()) {
-                            height = 0;
-                        } else if (Emulator.isNumeric(square)) {
-                            height = Short.parseShort(square);
-                        } else {
-                            height = (short) (10 + "ABCDEFGHIJKLMNOPQRSTUVWXYZ".indexOf(square.toUpperCase()));
-                        }
-                    }
-
-                    if (tile != null && tile.state != RoomTileState.INVALID && height != tile.z && room.getTopItemAt(x, y) != null) {
-                        errors.add("${notification.floorplan_editor.error.message.change_blocked_by_room_item}");
-                        break blockingRoomItemScan;
+                if (tile != null && tile.state != RoomTileState.INVALID && height != tile.z && room.getTopItemAt(x, y) != null) {
+                    if (autoPickup) {
+                        THashSet<HabboItem> here = room.getItemsAt(x, y);
+                        if (here != null) itemsToPickup.addAll(here);
+                        continue;
                     }
+                    blockedX = x;
+                    blockedY = y;
+                    break blockingRoomItemScan;
                 }
             }
+        }
 
+        if (blockedX < 0) {
             locked_tileList.removeAll(new_tileList);
             if (!locked_tileList.isEmpty()) {
-                errors.add("${notification.floorplan_editor.error.message.change_blocked_by_room_item}");
+                if (autoPickup) {
+                    for (RoomTile lt : locked_tileList) {
+                        THashSet<HabboItem> here = room.getItemsAt(lt.x, lt.y);
+                        if (here != null) itemsToPickup.addAll(here);
+                    }
+                } else {
+                    RoomTile first = locked_tileList.iterator().next();
+                    blockedX = first.x;
+                    blockedY = first.y;
+                }
             }
+        }
 
+        if (blockedX >= 0) {
+            this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FLOORPLAN_EDITOR_ERROR.key,
+                    "${notification.floorplan_editor.error.message.change_blocked_by_room_item} (" + blockedX + ", " + blockedY + ")"));
+            return;
+        }
 
-
-            if (errors.length() > 0) {
-                this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FLOORPLAN_EDITOR_ERROR.key, errors.toString()));
+        if (autoPickup && !itemsToPickup.isEmpty()) {
+            if (itemsToPickup.size() > MAX_AUTO_PICKUP_ITEMS) {
+                LOGGER.warn("Floorplan auto-pickup rejected (over cap): user={} room={} itemCount={} cap={}",
+                        this.client.getHabbo().getHabboInfo().getId(), room.getId(), itemsToPickup.size(), MAX_AUTO_PICKUP_ITEMS);
+                this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FLOORPLAN_EDITOR_ERROR.key,
+                        "Too many items would be picked up (" + itemsToPickup.size() + " > " + MAX_AUTO_PICKUP_ITEMS + "). Remove some furniture manually and save again."));
                 return;
             }
 
-            RoomLayout layout = room.getLayout();
-
-            if (layout instanceof CustomRoomLayout) {
-                layout.setDoorX((short) doorX);
-                layout.setDoorY((short) doorY);
-                layout.setDoorDirection(doorRotation);
-                layout.setHeightmap(map);
-                layout.parse();
-
-                if (layout.getDoorTile() == null) {
-                    this.client.getHabbo().alert("Error");
-                    ((CustomRoomLayout) layout).needsUpdate(false);
-                    Emulator.getGameEnvironment().getRoomManager().unloadRoom(room);
-                    return;
-                }
-                ((CustomRoomLayout) layout).needsUpdate(true);
-                Emulator.getThreading().run((CustomRoomLayout) layout);
-            } else {
-                layout = Emulator.getGameEnvironment().getRoomManager().insertCustomLayout(room, map, doorX, doorY, doorRotation);
+            Map<Integer, ArrayList<HabboItem>> byOwner = new HashMap<>();
+            for (HabboItem itm : itemsToPickup) {
+                if (itm == null) continue;
+                byOwner.computeIfAbsent(itm.getUserId(), k -> new ArrayList<>()).add(itm);
+                room.pickUpItem(itm, null);
             }
 
-            if (layout != null) {
-                room.setHasCustomLayout(true);
-                room.setNeedsUpdate(true);
-                room.setLayout(layout);
-                room.setWallSize(wallSize);
-                room.setFloorSize(floorSize);
-                room.setWallHeight(wallHeight);
-                room.save();
-                Collection<Habbo> habbos = new ArrayList<>(room.getUserCount());
-                habbos.addAll(room.getHabbos());
-                Emulator.getGameEnvironment().getRoomManager().unloadRoom(room);
-                room = Emulator.getGameEnvironment().getRoomManager().loadRoom(room.getId());
-                ServerMessage message = new ForwardToRoomComposer(room.getId()).compose();
-                for (Habbo habbo : habbos) {
-                    habbo.getClient().sendResponse(message);
+            for (Map.Entry<Integer, ArrayList<HabboItem>> entry : byOwner.entrySet()) {
+                Habbo owner = Emulator.getGameEnvironment().getHabboManager().getHabbo(entry.getKey());
+                if (owner == null) continue;
+                for (HabboItem itm : entry.getValue()) {
+                    owner.getClient().sendResponse(new AddHabboItemComposer(itm));
                 }
+                owner.getClient().sendResponse(new InventoryRefreshComposer());
+            }
+
+            LOGGER.info("Floorplan auto-pickup: user={} room={} itemCount={} owners={}",
+                    this.client.getHabbo().getHabboInfo().getId(), room.getId(), itemsToPickup.size(), byOwner.size());
+        }
+
+        RoomLayout layout = room.getLayout();
+
+        if (layout instanceof CustomRoomLayout) {
+            layout.setDoorX((short) doorX);
+            layout.setDoorY((short) doorY);
+            layout.setDoorDirection(doorRotation);
+            layout.setHeightmap(map);
+            layout.parse();
+
+            if (layout.getDoorTile() == null) {
+                this.client.getHabbo().alert("Error");
+                ((CustomRoomLayout) layout).needsUpdate(false);
+                Emulator.getGameEnvironment().getRoomManager().unloadRoom(room);
+                return;
+            }
+            ((CustomRoomLayout) layout).needsUpdate(true);
+            Emulator.getThreading().run((CustomRoomLayout) layout);
+        } else {
+            layout = Emulator.getGameEnvironment().getRoomManager().insertCustomLayout(room, map, doorX, doorY, doorRotation);
+        }
+
+        if (layout != null) {
+            room.setHasCustomLayout(true);
+            room.setNeedsUpdate(true);
+            room.setLayout(layout);
+            room.setWallSize(wallSize);
+            room.setFloorSize(floorSize);
+            room.setWallHeight(wallHeight);
+            room.save();
+
+            this.client.getHabbo().getHabboStats().lastFloorplanSaveTimestamp = now;
+            LOGGER.info("Floorplan saved: user={} room={} mapLen={} rows={} cols={}",
+                    this.client.getHabbo().getHabboInfo().getId(), room.getId(), map.length(), mapRows.length, firstRowSize);
+
+            Collection<Habbo> habbos = new ArrayList<>(room.getUserCount());
+            habbos.addAll(room.getHabbos());
+            Emulator.getGameEnvironment().getRoomManager().unloadRoom(room);
+            room = Emulator.getGameEnvironment().getRoomManager().loadRoom(room.getId());
+            ServerMessage message = new ForwardToRoomComposer(room.getId()).compose();
+            for (Habbo habbo : habbos) {
+                habbo.getClient().sendResponse(message);
             }
         }
     }

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingBanUserEvent.java

@@ -0,0 +1,61 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.modtool.ModToolBan;
+import com.eu.habbo.habbohotel.modtool.ModToolBanType;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+import java.util.List;
+
+/**
+ * Apply an arbitrary-duration account ban. Duration is taken in hours
+ * from the wire and converted to seconds for ModToolManager.ban —
+ * unlike ModToolSanctionBanEvent which only accepts the four fixed
+ * Habbo-protocol banType buckets.
+ */
+public class HousekeepingBanUserEvent extends MessageHandler {
+    private static final String ACTION_KEY = "user.ban";
+    private static final int SECONDS_IN_HOUR = 3600;
+    // 100-year ceiling, matches ModToolSanctionBanEvent's permanent ban.
+    private static final int MAX_DURATION_SECONDS = 100 * 365 * 24 * 3600;
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int userId = this.packet.readInt();
+        String reason = this.packet.readString();
+        int hours = this.packet.readInt();
+
+        if (userId <= 0 || hours <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        long durationLong = (long) hours * SECONDS_IN_HOUR;
+        int duration = durationLong > MAX_DURATION_SECONDS ? MAX_DURATION_SECONDS : (int) durationLong;
+
+        List<ModToolBan> bans = Emulator.getGameEnvironment().getModToolManager()
+                .ban(userId, this.client.getHabbo(), reason != null ? reason : "", duration, ModToolBanType.ACCOUNT, 0);
+
+        if (bans == null || bans.isEmpty()) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.ban_failed"));
+            return;
+        }
+
+        // ModToolBan doesn't expose the `bans` table autoinc id on the
+        // object, so we return the target user id as the actionId — it's
+        // the only stable handle the client can use until a dedicated
+        // housekeeping_log row id supersedes it.
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, userId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingDeleteRoomEvent.java

@@ -0,0 +1,68 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.rooms.Room;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+/**
+ * Permanently delete a room. Mirrors the minimum-viable subset of
+ * RequestDeleteRoomEvent: eject all users from the live room, dispose
+ * + uncache, then DELETE FROM rooms. Pets/guild/custom-layout cleanup
+ * is intentionally skipped on this slice — leftover rows in those
+ * tables become orphans but don't crash the emulator; a follow-up
+ * pass can cascade once we have a HK audit-log row to attach the
+ * orphan-cleanup to.
+ */
+public class HousekeepingDeleteRoomEvent extends MessageHandler {
+    private static final String ACTION_KEY = "room.delete";
+
+    @Override
+    public int getRatelimit() {
+        return 2000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int roomId = this.packet.readInt();
+
+        if (roomId <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        Room room = Emulator.getGameEnvironment().getRoomManager().loadRoom(roomId, false);
+
+        if (room != null) {
+            room.ejectAll();
+            room.preventUnloading = false;
+            room.dispose();
+            Emulator.getGameEnvironment().getRoomManager().uncacheRoom(room);
+        }
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("DELETE FROM rooms WHERE id = ? LIMIT 1")) {
+            statement.setInt(1, roomId);
+            int rows = statement.executeUpdate();
+
+            if (rows == 0) {
+                this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.room_not_found"));
+                return;
+            }
+        } catch (SQLException e) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.db_failed"));
+            return;
+        }
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, roomId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingFindRoomByIdEvent.java

@@ -0,0 +1,37 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.rooms.Room;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingRoomDetailComposer;
+
+public class HousekeepingFindRoomByIdEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 500;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int roomId = this.packet.readInt();
+
+        if (roomId <= 0) {
+            this.client.sendResponse(new HousekeepingRoomDetailComposer(null));
+            return;
+        }
+
+        // loadRoom covers both the in-memory cache (already-loaded rooms)
+        // and the offline path (SELECT * FROM rooms WHERE id=?). Pass
+        // false for loadData so we don't pull furni/bots/pets just to
+        // render an HK panel summary — getOwnerName / getUserCount work
+        // on the pre-loaded skeleton.
+        Room room = Emulator.getGameEnvironment().getRoomManager().loadRoom(roomId, false);
+
+        this.client.sendResponse(new HousekeepingRoomDetailComposer(room));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingFindUserByIdEvent.java

@@ -0,0 +1,35 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.users.HabboInfo;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingUserDetailComposer;
+
+public class HousekeepingFindUserByIdEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 500;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int userId = this.packet.readInt();
+
+        if (userId <= 0) {
+            this.client.sendResponse(new HousekeepingUserDetailComposer(null));
+            return;
+        }
+
+        // HabboManager.getHabboInfo(int) returns the in-memory record for
+        // online users and falls through to the offline SQL lookup
+        // otherwise, so a single call covers both branches.
+        HabboInfo info = Emulator.getGameEnvironment().getHabboManager().getHabboInfo(userId);
+
+        this.client.sendResponse(new HousekeepingUserDetailComposer(info));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingFindUserByNameEvent.java

@@ -0,0 +1,35 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.habbohotel.users.HabboInfo;
+import com.eu.habbo.habbohotel.users.HabboManager;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingUserDetailComposer;
+
+public class HousekeepingFindUserByNameEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 500;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        String username = this.packet.readString();
+
+        if (username == null || username.isEmpty()) {
+            this.client.sendResponse(new HousekeepingUserDetailComposer(null));
+            return;
+        }
+
+        Habbo online = Emulator.getGameEnvironment().getHabboManager().getHabbo(username);
+        HabboInfo info = online != null ? online.getHabboInfo() : HabboManager.getOfflineHabboInfo(username);
+
+        this.client.sendResponse(new HousekeepingUserDetailComposer(info));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingForceDisconnectUserEvent.java

@@ -0,0 +1,54 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+/**
+ * Force-close the session of an online user. Unlike kick (which only
+ * removes them from the current room), this drops their socket. Equivalent
+ * to /disconnect in command form but issued through the HK panel.
+ */
+public class HousekeepingForceDisconnectUserEvent extends MessageHandler {
+    private static final String ACTION_KEY = "user.disconnect";
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int userId = this.packet.readInt();
+        String reason = this.packet.readString();
+
+        if (userId <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        Habbo target = Emulator.getGameEnvironment().getHabboManager().getHabbo(userId);
+
+        if (target == null) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.user_offline"));
+            return;
+        }
+
+        if (reason != null && !reason.isEmpty()) {
+            target.alert(reason);
+        }
+
+        // ACK first so the action result lands before the target's socket
+        // closes (otherwise an alerted user on the same emulator thread may
+        // already be torn down when we try to write).
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, userId, ""));
+
+        target.disconnect();
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingGetDashboardEvent.java

@@ -0,0 +1,91 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingDashboardComposer;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class HousekeepingGetDashboardEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 2000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int onlineUsers = Emulator.getGameEnvironment().getHabboManager().getOnlineHabbos().size();
+        int activeRooms = 0;
+        int totalUsers = 0;
+        int totalRooms = 0;
+        int pendingTickets = 0;
+        int sanctionsLast24h = 0;
+        int now = Emulator.getIntUnixTimestamp();
+
+        // activeRooms = loaded rooms with at least one user
+        try {
+            for (var room : Emulator.getGameEnvironment().getRoomManager().getActiveRooms()) {
+                if (room != null && room.getUserCount() > 0) activeRooms++;
+            }
+        } catch (Exception ignored) {
+            // fall through with 0
+        }
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection()) {
+            try (PreparedStatement statement = connection.prepareStatement("SELECT COUNT(*) FROM users");
+                 ResultSet rs = statement.executeQuery()) {
+                if (rs.next()) totalUsers = rs.getInt(1);
+            }
+
+            try (PreparedStatement statement = connection.prepareStatement("SELECT COUNT(*) FROM rooms");
+                 ResultSet rs = statement.executeQuery()) {
+                if (rs.next()) totalRooms = rs.getInt(1);
+            }
+
+            try (PreparedStatement statement = connection.prepareStatement("SELECT COUNT(*) FROM support_tickets WHERE state = 0");
+                 ResultSet rs = statement.executeQuery()) {
+                if (rs.next()) pendingTickets = rs.getInt(1);
+            }
+
+            try (PreparedStatement statement = connection.prepareStatement("SELECT COUNT(*) FROM bans WHERE timestamp > ?")) {
+                statement.setInt(1, now - (24 * 3600));
+                try (ResultSet rs = statement.executeQuery()) {
+                    if (rs.next()) sanctionsLast24h = rs.getInt(1);
+                }
+            }
+        } catch (SQLException ignored) {
+            // Surface 0s rather than failing the whole dashboard on a missing
+            // optional table — the HK panel can render partial data.
+        }
+
+        int uptime = (int) ((System.currentTimeMillis() - HOUSEKEEPING_BOOT_MILLIS) / 1000);
+        String version = "Arcturus-Morningstar-Extended";
+
+        this.client.sendResponse(new HousekeepingDashboardComposer(
+                onlineUsers,
+                totalUsers,
+                activeRooms,
+                totalRooms,
+                onlineUsers, // peakOnlineToday — not tracked, use current as best-effort
+                onlineUsers, // peakOnlineAllTime — same
+                pendingTickets,
+                sanctionsLast24h,
+                Math.max(uptime, 0),
+                version
+        ));
+    }
+
+    // Approximate uptime — captured at class-load time rather than emu startup
+    // (Emulator.java doesn't expose a public startup timestamp). For HK panel
+    // headline metrics this is close enough; if tighter accuracy is needed
+    // later, plumb Emulator.startup through and read it here.
+    private static final long HOUSEKEEPING_BOOT_MILLIS = System.currentTimeMillis();
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingGiveCreditsEvent.java

@@ -0,0 +1,62 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+public class HousekeepingGiveCreditsEvent extends MessageHandler {
+    private static final String ACTION_KEY = "user.give_credits";
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int userId = this.packet.readInt();
+        int amount = this.packet.readInt();
+
+        if (userId <= 0 || amount == 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        Habbo online = Emulator.getGameEnvironment().getHabboManager().getHabbo(userId);
+
+        if (online != null) {
+            // giveCredits already pushes UserCreditsComposer and persists via the
+            // standard HabboInfo write path; nothing extra needed for the online branch.
+            online.giveCredits(amount);
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, userId, ""));
+            return;
+        }
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("UPDATE users SET credits = credits + ? WHERE id = ? LIMIT 1")) {
+            statement.setInt(1, amount);
+            statement.setInt(2, userId);
+            int rows = statement.executeUpdate();
+
+            if (rows == 0) {
+                this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.user_not_found"));
+                return;
+            }
+        } catch (SQLException e) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.db_failed"));
+            return;
+        }
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, userId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingGiveCurrencyEvent.java

@@ -0,0 +1,74 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+/**
+ * Generic non-credits currency grant. Wire field `currencyType`:
+ * 0 => duckets / pixels, 5 => diamonds, 101 => seasonal-primary.
+ * Online users go through Habbo.givePoints / givePixels which dispatches
+ * a UserCurrencyComposer; offline goes straight to `users_currency`.
+ */
+public class HousekeepingGiveCurrencyEvent extends MessageHandler {
+    private static final int CURRENCY_DUCKETS = 0;
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int userId = this.packet.readInt();
+        int currencyType = this.packet.readInt();
+        int amount = this.packet.readInt();
+
+        String actionKey = "user.give_currency_" + currencyType;
+
+        if (userId <= 0 || amount == 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(actionKey, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        Habbo online = Emulator.getGameEnvironment().getHabboManager().getHabbo(userId);
+
+        if (online != null) {
+            // givePixels writes users_currency type=0 and ships UserCurrency;
+            // givePoints(type, amount) is the generalised path for everything else.
+            if (currencyType == CURRENCY_DUCKETS) {
+                online.givePixels(amount);
+            } else {
+                online.givePoints(currencyType, amount);
+            }
+
+            this.client.sendResponse(new HousekeepingActionResultComposer(actionKey, true, userId, ""));
+            return;
+        }
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement(
+                     "INSERT INTO users_currency (user_id, type, amount) VALUES (?, ?, ?) " +
+                     "ON DUPLICATE KEY UPDATE amount = amount + VALUES(amount)")) {
+            statement.setInt(1, userId);
+            statement.setInt(2, currencyType);
+            statement.setInt(3, amount);
+            statement.executeUpdate();
+        } catch (SQLException e) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(actionKey, false, 0, "housekeeping.error.db_failed"));
+            return;
+        }
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(actionKey, true, userId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingGrantItemEvent.java

@@ -0,0 +1,62 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+/**
+ * Grant a furni item (by items_base id) `quantity` times. Each row in
+ * the `items` table is one furni unit; quantity > 1 just batches the
+ * insert. The online user's HabboInventory isn't proactively refreshed
+ * — they'll see the new items next time they open the hand inventory
+ * (or after a relog).
+ */
+public class HousekeepingGrantItemEvent extends MessageHandler {
+    private static final String ACTION_KEY = "user.grant_item";
+    private static final int MAX_QUANTITY_PER_CALL = 100;
+
+    @Override
+    public int getRatelimit() {
+        return 2000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int userId = this.packet.readInt();
+        int itemId = this.packet.readInt();
+        int quantity = this.packet.readInt();
+
+        if (userId <= 0 || itemId <= 0 || quantity <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        if (quantity > MAX_QUANTITY_PER_CALL) {
+            quantity = MAX_QUANTITY_PER_CALL;
+        }
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("INSERT INTO items (user_id, item_id, extra_data) VALUES (?, ?, '')")) {
+            for (int i = 0; i < quantity; i++) {
+                statement.setInt(1, userId);
+                statement.setInt(2, itemId);
+                statement.addBatch();
+            }
+            statement.executeBatch();
+        } catch (SQLException e) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.economy_failed"));
+            return;
+        }
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, userId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingKickAllFromRoomEvent.java

@@ -0,0 +1,41 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.rooms.Room;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+public class HousekeepingKickAllFromRoomEvent extends MessageHandler {
+    private static final String ACTION_KEY = "room.kick_all";
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int roomId = this.packet.readInt();
+
+        if (roomId <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        Room room = Emulator.getGameEnvironment().getRoomManager().loadRoom(roomId, false);
+
+        if (room == null) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.room_not_found"));
+            return;
+        }
+
+        room.ejectAll();
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, roomId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingKickUserEvent.java

@@ -0,0 +1,60 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+/**
+ * Kick a user out of their current room. Mirrors ModToolManager.kick
+ * (leave room + alert), but the legacy method gates on ACC_SUPPORTTOOL,
+ * which would force HK operators to also hold the support-tool permission.
+ * Replicating the few lines locally keeps the HK module self-gated on
+ * ACC_HOUSEKEEPING.
+ */
+public class HousekeepingKickUserEvent extends MessageHandler {
+    private static final String ACTION_KEY = "user.kick";
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int userId = this.packet.readInt();
+        String reason = this.packet.readString();
+
+        if (userId <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        Habbo target = Emulator.getGameEnvironment().getHabboManager().getHabbo(userId);
+
+        if (target == null) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.user_offline"));
+            return;
+        }
+
+        if (target.hasPermission(Permission.ACC_UNKICKABLE)) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.target_unkickable"));
+            return;
+        }
+
+        if (target.getHabboInfo().getCurrentRoom() != null) {
+            Emulator.getGameEnvironment().getRoomManager().leaveRoom(target, target.getHabboInfo().getCurrentRoom());
+        }
+
+        if (reason != null && !reason.isEmpty()) {
+            target.alert(reason);
+        }
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, userId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingListActionLogEvent.java

@@ -0,0 +1,85 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionLogComposer;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Read the housekeeping_log audit table. The table isn't part of the
+ * base FullDatabase.sql yet — operators who want audit have to create
+ * it once:
+ *
+ *   CREATE TABLE IF NOT EXISTS `housekeeping_log` (
+ *     `id` INT NOT NULL AUTO_INCREMENT,
+ *     `timestamp` INT NOT NULL,
+ *     `actor_id` INT NOT NULL,
+ *     `actor_name` VARCHAR(64) NOT NULL DEFAULT '',
+ *     `target_type` VARCHAR(16) NOT NULL DEFAULT 'user',
+ *     `target_id` INT NOT NULL DEFAULT 0,
+ *     `target_label` VARCHAR(128) NOT NULL DEFAULT '',
+ *     `action` VARCHAR(64) NOT NULL DEFAULT '',
+ *     `detail` VARCHAR(500) NOT NULL DEFAULT '',
+ *     `success` TINYINT NOT NULL DEFAULT 1,
+ *     PRIMARY KEY (`id`), KEY `timestamp` (`timestamp`)
+ *   ) ENGINE=InnoDB;
+ *
+ * If the table is missing we swallow the SQL error and return an empty
+ * list — the panel just shows "no audit entries" instead of breaking.
+ * Writing into the table is a follow-up: each HK handler will append
+ * a row once the table exists; for now the listing is read-only.
+ */
+public class HousekeepingListActionLogEvent extends MessageHandler {
+    private static final int HARD_LIMIT = 500;
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int limit = Math.min(Math.max(this.packet.readInt(), 1), HARD_LIMIT);
+
+        List<HousekeepingActionLogComposer.Row> rows = new ArrayList<>();
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement(
+                     "SELECT id, timestamp, actor_id, actor_name, target_type, target_id, target_label, action, detail, success " +
+                     "FROM housekeeping_log ORDER BY id DESC LIMIT ?")) {
+            statement.setInt(1, limit);
+
+            try (ResultSet rs = statement.executeQuery()) {
+                while (rs.next()) {
+                    rows.add(new HousekeepingActionLogComposer.Row(
+                            rs.getInt("id"),
+                            rs.getInt("timestamp"),
+                            rs.getInt("actor_id"),
+                            rs.getString("actor_name"),
+                            rs.getString("target_type"),
+                            rs.getInt("target_id"),
+                            rs.getString("target_label"),
+                            rs.getString("action"),
+                            rs.getString("detail"),
+                            rs.getInt("success") == 1
+                    ));
+                }
+            }
+        } catch (SQLException ignored) {
+            // table absent — return empty list, log via emu logger left to the panel UI
+        }
+
+        this.client.sendResponse(new HousekeepingActionLogComposer(rows));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingMuteRoomEvent.java

@@ -0,0 +1,50 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.rooms.Room;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+/**
+ * Toggle room-wide mute. Habbo's Room.setMuted is boolean, not duration-
+ * scoped, so the wire `minutes` arg picks the semantic: minutes==0 =>
+ * unmute, minutes>0 => mute. An emulator-side scheduled unmute could
+ * use the value as a timer, but for now the mute stays until the
+ * operator unmutes manually — the minutes is reserved as a forward-
+ * compat field on the wire.
+ */
+public class HousekeepingMuteRoomEvent extends MessageHandler {
+    private static final String ACTION_KEY = "room.mute";
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int roomId = this.packet.readInt();
+        int minutes = this.packet.readInt();
+
+        if (roomId <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        Room room = Emulator.getGameEnvironment().getRoomManager().loadRoom(roomId, false);
+
+        if (room == null) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.room_not_found"));
+            return;
+        }
+
+        room.setMuted(minutes > 0);
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, roomId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingMuteUserEvent.java

@@ -0,0 +1,55 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+/**
+ * Apply an arbitrary-duration in-room mute. Habbo.mute is a session-only
+ * mute (it stores remaining seconds on the live Habbo object), so the
+ * target must be online for the action to take effect — when the target
+ * isn't online the handler returns ok=false with `user_offline` so the
+ * UI can fall back to ModToolSanctionMute or surface a clear error.
+ */
+public class HousekeepingMuteUserEvent extends MessageHandler {
+    private static final String ACTION_KEY = "user.mute";
+    private static final int SECONDS_IN_MINUTE = 60;
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int userId = this.packet.readInt();
+        String reason = this.packet.readString();
+        int minutes = this.packet.readInt();
+
+        if (userId <= 0 || minutes <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        Habbo target = Emulator.getGameEnvironment().getHabboManager().getHabbo(userId);
+
+        if (target == null) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.user_offline"));
+            return;
+        }
+
+        target.mute(minutes * SECONDS_IN_MINUTE, false);
+
+        if (reason != null && !reason.isEmpty()) {
+            target.alert(reason);
+        }
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, userId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingResetUserPasswordEvent.java

@@ -0,0 +1,89 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+import org.mindrot.jbcrypt.BCrypt;
+
+import java.security.SecureRandom;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+/**
+ * Reset a user's password to a fresh random 12-character alphanumeric
+ * string. Persists a BCrypt `$2a$` hash of the new password into
+ * `users.password` (matches what `AuthHttpUtil.checkPassword` /
+ * `SessionEndpoints` / `AccountChangeEndpoints` already write and read),
+ * clears `auth_ticket` so any active session can't be re-used to bypass
+ * the reset, and ships the PLAINTEXT new password back to the operator
+ * in the action-result `message` so they can communicate it out-of-band.
+ */
+public class HousekeepingResetUserPasswordEvent extends MessageHandler {
+    private static final String ACTION_KEY = "user.reset_password";
+    private static final String PASSWORD_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz23456789";
+    private static final int PASSWORD_LENGTH = 12;
+    private static final int BCRYPT_COST = 10;
+
+    private static final SecureRandom RNG = new SecureRandom();
+
+    @Override
+    public int getRatelimit() {
+        return 2000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int userId = this.packet.readInt();
+
+        if (userId <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        String plain = randomPassword();
+        String hash;
+
+        try {
+            hash = BCrypt.hashpw(plain, BCrypt.gensalt(BCRYPT_COST));
+        } catch (IllegalArgumentException e) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.hash_failed"));
+            return;
+        }
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("UPDATE users SET password = ?, auth_ticket = '' WHERE id = ? LIMIT 1")) {
+            statement.setString(1, hash);
+            statement.setInt(2, userId);
+            int rows = statement.executeUpdate();
+
+            if (rows == 0) {
+                this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.user_not_found"));
+                return;
+            }
+        } catch (SQLException e) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.db_failed"));
+            return;
+        }
+
+        // Plaintext flows through `message` — the client surfaces it via the
+        // status banner so the operator can read it once. SSL is on the
+        // operator: the only secure transport for the WS is wss://.
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, userId, plain));
+    }
+
+    private static String randomPassword() {
+        StringBuilder sb = new StringBuilder(PASSWORD_LENGTH);
+
+        for (int i = 0; i < PASSWORD_LENGTH; i++) {
+            sb.append(PASSWORD_ALPHABET.charAt(RNG.nextInt(PASSWORD_ALPHABET.length())));
+        }
+
+        return sb.toString();
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingRoomStateEvent.java

@@ -0,0 +1,49 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.rooms.Room;
+import com.eu.habbo.habbohotel.rooms.RoomState;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+/**
+ * Toggle the room state between OPEN (open) and LOCKED (closed). The
+ * client picks which transition it wants via the boolean — true => OPEN,
+ * false => LOCKED. Persists state through `Room.save()` so the change
+ * outlives an unload.
+ */
+public class HousekeepingRoomStateEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int roomId = this.packet.readInt();
+        boolean open = this.packet.readBoolean();
+        String actionKey = open ? "room.open" : "room.close";
+
+        if (roomId <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(actionKey, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        Room room = Emulator.getGameEnvironment().getRoomManager().loadRoom(roomId, false);
+
+        if (room == null) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(actionKey, false, 0, "housekeeping.error.room_not_found"));
+            return;
+        }
+
+        room.setState(open ? RoomState.OPEN : RoomState.LOCKED);
+        room.save();
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(actionKey, true, roomId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingSearchRoomsEvent.java

@@ -0,0 +1,75 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.rooms.Room;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingRoomListComposer;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Search rooms by name. `exactMatch=true` => `name = ?` (used by the
+ * findByName autocomplete that wants a unique hit). `exactMatch=false`
+ * => `name LIKE concat(?, '%')` (used by the prefix dropdown).
+ *
+ * Both branches go through the same packet because the wire shape is
+ * identical — the client picks which mode it wants by toggling the
+ * boolean.
+ */
+public class HousekeepingSearchRoomsEvent extends MessageHandler {
+    private static final int HARD_LIMIT = 50;
+
+    @Override
+    public int getRatelimit() {
+        return 500;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        String query = this.packet.readString();
+        boolean exactMatch = this.packet.readBoolean();
+        int limit = Math.min(Math.max(this.packet.readInt(), 1), HARD_LIMIT);
+
+        if (query == null) query = "";
+        query = query.trim();
+
+        if (query.isEmpty()) {
+            this.client.sendResponse(new HousekeepingRoomListComposer(new ArrayList<>()));
+            return;
+        }
+
+        String sql = exactMatch
+                ? "SELECT id FROM rooms WHERE name = ? LIMIT ?"
+                : "SELECT id FROM rooms WHERE name LIKE ? LIMIT ?";
+
+        List<Room> rooms = new ArrayList<>();
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement(sql)) {
+            statement.setString(1, exactMatch ? query : query + "%");
+            statement.setInt(2, limit);
+
+            try (ResultSet set = statement.executeQuery()) {
+                while (set.next()) {
+                    Room room = Emulator.getGameEnvironment().getRoomManager().loadRoom(set.getInt("id"), false);
+
+                    if (room != null) rooms.add(room);
+                }
+            }
+        } catch (SQLException ignored) {
+            // fall through with whatever we collected before the failure
+        }
+
+        this.client.sendResponse(new HousekeepingRoomListComposer(rooms));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingSendHotelAlertEvent.java

@@ -0,0 +1,58 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.generic.alerts.StaffAlertWithLinkComposer;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+import java.util.Map;
+
+/**
+ * Mirrors :ha — staff alert with sender attribution, broadcast to
+ * every online user whose `blockStaffAlerts` flag isn't set. Composed
+ * once and forwarded by reference (sendResponse compiles to the same
+ * underlying buffer) so the broadcast is O(N habbos) wire writes,
+ * not O(N) compose calls.
+ */
+public class HousekeepingSendHotelAlertEvent extends MessageHandler {
+    private static final String ACTION_KEY = "hotel.alert";
+
+    @Override
+    public int getRatelimit() {
+        return 2000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        String message = this.packet.readString();
+
+        if (message == null || message.trim().isEmpty()) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.alert_empty"));
+            return;
+        }
+
+        String body = message + "\r\n-" + this.client.getHabbo().getHabboInfo().getUsername();
+        ServerMessage broadcast = new StaffAlertWithLinkComposer(body, "").compose();
+
+        int reached = 0;
+
+        for (Map.Entry<Integer, Habbo> entry : Emulator.getGameEnvironment().getHabboManager().getOnlineHabbos().entrySet()) {
+            Habbo habbo = entry.getValue();
+
+            if (habbo == null || habbo.getClient() == null) continue;
+            if (habbo.getHabboStats() != null && habbo.getHabboStats().blockStaffAlerts) continue;
+
+            habbo.getClient().sendResponse(broadcast);
+            reached++;
+        }
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, reached, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingSetHcSubscriptionEvent.java

@@ -0,0 +1,76 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+/**
+ * Extend a user's HC by `days`. Adds to the existing club_expire_timestamp
+ * if it's still in the future, otherwise stretches from `now`. Days==0
+ * means cancel the active subscription (timestamp clamped to `now`).
+ */
+public class HousekeepingSetHcSubscriptionEvent extends MessageHandler {
+    private static final String ACTION_KEY = "user.set_hc";
+    private static final int SECONDS_IN_DAY = 24 * 3600;
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int userId = this.packet.readInt();
+        int days = this.packet.readInt();
+
+        if (userId <= 0 || days < 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        int now = Emulator.getIntUnixTimestamp();
+        int newExpire;
+
+        Habbo online = Emulator.getGameEnvironment().getHabboManager().getHabbo(userId);
+
+        if (days == 0) {
+            newExpire = now;
+        } else if (online != null) {
+            int current = online.getHabboStats().getClubExpireTimestamp();
+            newExpire = (current > now ? current : now) + (days * SECONDS_IN_DAY);
+        } else {
+            newExpire = now + (days * SECONDS_IN_DAY); // best-effort offline; can't read previous expiry cheaply
+        }
+
+        if (online != null) {
+            online.getHabboStats().setClubExpireTimestamp(newExpire);
+        }
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("UPDATE users_settings SET club_expire_timestamp = ? WHERE user_id = ? LIMIT 1")) {
+            statement.setInt(1, newExpire);
+            statement.setInt(2, userId);
+            int rows = statement.executeUpdate();
+
+            if (rows == 0) {
+                this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.user_not_found"));
+                return;
+            }
+        } catch (SQLException e) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.db_failed"));
+            return;
+        }
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, userId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingSetUserRankEvent.java

@@ -0,0 +1,71 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.permissions.PermissionsManager;
+import com.eu.habbo.habbohotel.permissions.Rank;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+import com.eu.habbo.messages.outgoing.users.UserPermissionsComposer;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+public class HousekeepingSetUserRankEvent extends MessageHandler {
+    private static final String ACTION_KEY = "user.set_rank";
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int userId = this.packet.readInt();
+        int rankId = this.packet.readInt();
+
+        if (userId <= 0 || rankId <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        PermissionsManager permissions = Emulator.getGameEnvironment().getPermissionsManager();
+
+        if (!permissions.rankExists(rankId)) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.rank_not_found"));
+            return;
+        }
+
+        Rank rank = permissions.getRank(rankId);
+
+        // Persist for the offline path. Online users get their in-memory
+        // HabboInfo.rank rebound below so server-side hasPermission()
+        // checks land on the new permission set without a relogin.
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("UPDATE users SET rank = ? WHERE id = ? LIMIT 1")) {
+            statement.setInt(1, rankId);
+            statement.setInt(2, userId);
+            statement.execute();
+        } catch (SQLException e) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.db_failed"));
+            return;
+        }
+
+        Habbo online = Emulator.getGameEnvironment().getHabboManager().getHabbo(userId);
+
+        if (online != null) {
+            online.getHabboInfo().setRank(rank);
+            // Ship the refreshed permissions snapshot — same payload the
+            // :update_permissions command emits when a rank is rebound.
+            online.getClient().sendResponse(new UserPermissionsComposer(online));
+        }
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, userId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingTradeLockUserEvent.java

@@ -0,0 +1,77 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+/**
+ * Apply an arbitrary-duration trade lock. Writes
+ * `users_settings.trade_locked_until = now + hours*3600` so the lock
+ * survives logout/login — that column is the canonical timestamp the
+ * mod-tool user-info composer queries on. Online users also get their
+ * in-memory HabboStats.allowTrade flag cleared so the lock takes
+ * effect on the active session without waiting for a relog.
+ */
+public class HousekeepingTradeLockUserEvent extends MessageHandler {
+    private static final String ACTION_KEY = "user.trade_lock";
+    private static final int SECONDS_IN_HOUR = 3600;
+    private static final int MAX_DURATION_SECONDS = 100 * 365 * 24 * 3600;
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int userId = this.packet.readInt();
+        int hours = this.packet.readInt();
+        String reason = this.packet.readString();
+
+        if (userId <= 0 || hours <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        long durationLong = (long) hours * SECONDS_IN_HOUR;
+        int duration = durationLong > MAX_DURATION_SECONDS ? MAX_DURATION_SECONDS : (int) durationLong;
+        int lockedUntil = Emulator.getIntUnixTimestamp() + duration;
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("UPDATE users_settings SET trade_locked_until = ? WHERE user_id = ? LIMIT 1")) {
+            statement.setInt(1, lockedUntil);
+            statement.setInt(2, userId);
+            int rows = statement.executeUpdate();
+
+            if (rows == 0) {
+                this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.user_not_found"));
+                return;
+            }
+        } catch (SQLException e) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.db_failed"));
+            return;
+        }
+
+        Habbo online = Emulator.getGameEnvironment().getHabboManager().getHabbo(userId);
+
+        if (online != null) {
+            online.getHabboStats().setAllowTrade(false);
+
+            if (reason != null && !reason.isEmpty()) {
+                online.alert(reason);
+            }
+        }
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, userId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingTransferRoomOwnershipEvent.java

@@ -0,0 +1,67 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.users.HabboInfo;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+/**
+ * Transfer ownership of a room to a different user. Updates both
+ * `rooms.owner_id` and `rooms.owner_name` so the cached owner name on
+ * the navigator stays in sync without forcing a relog. The room is
+ * touched via direct SQL rather than via Room.setOwnerId() because
+ * the room may not be loaded.
+ */
+public class HousekeepingTransferRoomOwnershipEvent extends MessageHandler {
+    private static final String ACTION_KEY = "room.transfer";
+
+    @Override
+    public int getRatelimit() {
+        return 2000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int roomId = this.packet.readInt();
+        int newOwnerId = this.packet.readInt();
+
+        if (roomId <= 0 || newOwnerId <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        HabboInfo newOwner = Emulator.getGameEnvironment().getHabboManager().getHabboInfo(newOwnerId);
+
+        if (newOwner == null) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.new_owner_not_found"));
+            return;
+        }
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("UPDATE rooms SET owner_id = ?, owner_name = ? WHERE id = ? LIMIT 1")) {
+            statement.setInt(1, newOwnerId);
+            statement.setString(2, newOwner.getUsername());
+            statement.setInt(3, roomId);
+            int rows = statement.executeUpdate();
+
+            if (rows == 0) {
+                this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.room_not_found"));
+                return;
+            }
+        } catch (SQLException e) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.db_failed"));
+            return;
+        }
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, true, roomId, ""));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/housekeeping/HousekeepingUnbanUserEvent.java

@@ -0,0 +1,44 @@
+package com.eu.habbo.messages.incoming.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.users.HabboInfo;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.housekeeping.HousekeepingActionResultComposer;
+
+public class HousekeepingUnbanUserEvent extends MessageHandler {
+    private static final String ACTION_KEY = "user.unban";
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (!this.client.getHabbo().hasPermission(Permission.ACC_HOUSEKEEPING)) {
+            return;
+        }
+
+        int userId = this.packet.readInt();
+
+        if (userId <= 0) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.invalid_input"));
+            return;
+        }
+
+        HabboInfo info = Emulator.getGameEnvironment().getHabboManager().getHabboInfo(userId);
+
+        if (info == null) {
+            this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, false, 0, "housekeeping.error.user_not_found"));
+            return;
+        }
+
+        // ModToolManager.unban only takes a username; the SQL UPDATE
+        // happens against active bans (ban_expire > now), so calling it
+        // on a never-banned user is a benign no-op that returns false.
+        boolean cleared = Emulator.getGameEnvironment().getModToolManager().unban(info.getUsername());
+
+        this.client.sendResponse(new HousekeepingActionResultComposer(ACTION_KEY, cleared, cleared ? userId : 0, cleared ? "" : "housekeeping.error.no_active_ban"));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/rarevalues/RequestRareValuesEvent.java

@@ -0,0 +1,21 @@
+package com.eu.habbo.messages.incoming.rarevalues;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.rarevalues.RareValuesComposer;
+
+// Client requests the furni value map once on load. Public info (catalog prices),
+// no permission gate. Rate limited since the payload is large.
+public class RequestRareValuesEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 5000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        this.client.sendResponse(new RareValuesComposer(
+                Emulator.getGameEnvironment().getCatalogManager().getFurnitureValues()
+        ));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/rooms/bots/BotSaveSettingsEvent.java

@@ -5,11 +5,13 @@ import com.eu.habbo.habbohotel.bots.Bot;
 import com.eu.habbo.habbohotel.bots.BotManager;
 import com.eu.habbo.habbohotel.permissions.Permission;
 import com.eu.habbo.habbohotel.rooms.Room;
+import com.eu.habbo.habbohotel.rooms.RoomUserRotation;
 import com.eu.habbo.habbohotel.users.DanceType;
 import com.eu.habbo.messages.incoming.MessageHandler;
 import com.eu.habbo.messages.outgoing.generic.alerts.BotErrorComposer;
 import com.eu.habbo.messages.outgoing.rooms.users.RoomUserDanceComposer;
 import com.eu.habbo.messages.outgoing.rooms.users.RoomUserNameChangedComposer;
+import com.eu.habbo.messages.outgoing.rooms.users.RoomUserStatusComposer;
 import com.eu.habbo.messages.outgoing.rooms.users.RoomUsersComposer;
 import com.eu.habbo.plugin.events.bots.BotSavedChatEvent;
 import com.eu.habbo.plugin.events.bots.BotSavedLookEvent;
@@ -28,13 +30,20 @@ public class BotSaveSettingsEvent extends MessageHandler {
 
         if (room.getOwnerId() == this.client.getHabbo().getHabboInfo().getId() || this.client.getHabbo().hasPermission(Permission.ACC_ANYROOMOWNER)) {
             int botId = this.packet.readInt();
-
             Bot bot = room.getBot(Math.abs(botId));
-
             if (bot == null)
                 return;
-
             int settingId = this.packet.readInt();
+            boolean allowed = false;
+            for (short a : bot.getOwnerActionIds()) {
+                if (a == settingId) {
+                    allowed = true;
+                    break;
+                }
+            }
+            if (!allowed) return;
+
+            if (!bot.tryAcquireOwnerActionSlot()) return;
 
             switch (settingId) {
                 case 1:
@@ -160,8 +169,18 @@ public class BotSaveSettingsEvent extends MessageHandler {
                     bot.needsUpdate(true);
                     room.sendComposer(new RoomUsersComposer(bot).compose());
                     break;
+                case Bot.ACTION_ROTATE:
+                    if (bot.getRoomUnit() == null) break;
+                    int next = (bot.getRoomUnit().getBodyRotation().getValue() + 2) % 8;
+                    RoomUserRotation rotation = RoomUserRotation.fromValue(next);
+                    bot.getRoomUnit().setRotation(rotation);
+                    bot.needsUpdate(true);
+                    room.sendComposer(new RoomUserStatusComposer(bot.getRoomUnit()).compose());
+                    break;
             }
 
+            bot.onPostOwnerAction(settingId);
+
             if (bot.needsUpdate()) {
                 Emulator.getThreading().run(bot);
             }

Emulator/src/main/java/com/eu/habbo/messages/incoming/soundboard/SoundboardPlayEvent.java

@@ -0,0 +1,31 @@
+package com.eu.habbo.messages.incoming.soundboard;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.rooms.Room;
+import com.eu.habbo.habbohotel.soundboard.SoundboardSound;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.soundboard.SoundboardPlayComposer;
+
+public class SoundboardPlayEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 250;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        Habbo habbo = this.client.getHabbo();
+        if (habbo == null) return;
+
+        Room room = this.currentRoom();
+        if (room == null || !room.isSoundboardEnabled()) return;
+
+        int soundId = this.packet.readInt();
+        SoundboardSound sound = Emulator.getGameEnvironment().getSoundboardManager().getSound(soundId);
+        if (sound == null) return;
+
+        // Broadcast to everyone in the room.
+        room.sendComposer(new SoundboardPlayComposer(sound.id, sound.url, habbo.getHabboInfo().getUsername()).compose());
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/soundboard/SoundboardSetEnabledEvent.java

@@ -0,0 +1,37 @@
+package com.eu.habbo.messages.incoming.soundboard;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.permissions.Permission;
+import com.eu.habbo.habbohotel.rooms.Room;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.soundboard.SoundboardSettingsComposer;
+
+public class SoundboardSetEnabledEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        Habbo habbo = this.client.getHabbo();
+        if (habbo == null) return;
+
+        Room room = this.currentRoom();
+        if (room == null) return;
+
+        // Only the room owner (or staff) may toggle the soundboard for the room.
+        boolean isOwner = room.getOwnerId() == habbo.getHabboInfo().getId();
+        if (!isOwner && !habbo.hasPermission(Permission.ACC_SUPPORTTOOL)) return;
+
+        boolean enabled = this.packet.readInt() == 1;
+
+        room.setSoundboardEnabled(enabled);
+        Emulator.getGameEnvironment().getSoundboardManager().setRoomEnabled(room.getId(), enabled);
+
+        // Push the refreshed settings (flag + sound list) to everyone in the room
+        // so the toolbar icon appears/disappears live.
+        room.sendComposer(new SoundboardSettingsComposer(enabled, Emulator.getGameEnvironment().getSoundboardManager().getSounds()).compose());
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/wheel/WheelAdminGetPrizesEvent.java

@@ -0,0 +1,24 @@
+package com.eu.habbo.messages.incoming.wheel;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.wheel.WheelAdminPrizesComposer;
+
+public class WheelAdminGetPrizesEvent extends MessageHandler {
+    public static final String PERMISSION_KEY = "acc_wheeladmin";
+
+    @Override
+    public int getRatelimit() {
+        return 500;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (this.client.getHabbo() == null || !this.client.getHabbo().hasPermission(PERMISSION_KEY)) {
+            return;
+        }
+
+        this.client.sendResponse(new WheelAdminPrizesComposer(
+                Emulator.getGameEnvironment().getWheelManager().getPrizes()));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/wheel/WheelAdminSavePrizesEvent.java

@@ -0,0 +1,46 @@
+package com.eu.habbo.messages.incoming.wheel;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.wheel.WheelManager;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.wheel.WheelAdminPrizesComposer;
+import com.eu.habbo.messages.outgoing.wheel.WheelDataComposer;
+
+public class WheelAdminSavePrizesEvent extends MessageHandler {
+    public static final String PERMISSION_KEY = "acc_wheeladmin";
+
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (this.client.getHabbo() == null || !this.client.getHabbo().hasPermission(PERMISSION_KEY)) {
+            return;
+        }
+
+        WheelManager wheel = Emulator.getGameEnvironment().getWheelManager();
+
+        int count = this.packet.readInt();
+        if (count <= 0 || count > WheelManager.MAX_PRIZES_PER_SAVE) return;
+
+        for (int i = 0; i < count; i++) {
+            int id = this.packet.readInt();
+            String type = this.packet.readString();
+            String value = this.packet.readString();
+            int amount = this.packet.readInt();
+            int pointsType = this.packet.readInt();
+            int weight = this.packet.readInt();
+            String label = this.packet.readString();
+            wheel.savePrize(id, type, value, amount, pointsType, weight, label);
+        }
+
+        wheel.reload();
+
+        this.client.sendResponse(new WheelAdminPrizesComposer(wheel.getPrizes()));
+        this.client.sendResponse(new WheelDataComposer(
+                wheel.getUserState(this.client.getHabbo().getHabboInfo().getId()),
+                wheel.getSpinCost(), wheel.getSpinCostType(), wheel.getPrizes()));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/wheel/WheelBuySpinEvent.java

@@ -0,0 +1,27 @@
+package com.eu.habbo.messages.incoming.wheel;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.habbohotel.wheel.WheelManager;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.wheel.WheelDataComposer;
+
+public class WheelBuySpinEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        Habbo habbo = this.client.getHabbo();
+        if (habbo == null) return;
+
+        WheelManager wheel = Emulator.getGameEnvironment().getWheelManager();
+        wheel.buySpin(habbo); // whether or not it succeeds, resend the balance
+
+        this.client.sendResponse(new WheelDataComposer(
+                wheel.getUserState(habbo.getHabboInfo().getId()),
+                wheel.getSpinCost(), wheel.getSpinCostType(), wheel.getPrizes()));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/wheel/WheelOpenEvent.java

@@ -0,0 +1,27 @@
+package com.eu.habbo.messages.incoming.wheel;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.habbohotel.wheel.WheelManager;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.wheel.WheelDataComposer;
+import com.eu.habbo.messages.outgoing.wheel.WheelRecentWinsComposer;
+
+public class WheelOpenEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 500;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        Habbo habbo = this.client.getHabbo();
+        if (habbo == null) return;
+
+        WheelManager wheel = Emulator.getGameEnvironment().getWheelManager();
+        this.client.sendResponse(new WheelDataComposer(
+                wheel.getUserState(habbo.getHabboInfo().getId()),
+                wheel.getSpinCost(), wheel.getSpinCostType(), wheel.getPrizes()));
+        this.client.sendResponse(new WheelRecentWinsComposer(wheel.getRecentWins(50)));
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/wheel/WheelSpinEvent.java

@@ -0,0 +1,39 @@
+package com.eu.habbo.messages.incoming.wheel;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.habbohotel.wheel.WheelManager;
+import com.eu.habbo.habbohotel.wheel.WheelPrize;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.wheel.WheelDataComposer;
+import com.eu.habbo.messages.outgoing.wheel.WheelRecentWinsComposer;
+import com.eu.habbo.messages.outgoing.wheel.WheelResultComposer;
+
+public class WheelSpinEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 1500;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        Habbo habbo = this.client.getHabbo();
+        if (habbo == null) return;
+
+        WheelManager wheel = Emulator.getGameEnvironment().getWheelManager();
+        WheelPrize prize = wheel.spin(habbo);
+
+        if (prize != null) {
+            this.client.sendResponse(new WheelResultComposer(prize.id));
+        }
+
+        // Refresh the balance either way so the client unlocks the wheel.
+        this.client.sendResponse(new WheelDataComposer(
+                wheel.getUserState(habbo.getHabboInfo().getId()),
+                wheel.getSpinCost(), wheel.getSpinCostType(), wheel.getPrizes()));
+
+        if (prize != null) {
+            this.client.sendResponse(new WheelRecentWinsComposer(wheel.getRecentWins(50)));
+        }
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/Outgoing.java

@@ -586,4 +586,21 @@ public class Outgoing {
     public static final int YouTubeRoomWatchersComposer = 8002;
     public static final int YouTubeRoomSettingsComposer = 8003;
 
+    // Housekeeping (in-client admin panel) — IDs 9200..9299 reserved
+    public static final int HousekeepingUserDetailComposer = 9200;
+    public static final int HousekeepingActionResultComposer = 9201;
+    public static final int HousekeepingRoomDetailComposer = 9202;
+    public static final int HousekeepingRoomListComposer = 9203;
+    public static final int HousekeepingDashboardComposer = 9204;
+    public static final int HousekeepingActionLogComposer = 9205;
+
+    // Custom features — IDs 9400+ reserved
+    public static final int RareValuesComposer = 9400;
+    public static final int WheelDataComposer = 9401;
+    public static final int WheelResultComposer = 9402;
+    public static final int WheelRecentWinsComposer = 9403;
+    public static final int WheelAdminPrizesComposer = 9404;
+    public static final int SoundboardSettingsComposer = 9405;
+    public static final int SoundboardPlayComposer = 9406;
+
 }

Emulator/src/main/java/com/eu/habbo/messages/outgoing/housekeeping/HousekeepingActionLogComposer.java

@@ -0,0 +1,65 @@
+package com.eu.habbo.messages.outgoing.housekeeping;
+
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+import java.util.List;
+
+public class HousekeepingActionLogComposer extends MessageComposer {
+    public static class Row {
+        public final int id;
+        public final int timestamp;
+        public final int actorId;
+        public final String actorName;
+        public final String targetType;
+        public final int targetId;
+        public final String targetLabel;
+        public final String action;
+        public final String detail;
+        public final boolean success;
+
+        public Row(int id, int timestamp, int actorId, String actorName, String targetType, int targetId,
+                   String targetLabel, String action, String detail, boolean success) {
+            this.id = id;
+            this.timestamp = timestamp;
+            this.actorId = actorId;
+            this.actorName = actorName != null ? actorName : "";
+            this.targetType = targetType != null ? targetType : "user";
+            this.targetId = targetId;
+            this.targetLabel = targetLabel != null ? targetLabel : "";
+            this.action = action != null ? action : "";
+            this.detail = detail != null ? detail : "";
+            this.success = success;
+        }
+    }
+
+    private final List<Row> rows;
+
+    public HousekeepingActionLogComposer(List<Row> rows) {
+        this.rows = rows;
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.HousekeepingActionLogComposer);
+        this.response.appendInt(this.rows != null ? this.rows.size() : 0);
+
+        if (this.rows != null) {
+            for (Row r : this.rows) {
+                this.response.appendInt(r.id);
+                this.response.appendInt(r.timestamp);
+                this.response.appendInt(r.actorId);
+                this.response.appendString(r.actorName);
+                this.response.appendString(r.targetType);
+                this.response.appendInt(r.targetId);
+                this.response.appendString(r.targetLabel);
+                this.response.appendString(r.action);
+                this.response.appendString(r.detail);
+                this.response.appendBoolean(r.success);
+            }
+        }
+
+        return this.response;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/housekeeping/HousekeepingActionResultComposer.java

@@ -0,0 +1,36 @@
+package com.eu.habbo.messages.outgoing.housekeeping;
+
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+/**
+ * Generic ack for any housekeeping action (ban, mute, kick, give-credits,
+ * room-close, …). The client matches it back to the originating call via
+ * the `actionKey` field, which lets multiple in-flight actions share the
+ * same event stream without ordering bugs.
+ */
+public class HousekeepingActionResultComposer extends MessageComposer {
+    private final String actionKey;
+    private final boolean ok;
+    private final int actionId;
+    private final String message;
+
+    public HousekeepingActionResultComposer(String actionKey, boolean ok, int actionId, String message) {
+        this.actionKey = actionKey != null ? actionKey : "";
+        this.ok = ok;
+        this.actionId = actionId;
+        this.message = message != null ? message : "";
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.HousekeepingActionResultComposer);
+        this.response.appendString(this.actionKey);
+        this.response.appendBoolean(this.ok);
+        this.response.appendInt(this.actionId);
+        this.response.appendString(this.message);
+
+        return this.response;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/housekeeping/HousekeepingDashboardComposer.java

@@ -0,0 +1,50 @@
+package com.eu.habbo.messages.outgoing.housekeeping;
+
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+public class HousekeepingDashboardComposer extends MessageComposer {
+    private final int onlineUsers;
+    private final int totalUsers;
+    private final int activeRooms;
+    private final int totalRooms;
+    private final int peakOnlineToday;
+    private final int peakOnlineAllTime;
+    private final int pendingTickets;
+    private final int sanctionsLast24h;
+    private final int serverUptimeSeconds;
+    private final String serverVersion;
+
+    public HousekeepingDashboardComposer(int onlineUsers, int totalUsers, int activeRooms, int totalRooms,
+                                         int peakOnlineToday, int peakOnlineAllTime, int pendingTickets,
+                                         int sanctionsLast24h, int serverUptimeSeconds, String serverVersion) {
+        this.onlineUsers = onlineUsers;
+        this.totalUsers = totalUsers;
+        this.activeRooms = activeRooms;
+        this.totalRooms = totalRooms;
+        this.peakOnlineToday = peakOnlineToday;
+        this.peakOnlineAllTime = peakOnlineAllTime;
+        this.pendingTickets = pendingTickets;
+        this.sanctionsLast24h = sanctionsLast24h;
+        this.serverUptimeSeconds = serverUptimeSeconds;
+        this.serverVersion = serverVersion != null ? serverVersion : "";
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.HousekeepingDashboardComposer);
+        this.response.appendInt(this.onlineUsers);
+        this.response.appendInt(this.totalUsers);
+        this.response.appendInt(this.activeRooms);
+        this.response.appendInt(this.totalRooms);
+        this.response.appendInt(this.peakOnlineToday);
+        this.response.appendInt(this.peakOnlineAllTime);
+        this.response.appendInt(this.pendingTickets);
+        this.response.appendInt(this.sanctionsLast24h);
+        this.response.appendInt(this.serverUptimeSeconds);
+        this.response.appendString(this.serverVersion);
+
+        return this.response;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/housekeeping/HousekeepingRoomDetailComposer.java

@@ -0,0 +1,49 @@
+package com.eu.habbo.messages.outgoing.housekeeping;
+
+import com.eu.habbo.habbohotel.rooms.Room;
+import com.eu.habbo.habbohotel.rooms.RoomState;
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+public class HousekeepingRoomDetailComposer extends MessageComposer {
+    private final Room room;
+
+    public HousekeepingRoomDetailComposer(Room room) {
+        this.room = room;
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.HousekeepingRoomDetailComposer);
+
+        if (this.room == null) {
+            this.response.appendBoolean(false);
+            return this.response;
+        }
+
+        this.response.appendBoolean(true);
+        appendRoomFields(this.response, this.room);
+
+        return this.response;
+    }
+
+    /** Shared by HousekeepingRoomListComposer too. */
+    public static void appendRoomFields(ServerMessage response, Room room) {
+        response.appendInt(room.getId());
+        response.appendString(safe(room.getName()));
+        response.appendString(safe(room.getDescription()));
+        response.appendInt(room.getOwnerId());
+        response.appendString(safe(room.getOwnerName()));
+        response.appendInt(room.getUserCount());
+        response.appendInt(room.getUsersMax());
+        response.appendBoolean(room.getState() != null && room.getState() != RoomState.OPEN);
+        response.appendBoolean(room.isMuted());
+        response.appendBoolean(room.isPublicRoom());
+        response.appendInt(0); // createdAt — Room doesn't expose; left as 0 until a schema-side timestamp surfaces.
+    }
+
+    private static String safe(String value) {
+        return value != null ? value : "";
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/housekeeping/HousekeepingRoomListComposer.java

@@ -0,0 +1,30 @@
+package com.eu.habbo.messages.outgoing.housekeeping;
+
+import com.eu.habbo.habbohotel.rooms.Room;
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+import java.util.List;
+
+public class HousekeepingRoomListComposer extends MessageComposer {
+    private final List<Room> rooms;
+
+    public HousekeepingRoomListComposer(List<Room> rooms) {
+        this.rooms = rooms;
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.HousekeepingRoomListComposer);
+        this.response.appendInt(this.rooms != null ? this.rooms.size() : 0);
+
+        if (this.rooms != null) {
+            for (Room room : this.rooms) {
+                HousekeepingRoomDetailComposer.appendRoomFields(this.response, room);
+            }
+        }
+
+        return this.response;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/housekeeping/HousekeepingUserDetailComposer.java

@@ -0,0 +1,59 @@
+package com.eu.habbo.messages.outgoing.housekeeping;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.modtool.ModToolBan;
+import com.eu.habbo.habbohotel.permissions.Rank;
+import com.eu.habbo.habbohotel.users.HabboInfo;
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+public class HousekeepingUserDetailComposer extends MessageComposer {
+    private static final int CURRENCY_DUCKETS = 0;
+    private static final int CURRENCY_DIAMONDS = 5;
+
+    private final HabboInfo info;
+
+    public HousekeepingUserDetailComposer(HabboInfo info) {
+        this.info = info;
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.HousekeepingUserDetailComposer);
+
+        if (this.info == null) {
+            this.response.appendBoolean(false);
+            return this.response;
+        }
+
+        Rank rank = this.info.getRank();
+        ModToolBan ban = Emulator.getGameEnvironment().getModToolManager().checkForBan(this.info.getId());
+
+        this.response.appendBoolean(true);
+        this.response.appendInt(this.info.getId());
+        this.response.appendString(safe(this.info.getUsername()));
+        this.response.appendString(safe(this.info.getMotto()));
+        this.response.appendString(safe(this.info.getLook()));
+        this.response.appendInt(rank != null ? rank.getId() : 0);
+        this.response.appendString(rank != null ? safe(rank.getName()) : "");
+        this.response.appendBoolean(this.info.isOnline());
+        this.response.appendInt(this.info.getLastOnline());
+        this.response.appendInt(this.info.getCredits());
+        this.response.appendInt(this.info.getCurrencyAmount(CURRENCY_DUCKETS));
+        this.response.appendInt(this.info.getCurrencyAmount(CURRENCY_DIAMONDS));
+        this.response.appendString(safe(this.info.getMail()));
+        this.response.appendString(safe(this.info.getIpLogin()));
+        this.response.appendBoolean(ban != null);
+        // Mute / trade-lock surface as future packet extensions; see the
+        // optional-trailing-field parser pattern on the renderer side.
+        this.response.appendBoolean(false);
+        this.response.appendBoolean(false);
+
+        return this.response;
+    }
+
+    private static String safe(String value) {
+        return value != null ? value : "";
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/rarevalues/RareValuesComposer.java

@@ -0,0 +1,35 @@
+package com.eu.habbo.messages.outgoing.rarevalues;
+
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+import gnu.trove.iterator.TIntObjectIterator;
+import gnu.trove.map.TIntObjectMap;
+
+// Sends the full spriteId -> value map to the client. Consumed by the toolbar
+// price guide and the furni infostand "value" line. See CatalogManager#loadFurnitureValues.
+public class RareValuesComposer extends MessageComposer {
+    private final TIntObjectMap<int[]> values;
+
+    public RareValuesComposer(TIntObjectMap<int[]> values) {
+        this.values = values;
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.RareValuesComposer);
+        this.response.appendInt(this.values.size());
+
+        TIntObjectIterator<int[]> iterator = this.values.iterator();
+        while (iterator.hasNext()) {
+            iterator.advance();
+            int[] value = iterator.value();
+            this.response.appendInt(iterator.key()); // spriteId
+            this.response.appendInt(value[0]);        // credits
+            this.response.appendInt(value[1]);        // points
+            this.response.appendInt(value[2]);        // pointsType
+        }
+
+        return this.response;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/rooms/users/RoomUsersComposer.java

@@ -86,7 +86,7 @@ public class RoomUsersComposer extends MessageComposer {
                     this.response.appendInt(habbo.getHabboInfo().getId());
                     this.response.appendString(habbo.getHabboInfo().getUsername());
                     this.response.appendString(habbo.getHabboInfo().getMotto());
-					this.response.appendInt(habbo.getHabboInfo().getInfostandBg());
+                    this.response.appendInt(habbo.getHabboInfo().getInfostandBg());
                     this.response.appendInt(habbo.getHabboInfo().getInfostandStand());
                     this.response.appendInt(habbo.getHabboInfo().getInfostandOverlay());
                     this.response.appendInt(habbo.getHabboInfo().getInfostandCardBg());
@@ -129,7 +129,7 @@ public class RoomUsersComposer extends MessageComposer {
             this.response.appendInt(0 - this.bot.getId());
             this.response.appendString(this.bot.getName());
             this.response.appendString(this.bot.getMotto());
-			this.response.appendInt(0);
+            this.response.appendInt(0);
             this.response.appendInt(0);
             this.response.appendInt(0);
             this.response.appendInt(0);
@@ -143,17 +143,11 @@ public class RoomUsersComposer extends MessageComposer {
             this.response.appendString(this.bot.getGender().name().toUpperCase());
             this.response.appendInt(this.bot.getOwnerId());
             this.response.appendString(this.bot.getOwnerName());
-            this.response.appendInt(10);
-            this.response.appendShort(0);
-            this.response.appendShort(1);
-            this.response.appendShort(2);
-            this.response.appendShort(3);
-            this.response.appendShort(4);
-            this.response.appendShort(5);
-            this.response.appendShort(6);
-            this.response.appendShort(7);
-            this.response.appendShort(8);
-            this.response.appendShort(9);
+            short[] singleActions = this.bot.getOwnerActionIds();
+            this.response.appendInt(singleActions.length);
+            for (short action : singleActions) {
+                this.response.appendShort(action);
+            }
             this.response.appendString("unknown");
             this.response.appendInt(0);
             this.response.appendInt(0);
@@ -163,10 +157,10 @@ public class RoomUsersComposer extends MessageComposer {
                 this.response.appendInt(0 - bot.getId());
                 this.response.appendString(bot.getName());
                 this.response.appendString(bot.getMotto());
-				this.response.appendInt(0);
-				this.response.appendInt(0);
-				this.response.appendInt(0);
-				this.response.appendInt(0);
+                this.response.appendInt(0);
+                this.response.appendInt(0);
+                this.response.appendInt(0);
+                this.response.appendInt(0);
                 this.response.appendString(bot.getFigure());
                 this.response.appendInt(bot.getRoomUnit().getId());
                 this.response.appendInt(bot.getRoomUnit().getX());
@@ -177,17 +171,11 @@ public class RoomUsersComposer extends MessageComposer {
                 this.response.appendString(bot.getGender().name().toUpperCase());
                 this.response.appendInt(bot.getOwnerId());
                 this.response.appendString(bot.getOwnerName());
-                this.response.appendInt(10);
-                this.response.appendShort(0);
-                this.response.appendShort(1);
-                this.response.appendShort(2);
-                this.response.appendShort(3);
-                this.response.appendShort(4);
-                this.response.appendShort(5);
-                this.response.appendShort(6);
-                this.response.appendShort(7);
-                this.response.appendShort(8);
-                this.response.appendShort(9);
+                short[] listActions = bot.getOwnerActionIds();
+                this.response.appendInt(listActions.length);
+                for (short action : listActions) {
+                    this.response.appendShort(action);
+                }
                 this.response.appendString("unknown");
                 this.response.appendInt(0);
                 this.response.appendInt(0);

Emulator/src/main/java/com/eu/habbo/messages/outgoing/soundboard/SoundboardPlayComposer.java

@@ -0,0 +1,27 @@
+package com.eu.habbo.messages.outgoing.soundboard;
+
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+// Broadcast to everyone in the room when a pad is pressed — they all play the clip.
+public class SoundboardPlayComposer extends MessageComposer {
+    private final int soundId;
+    private final String url;
+    private final String username;
+
+    public SoundboardPlayComposer(int soundId, String url, String username) {
+        this.soundId = soundId;
+        this.url = url != null ? url : "";
+        this.username = username != null ? username : "";
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.SoundboardPlayComposer);
+        this.response.appendInt(this.soundId);
+        this.response.appendString(this.url);
+        this.response.appendString(this.username);
+        return this.response;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/soundboard/SoundboardSettingsComposer.java

@@ -0,0 +1,33 @@
+package com.eu.habbo.messages.outgoing.soundboard;
+
+import com.eu.habbo.habbohotel.soundboard.SoundboardSound;
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+import java.util.List;
+
+// Sent on room enter (and on toggle): whether the soundboard is active in this
+// room + the available pads. The client shows the toolbar icon only if enabled.
+public class SoundboardSettingsComposer extends MessageComposer {
+    private final boolean enabled;
+    private final List<SoundboardSound> sounds;
+
+    public SoundboardSettingsComposer(boolean enabled, List<SoundboardSound> sounds) {
+        this.enabled = enabled;
+        this.sounds = sounds;
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.SoundboardSettingsComposer);
+        this.response.appendBoolean(this.enabled);
+        this.response.appendInt(this.sounds.size());
+        for (SoundboardSound sound : this.sounds) {
+            this.response.appendInt(sound.id);
+            this.response.appendString(sound.name);
+            this.response.appendString(sound.url);
+        }
+        return this.response;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/wheel/WheelAdminPrizesComposer.java

@@ -0,0 +1,34 @@
+package com.eu.habbo.messages.outgoing.wheel;
+
+import com.eu.habbo.habbohotel.wheel.WheelPrize;
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+import java.util.List;
+
+// Raw editable prize list for the in-client admin editor (sends value/amount/
+// pointsType as stored, unlike WheelDataComposer which resolves icons for players).
+public class WheelAdminPrizesComposer extends MessageComposer {
+    private final List<WheelPrize> prizes;
+
+    public WheelAdminPrizesComposer(List<WheelPrize> prizes) {
+        this.prizes = prizes;
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.WheelAdminPrizesComposer);
+        this.response.appendInt(this.prizes.size());
+        for (WheelPrize prize : this.prizes) {
+            this.response.appendInt(prize.id);
+            this.response.appendString(prize.type);
+            this.response.appendString(prize.value == null ? "" : prize.value);
+            this.response.appendInt(prize.amount);
+            this.response.appendInt(prize.pointsType);
+            this.response.appendInt(prize.weight);
+            this.response.appendString(prize.label == null ? "" : prize.label);
+        }
+        return this.response;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/wheel/WheelDataComposer.java

@@ -0,0 +1,46 @@
+package com.eu.habbo.messages.outgoing.wheel;
+
+import com.eu.habbo.habbohotel.wheel.WheelPrize;
+import com.eu.habbo.habbohotel.wheel.WheelUserState;
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+import java.util.List;
+
+// User spin balance + cost + the full prize list (one entry per slice).
+public class WheelDataComposer extends MessageComposer {
+    private final WheelUserState state;
+    private final int spinCost;
+    private final int spinCostType;
+    private final List<WheelPrize> prizes;
+
+    public WheelDataComposer(WheelUserState state, int spinCost, int spinCostType, List<WheelPrize> prizes) {
+        this.state = state;
+        this.spinCost = spinCost;
+        this.spinCostType = spinCostType;
+        this.prizes = prizes;
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.WheelDataComposer);
+        this.response.appendInt(this.state.freeSpins);
+        this.response.appendInt(this.state.extraSpins);
+        this.response.appendInt(this.spinCost);
+        this.response.appendInt(this.spinCostType);
+
+        this.response.appendInt(this.prizes.size());
+        for (WheelPrize prize : this.prizes) {
+            this.response.appendInt(prize.id);
+            this.response.appendString(prize.type);
+            this.response.appendInt(prize.spriteId);     // item only, else 0
+            this.response.appendString(prize.badgeCode()); // badge only, else ""
+            this.response.appendInt(prize.amount);
+            this.response.appendInt(prize.pointsType);
+            this.response.appendString(prize.label == null ? "" : prize.label);
+        }
+
+        return this.response;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/wheel/WheelRecentWinsComposer.java

@@ -0,0 +1,29 @@
+package com.eu.habbo.messages.outgoing.wheel;
+
+import com.eu.habbo.habbohotel.wheel.WheelRecentWin;
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+import java.util.List;
+
+// "Latest winners" list: username + look (for the headshot) + prize label.
+public class WheelRecentWinsComposer extends MessageComposer {
+    private final List<WheelRecentWin> wins;
+
+    public WheelRecentWinsComposer(List<WheelRecentWin> wins) {
+        this.wins = wins;
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.WheelRecentWinsComposer);
+        this.response.appendInt(this.wins.size());
+        for (WheelRecentWin win : this.wins) {
+            this.response.appendString(win.username);
+            this.response.appendString(win.look);
+            this.response.appendString(win.prizeLabel);
+        }
+        return this.response;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/wheel/WheelResultComposer.java

@@ -0,0 +1,22 @@
+package com.eu.habbo.messages.outgoing.wheel;
+
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+// The winning prize id. The client animates the wheel to that slice; the reward
+// was already granted server-side.
+public class WheelResultComposer extends MessageComposer {
+    private final int prizeId;
+
+    public WheelResultComposer(int prizeId) {
+        this.prizeId = prizeId;
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.WheelResultComposer);
+        this.response.appendInt(this.prizeId);
+        return this.response;
+    }
+}