🆙 Bump version to 4.2.35 [skip ci]

Merge pull request #149 from duckietm/main

Database Updates/003_live_required_schema.sql

@@ -322,13 +322,6 @@ CREATE TABLE IF NOT EXISTS `custom_prefix_settings` (
     PRIMARY KEY (`key_name`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
 
-CREATE TABLE IF NOT EXISTS `custom_prefix_blacklist` (
-    `id` INT(11) NOT NULL AUTO_INCREMENT,
-    `word` VARCHAR(100) NOT NULL,
-    PRIMARY KEY (`id`),
-    UNIQUE KEY `uk_custom_prefix_blacklist_word` (`word`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-
 INSERT IGNORE INTO `custom_prefix_settings` (`key_name`, `value`) VALUES
     ('max_length', '15'),
     ('min_rank_to_buy', '1'),

Database Updates/007_Frank.sql

@@ -49,22 +49,22 @@ INSERT INTO `bot_chat_responses` (`bot_type`, `keys`, `responses`) VALUES
 ('frank', 'pills;drugs',   'Drugs are bad, mmkay?');
 
 INSERT IGNORE INTO `bot_serves` (`keys`, `item`) VALUES
-('sunflower',                                          21),
-('cola;habbo cola',                                    32),
+('sunflower',                                          1002),
+('cola;habbo cola',                                    19),
 ('rose',                                               1000),
-('book',                                               20),
-('tea',                                                6),
-('coffee',                                             1),
-('migraine;headache;pills',                            34),
-('radioactive liquid;radioactive',                     36),
-('turkey;can of turkey',                               38);
+('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 (99001, 0, 'bot_frank', 'Frank', 1, 1, 0.00, '0', '0', '0', '1', '0', '0', '0', '0', '0', 'r', 'default', 1, '0', '0', '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');
+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 ('99001', 1, 99001, 'Frank', 0, 0, 0, 1, '0');
+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,89 @@
+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
+-- ----------------------------------------------------------------------------
+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`)
+) 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.'),
+    ('wheel.spin_cost',          '50', 'Fortune wheel: cost of one extra spin.'),
+    ('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`)
+SELECT `type`, `amount`, `points_type`, `weight`, `label`, `sort_order`
+FROM (
+              SELECT 'points'  AS `type`,  25 AS `amount`, 5 AS `points_type`, 20 AS `weight`, '25 diamonds'   AS `label`, 1 AS `sort_order`
+    UNION ALL SELECT 'points',   50, 5, 12, '50 diamonds',   2
+    UNION ALL SELECT 'points',  200, 5,  3, '200 diamonds',  3
+    UNION ALL SELECT 'credits', 100, 0, 15, '100 credits',   4
+    UNION ALL SELECT 'spin',      1, 0, 15, '1 Extra spin',  5
+    UNION ALL SELECT 'spin',      2, 0,  6, '2 Extra spins', 6
+    UNION ALL SELECT 'nothing',   0, 0, 29, 'Oh to bad!',    7
+) AS seed
+WHERE NOT EXISTS (SELECT 1 FROM `wheel_prizes`);
+
+INSERT IGNORE INTO `permission_definitions` (`permission_key`, `max_value`, `comment`)
+VALUES (
+    'acc_wheeladmin',
+    1,
+    'Allows opening the Fortune Wheel prize editor (FortuneWheelSettingsView) to add/edit prize slices. Gated server-side by the same key.'
+);
+
+SET @cols := NULL;
+SELECT GROUP_CONCAT(CONCAT('dst.`', `column_name`, '` = src.`', `column_name`, '`') SEPARATOR ', ')
+    INTO @cols
+FROM `information_schema`.`columns`
+WHERE `table_schema` = DATABASE()
+  AND `table_name`   = 'permission_definitions'
+  AND `column_name`  REGEXP '^rank_[0-9]+$';
+
+SET @sql := CONCAT(
+    'UPDATE `permission_definitions` dst ',
+    'JOIN `permission_definitions` src ON src.`permission_key` = ''acc_ads_background'' ',
+    'SET ', @cols, ' ',
+    'WHERE dst.`permission_key` = ''acc_wheeladmin'''
+);
+PREPARE stmt FROM @sql;
+EXECUTE stmt;
+DEALLOCATE PREPARE stmt;

Database Updates/009_mentions_wordfilter.sql

@@ -0,0 +1,76 @@
+CREATE TABLE IF NOT EXISTS `habbo_mentions` (
+    `id`               INT(11)       NOT NULL AUTO_INCREMENT,
+    `target_user_id`   INT(11)       NOT NULL,
+    `sender_user_id`   INT(11)       NOT NULL,
+    `sender_username`  VARCHAR(64)   NOT NULL DEFAULT '',
+    `room_id`          INT(11)       NOT NULL DEFAULT 0,
+    `room_name`        VARCHAR(64)   NOT NULL DEFAULT '',
+    `message`          VARCHAR(255)  NOT NULL DEFAULT '',
+    `mention_type`     TINYINT(1)    NOT NULL DEFAULT 0  COMMENT '0 = direct (@nick), 1 = broadcast (@all/@friends/@room)',
+    `timestamp`        INT(11)       NOT NULL DEFAULT 0,
+    `read`             TINYINT(1)    NOT NULL DEFAULT 0,
+    PRIMARY KEY (`id`),
+    KEY `idx_target_id`        (`target_user_id`, `id`),
+    KEY `idx_target_unread`    (`target_user_id`, `read`),
+    KEY `idx_target_timestamp` (`target_user_id`, `timestamp`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+
+
+
+INSERT INTO `permission_definitions`
+    (`permission_key`, `max_value`, `comment`,
+     `rank_1`, `rank_2`, `rank_3`, `rank_4`, `rank_5`, `rank_6`, `rank_7`, `rank_8`)
+VALUES
+    ('acc_mention_everyone', 1,
+     'Allow sending @all / @everyone / @tutti broadcast mentions (hotel-wide).',
+     0, 0, 0, 0, 1, 1, 1, 1),
+    ('acc_mention_friends', 1,
+     'Allow sending @friends / @amici broadcast mentions (sender''s online buddies).',
+     0, 0, 0, 0, 1, 1, 1, 1),
+    ('cmd_disablementions', 1,
+     'Allow toggling :disablementions to stop receiving any @mention notifications.',
+     1, 1, 1, 1, 1, 1, 1, 1),
+    ('cmd_disablemassmentions', 1,
+     'Allow toggling :disablemassmentions to stop receiving broadcast mentions (direct @nick still works).',
+     1, 1, 1, 1, 1, 1, 1, 1)
+ON DUPLICATE KEY UPDATE
+    `comment` = VALUES(`comment`);
+
+
+-- ----------------------------------------------------------------------------
+-- 3. Emulator settings: cooldowns, caps and alias lists
+--
+--    Only inserted when missing - existing tuned values are preserved.
+-- ----------------------------------------------------------------------------
+
+INSERT IGNORE INTO `emulator_settings` (`key`, `value`, `comment`) VALUES
+    ('mentions.enabled',          '1',
+        'Master switch. 1 = process @mentions, 0 = disable the feature entirely.'),
+    ('mentions.max.targets',      '50',
+        'Hard cap on how many users a single broadcast (@all / @friends / @room) can fan out to.'),
+    ('mentions.cooldown.ms',      '3000',
+        'Per-sender cooldown between any two mentions, in milliseconds.'),
+    ('mentions.room.cooldown.ms', '15000',
+        'Extra per-sender cooldown for broadcast mentions (@all / @friends / @room) on top of mentions.cooldown.ms.'),
+    ('mentions.store.limit',      '50',
+        'Number of mentions returned in the initial RequestMentionsList response.'),
+    ('mentions.request.cooldown.ms', '2000',
+        'Per-user cooldown between RequestMentionsList packets.'),
+    ('mentions.markread.cooldown.ms', '500',
+        'Per-user cooldown between mark-single-as-read packets.'),
+    ('mentions.markall.cooldown.ms',  '5000',
+        'Per-user cooldown between mark-all-as-read packets (bulk DB update).'),
+    ('mentions.delete.cooldown.ms',   '500',
+        'Per-user cooldown between delete-mention packets.'),
+    ('mentions.everyone.aliases', 'all,everyone,tutti',
+        'Comma-separated aliases that trigger an @everyone broadcast (requires acc_mention_everyone).'),
+    ('mentions.friends.aliases',  'friends,amici',
+        'Comma-separated aliases that trigger an @friends broadcast (requires acc_mention_friends).'),
+    ('mentions.room.aliases',     'room,stanza',
+        'Comma-separated aliases that trigger an @room broadcast (no permission required, room scope only).');
+
+
+ALTER TABLE `wordfilter`
+ADD COLUMN `prefix_only` ENUM('0','1') NOT NULL DEFAULT '0'
+COMMENT 'When 1, this word only applies to custom prefixes, not to chat/motto/guild.' AFTER `mute`;

Database Updates/Own_Database_RunFirst/016_custom_prefixes_setup.sql

@@ -63,15 +63,6 @@ CREATE TABLE IF NOT EXISTS `custom_prefix_settings` (
     PRIMARY KEY (`key_name`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
 
--- ------------------------------------------------------------
--- 5. Blacklist table
--- ------------------------------------------------------------
-CREATE TABLE IF NOT EXISTS `custom_prefix_blacklist` (
-    `id` INT(11) NOT NULL AUTO_INCREMENT,
-    `word` VARCHAR(100) NOT NULL,
-    PRIMARY KEY (`id`),
-    UNIQUE KEY `uk_word` (`word`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
 
 -- ============================================================
 -- Schema upgrades for existing installations
@@ -296,14 +287,6 @@ INSERT IGNORE INTO `custom_prefixes_catalog`
     (2, 'Legend', 'Legend', '#8B5CF6', '', 'discord-neon', '', 15, 0, 1, 2),
     (3, 'Staff Pick', 'Staff', '#3B82F6', '*', 'cartoon', '', 20, 0, 1, 3);
 
--- ============================================================
--- Example blacklist entries
--- ============================================================
-INSERT IGNORE INTO `custom_prefix_blacklist` (`word`) VALUES
-    ('admin'),
-    ('staff'),
-    ('mod'),
-    ('owner');
 
 -- ============================================================
 -- Notes

Emulator/pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.eu.habbo</groupId>
     <artifactId>Habbo</artifactId>
-    <version>4.2.22</version>
+    <version>4.2.35</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,9 @@ 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.mentions.MentionManager;
 import com.eu.habbo.habbohotel.commands.CommandHandler;
 import com.eu.habbo.habbohotel.crafting.CraftingManager;
 import com.eu.habbo.habbohotel.guides.GuideManager;
@@ -64,6 +67,9 @@ public class GameEnvironment {
     private GoogleTranslateManager googleTranslateManager;
     private CustomBadgeManager customBadgeManager;
     private InfostandBackgroundManager infostandBackgroundManager;
+    private WheelManager wheelManager;
+    private SoundboardManager soundboardManager;
+    private MentionManager mentionManager;
 
     public void load() throws Exception {
         LOGGER.info("GameEnvironment -> Loading...");
@@ -93,6 +99,9 @@ public class GameEnvironment {
         this.googleTranslateManager = new GoogleTranslateManager();
         this.customBadgeManager = new CustomBadgeManager();
         this.infostandBackgroundManager = new InfostandBackgroundManager();
+        this.wheelManager = new WheelManager();
+        this.soundboardManager = new SoundboardManager();
+        this.mentionManager = new MentionManager();
 
         this.roomManager.loadPublicRooms();
         this.navigatorManager.loadNavigator();
@@ -156,6 +165,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;
     }
@@ -188,6 +205,10 @@ public class GameEnvironment {
         return this.petManager;
     }
 
+    public MentionManager getMentionManager() {
+        return this.mentionManager;
+    }
+
     public AchievementManager getAchievementManager() {
         return this.achievementManager;
     }

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,9 +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};
+    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/FrankBot.java

@@ -23,7 +23,6 @@ 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";
@@ -75,13 +74,20 @@ public class FrankBot extends ButlerBot {
         }
     }
 
-    private static final short[] FRANK_OWNER_ACTIONS = new short[0];
+    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;

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;
+    public final TIntObjectMap<int[]> furnitureValues;
+    private volatile byte[] rareValuesPayloadCache;
 
     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,76 @@ public class CatalogManager {
         this.loadClothing();
         this.loadRecycler();
         this.loadGiftWrappers();
+        this.loadFurnitureValues();
+    }
+
+    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();
+
+                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});
+                    }
+                }
+            }
+        }
+
+        this.rebuildRareValuesPayloadCache();
+
+        LOGGER.info("Furniture Values -> Loaded! ({} entries)", this.furnitureValues.size());
+    }
+
+    private void rebuildRareValuesPayloadCache() {
+        try (java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream(this.furnitureValues.size() * 16 + 8);
+             java.io.DataOutputStream out = new java.io.DataOutputStream(baos)) {
+            out.writeInt(this.furnitureValues.size());
+            TIntObjectIterator<int[]> iterator = this.furnitureValues.iterator();
+            while (iterator.hasNext()) {
+                iterator.advance();
+                int[] value = iterator.value();
+                out.writeInt(iterator.key()); // spriteId
+                out.writeInt(value[0]);        // credits
+                out.writeInt(value[1]);        // points
+                out.writeInt(value[2]);        // pointsType
+            }
+            this.rareValuesPayloadCache = baos.toByteArray();
+        } catch (java.io.IOException e) {
+            LOGGER.error("Failed to build rare values payload cache", e);
+            this.rareValuesPayloadCache = null;
+        }
+    }
+
+    public TIntObjectMap<int[]> getFurnitureValues() {
+        return this.furnitureValues;
+    }
+
+    public byte[] getRareValuesPayloadSnapshot() {
+        return this.rareValuesPayloadCache;
     }
 
     private synchronized void loadLimitedNumbers() {
@@ -1051,9 +1124,6 @@ public class CatalogManager {
                                 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)) {

Emulator/src/main/java/com/eu/habbo/habbohotel/catalog/layouts/RoomBundleLayout.java

@@ -42,14 +42,18 @@ public class RoomBundleLayout extends SingleBundle {
         }
 
         if (this.room == null) {
-            if (this.roomId > 0) {
-                this.room = Emulator.getGameEnvironment().getRoomManager().loadRoom(this.roomId);
+            RoomManager roomManager = Emulator.getGameEnvironment().getRoomManager();
+            if (this.roomId > 0 && roomManager != null) {
+                this.room = roomManager.loadRoom(this.roomId);
 
                 if (this.room != null)
                     this.room.preventUnloading = true;
-            } else {
+            } else if (this.roomId <= 0) {
                 LOGGER.error("No room id specified for room bundle {}({})", this.getPageName(), this.getId());
             }
+            // roomManager can be null when CatalogManager.loadFurnitureValues() runs
+            // during GameEnvironment.load() before RoomManager is constructed; in that
+            // case skip eager room loading — the bundle resolves lazily at runtime.
         }
 
         if (this.room == null) {

Emulator/src/main/java/com/eu/habbo/habbohotel/commands/CommandHandler.java

@@ -191,6 +191,8 @@ public class CommandHandler {
         addCommand(new CreditsCommand());
         addCommand(new DanceCommand());
         addCommand(new DiagonalCommand());
+        addCommand(new DisableMassMentionsCommand());
+        addCommand(new DisableMentionsCommand());
         addCommand(new DisconnectCommand());
         addCommand(new EjectAllCommand());
         addCommand(new EmptyInventoryCommand());
@@ -301,7 +303,6 @@ public class CommandHandler {
         addCommand(new GivePrefixCommand());
         addCommand(new ListPrefixesCommand());
         addCommand(new RemovePrefixCommand());
-        addCommand(new PrefixBlacklistCommand());
         addCommand(new WiredCommand());
         addCommand(new TestCommand());
     }

Emulator/src/main/java/com/eu/habbo/habbohotel/commands/CommandsCommand.java

@@ -17,7 +17,22 @@ public class CommandsCommand extends Command {
         message.append("(").append(commands.size()).append("):\r\n");
 
         for (Command c : commands) {
-            message.append(Emulator.getTexts().getValue("commands.description." + c.permission, "commands.description." + c.permission)).append("\r");
+            String textKey = "commands.description." + c.permission;
+            String commandText = Emulator.getTexts().getValue(textKey, "");
+            String commandLine = ":" + c.keys[0];
+            String description = "";
+
+            if (commandText.startsWith(":")) {
+                commandLine = commandText;
+            } else if (!commandText.isEmpty() && !commandText.equals(textKey)) {
+                description = commandText;
+            }
+
+            message.append(commandLine).append("\r");
+
+            if (!description.isEmpty()) {
+                message.append(description).append("\r");
+            }
         }
 
         gameClient.getHabbo().alert(new String[]{message.toString()});

Emulator/src/main/java/com/eu/habbo/habbohotel/commands/DisableMassMentionsCommand.java

@@ -0,0 +1,25 @@
+package com.eu.habbo.habbohotel.commands;
+
+import com.eu.habbo.habbohotel.gameclients.GameClient;
+import com.eu.habbo.habbohotel.users.Habbo;
+
+public class DisableMassMentionsCommand extends Command {
+    public DisableMassMentionsCommand() {
+        super("cmd_disablemassmentions", new String[]{"disablemassmentions", "togglemassmentions"});
+    }
+
+    @Override
+    public boolean handle(GameClient gameClient, String[] params) throws Exception {
+        if (gameClient == null) return true;
+        Habbo habbo = gameClient.getHabbo();
+        if (habbo == null || habbo.getHabboStats() == null) return true;
+
+        boolean newState = !habbo.getHabboStats().massMentionsEnabled();
+        habbo.getHabboStats().setMassMentionsEnabled(newState);
+
+        habbo.whisper(newState
+                ? "Broadcast mentions (@all / @friends / @room) are now ENABLED for you."
+                : "Broadcast mentions (@all / @friends / @room) are now DISABLED for you. Direct @nick mentions still work.");
+        return true;
+    }
+}

Emulator/src/main/java/com/eu/habbo/habbohotel/commands/DisableMentionsCommand.java

@@ -0,0 +1,25 @@
+package com.eu.habbo.habbohotel.commands;
+
+import com.eu.habbo.habbohotel.gameclients.GameClient;
+import com.eu.habbo.habbohotel.users.Habbo;
+
+public class DisableMentionsCommand extends Command {
+    public DisableMentionsCommand() {
+        super("cmd_disablementions", new String[]{"disablementions", "togglementions"});
+    }
+
+    @Override
+    public boolean handle(GameClient gameClient, String[] params) throws Exception {
+        if (gameClient == null) return true;
+        Habbo habbo = gameClient.getHabbo();
+        if (habbo == null || habbo.getHabboStats() == null) return true;
+
+        boolean newState = !habbo.getHabboStats().mentionsEnabled();
+        habbo.getHabboStats().setMentionsEnabled(newState);
+
+        habbo.whisper(newState
+                ? "@mention notifications are now ENABLED for you."
+                : "@mention notifications are now DISABLED for you. You will not receive direct or broadcast mentions.");
+        return true;
+    }
+}

Emulator/src/main/java/com/eu/habbo/habbohotel/commands/FilterWordCommand.java

@@ -4,6 +4,7 @@ import com.eu.habbo.Emulator;
 import com.eu.habbo.habbohotel.gameclients.GameClient;
 import com.eu.habbo.habbohotel.modtool.WordFilter;
 import com.eu.habbo.habbohotel.modtool.WordFilterWord;
+import com.eu.habbo.habbohotel.rooms.RoomChatMessageBubbles;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -21,30 +22,44 @@ public class FilterWordCommand extends Command {
     @Override
     public boolean handle(GameClient gameClient, String[] params) throws Exception {
         if (params.length < 2) {
-            gameClient.getHabbo().whisper(Emulator.getTexts().getValue("commands.error.cmd_filterword.missing_word"));
+            gameClient.getHabbo().whisper(Emulator.getTexts().getValue("commands.error.cmd_filterword.missing_word"), RoomChatMessageBubbles.ALERT);
             return true;
         }
 
         String word = params[1];
 
+        // Optional trailing "prefix" keyword marks the word as prefix-only (blocks
+        // custom prefixes but not chat/motto/guild). Usage:
+        //   :filterword <word>                       -> everywhere, default replacement
+        //   :filterword <word> <replacement>         -> everywhere
+        //   :filterword <word> prefix                -> prefix-only, default replacement
+        //   :filterword <word> <replacement> prefix  -> prefix-only
+        boolean prefixOnly = false;
         String replacement = WordFilter.DEFAULT_REPLACEMENT;
-        if (params.length == 3) {
-            replacement = params[2];
+
+        if (params.length >= 3) {
+            if (params[params.length - 1].equalsIgnoreCase("prefix")) {
+                prefixOnly = true;
+                if (params.length >= 4) replacement = params[2];
+            } else {
+                replacement = params[2];
+            }
         }
 
-        WordFilterWord wordFilterWord = new WordFilterWord(word, replacement);
+        WordFilterWord wordFilterWord = new WordFilterWord(word, replacement, prefixOnly);
 
-        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection(); PreparedStatement statement = connection.prepareStatement("INSERT INTO wordfilter (`key`, `replacement`) VALUES (?, ?)")) {
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection(); PreparedStatement statement = connection.prepareStatement("INSERT INTO wordfilter (`key`, `replacement`, `prefix_only`) VALUES (?, ?, ?)")) {
             statement.setString(1, word);
             statement.setString(2, replacement);
+            statement.setString(3, prefixOnly ? "1" : "0");
             statement.execute();
         } catch (SQLException e) {
             LOGGER.error("Caught SQL exception", e);
-            gameClient.getHabbo().whisper(Emulator.getTexts().getValue("commands.error.cmd_filterword.error"));
+            gameClient.getHabbo().whisper(Emulator.getTexts().getValue("commands.error.cmd_filterword.error"), RoomChatMessageBubbles.ALERT);
             return true;
         }
 
-        gameClient.getHabbo().whisper(Emulator.getTexts().getValue("commands.succes.cmd_filterword.added").replace("%word%", word).replace("%replacement%", replacement));
+        gameClient.getHabbo().whisper(Emulator.getTexts().getValue("commands.succes.cmd_filterword.added").replace("%word%", word).replace("%replacement%", replacement) + (prefixOnly ? " [prefix-only]" : ""), RoomChatMessageBubbles.ALERT);
         Emulator.getGameEnvironment().getWordFilter().addWord(wordFilterWord);
 
         return true;

Emulator/src/main/java/com/eu/habbo/habbohotel/commands/PrefixBlacklistCommand.java

@@ -1,98 +0,0 @@
-package com.eu.habbo.habbohotel.commands;
-
-import com.eu.habbo.Emulator;
-import com.eu.habbo.habbohotel.gameclients.GameClient;
-import com.eu.habbo.habbohotel.rooms.RoomChatMessageBubbles;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-
-public class PrefixBlacklistCommand extends Command {
-    private static final Logger LOGGER = LoggerFactory.getLogger(PrefixBlacklistCommand.class);
-
-    public PrefixBlacklistCommand() {
-        super("cmd_prefix_blacklist", Emulator.getTexts().getValue("commands.keys.cmd_prefix_blacklist").split(";"));
-    }
-
-    @Override
-    public boolean handle(GameClient gameClient, String[] params) throws Exception {
-        if (params.length < 2) {
-            gameClient.getHabbo().whisper(Emulator.getTexts().getValue("commands.error.cmd_prefix_blacklist.usage"), RoomChatMessageBubbles.ALERT);
-            return true;
-        }
-
-        String action = params[1].toLowerCase();
-
-        if (action.equals("list")) {
-            StringBuilder sb = new StringBuilder();
-            sb.append(Emulator.getTexts().getValue("commands.succes.cmd_prefix_blacklist.header")).append("\r");
-
-            try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
-                 PreparedStatement statement = connection.prepareStatement("SELECT word FROM custom_prefix_blacklist ORDER BY word")) {
-                try (ResultSet set = statement.executeQuery()) {
-                    int count = 0;
-                    while (set.next()) {
-                        sb.append("- ").append(set.getString("word")).append("\r");
-                        count++;
-                    }
-                    if (count == 0) {
-                        sb.append(Emulator.getTexts().getValue("commands.succes.cmd_prefix_blacklist.empty"));
-                    }
-                }
-            } catch (SQLException e) {
-                LOGGER.error("Error listing prefix blacklist", e);
-            }
-
-            gameClient.getHabbo().whisper(sb.toString(), RoomChatMessageBubbles.ALERT);
-            return true;
-        }
-
-        if (params.length < 3) {
-            gameClient.getHabbo().whisper(Emulator.getTexts().getValue("commands.error.cmd_prefix_blacklist.usage"), RoomChatMessageBubbles.ALERT);
-            return true;
-        }
-
-        String word = params[2].toLowerCase().trim();
-
-        if (word.isEmpty()) {
-            gameClient.getHabbo().whisper(Emulator.getTexts().getValue("commands.error.cmd_prefix_blacklist.empty_word"), RoomChatMessageBubbles.ALERT);
-            return true;
-        }
-
-        if (action.equals("add")) {
-            try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
-                 PreparedStatement statement = connection.prepareStatement("INSERT INTO custom_prefix_blacklist (word) VALUES (?)")) {
-                statement.setString(1, word);
-                statement.execute();
-            } catch (SQLException e) {
-                LOGGER.error("Error adding prefix blacklist word", e);
-            }
-
-            gameClient.getHabbo().whisper(
-                Emulator.getTexts().getValue("commands.succes.cmd_prefix_blacklist.added").replace("%word%", word),
-                RoomChatMessageBubbles.ALERT
-            );
-        } else if (action.equals("remove")) {
-            try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
-                 PreparedStatement statement = connection.prepareStatement("DELETE FROM custom_prefix_blacklist WHERE word = ?")) {
-                statement.setString(1, word);
-                statement.execute();
-            } catch (SQLException e) {
-                LOGGER.error("Error removing prefix blacklist word", e);
-            }
-
-            gameClient.getHabbo().whisper(
-                Emulator.getTexts().getValue("commands.succes.cmd_prefix_blacklist.removed").replace("%word%", word),
-                RoomChatMessageBubbles.ALERT
-            );
-        } else {
-            gameClient.getHabbo().whisper(Emulator.getTexts().getValue("commands.error.cmd_prefix_blacklist.usage"), RoomChatMessageBubbles.ALERT);
-        }
-
-        return true;
-    }
-}

Emulator/src/main/java/com/eu/habbo/habbohotel/gameclients/GameClient.java

@@ -153,7 +153,13 @@ public class GameClient {
             this.channel.close();
 
             if (this.habbo != null) {
-                if (this.habbo.isOnline()) {
+                // Agisci sull'Habbo SOLO se è ancora attaccato a QUESTO client. Su un
+                // reconnect veloce (drop Cloudflare → il client riconnette) l'Habbo può
+                // essere già stato riassegnato alla NUOVA connessione (session resume):
+                // in quel caso questo dispose della vecchia connessione NON deve
+                // parcheggiarlo né disconnetterlo, altrimenti ucciderebbe la sessione
+                // appena ripristinata (era la causa del "Bye"/kick al 2° reconnect).
+                if (this.habbo.getClient() == this && this.habbo.isOnline()) {
                     // Try to park the habbo in the grace period instead of immediate disconnect
                     boolean parked = SessionResumeManager.getInstance().parkHabbo(this.habbo, this.ssoTicket);
 

Emulator/src/main/java/com/eu/habbo/habbohotel/gameclients/SessionResumeManager.java

@@ -118,16 +118,32 @@ public class SessionResumeManager {
             LOGGER.error("[SessionResume] Error during deferred disconnect", e);
         }
 
-        clearSsoTicket(habbo.getHabboInfo().getId());
+        // NON svuotare il ticket SSO qui. Dietro Cloudflare la pagina si ricarica
+        // lentamente (~15s) e la grace (5s) scade prima che la nuova connessione
+        // arrivi: svuotando il ticket si cancellava quello NUOVO appena scritto dal
+        // CMS per il refresh → "non-existing SSO token" → bisognava refreshare 2 volte.
+        // Il ticket vive col suo TTL (auth_ticket_expires_at) e viene sovrascritto dal
+        // CMS al prossimo /client o azzerato al logout.
     }
 
     private void restoreSsoTicket(int userId, String ssoTicket) {
+        // Restore the old ticket ONLY if no fresh ticket has been written in the
+        // meantime. On a hard-refresh the CMS writes a NEW auth_ticket for the same
+        // user before this parking restore runs; without the guard we'd clobber it
+        // with the old ticket, so the new connection's SSO wouldn't be found and the
+        // client would get "session expired" on the first attempt. The guard means:
+        // normal reconnect (ticket cleared to '' after login) -> restore; hard-refresh
+        // (CMS already wrote a new ticket) -> leave the new ticket untouched.
         try (var connection = Emulator.getDatabase().getDataSource().getConnection();
-             var statement = connection.prepareStatement("UPDATE users SET auth_ticket = ? WHERE id = ? LIMIT 1")) {
+             var statement = connection.prepareStatement("UPDATE users SET auth_ticket = ? WHERE id = ? AND (auth_ticket = '' OR auth_ticket IS NULL) LIMIT 1")) {
             statement.setString(1, ssoTicket);
             statement.setInt(2, userId);
-            statement.execute();
-            LOGGER.info("[SessionResume] Restored SSO ticket for user {} during grace period", userId);
+            int updated = statement.executeUpdate();
+            if (updated > 0) {
+                LOGGER.info("[SessionResume] Restored SSO ticket for user {} during grace period", userId);
+            } else {
+                LOGGER.info("[SessionResume] Skipped SSO restore for user {} — a newer ticket is already present (likely a fresh login/hard-refresh)", userId);
+            }
         } catch (Exception e) {
             LOGGER.error("[SessionResume] Failed to restore SSO ticket for user " + userId, e);
         }

Emulator/src/main/java/com/eu/habbo/habbohotel/guilds/Guild.java

@@ -252,6 +252,25 @@ public class Guild implements Runnable {
         return this.readForum;
     }
 
+    public boolean canHabboReadForum(int habboId, GuildMember member, boolean staff) {
+        if (staff || this.getOwnerId() == habboId) {
+            return true;
+        }
+
+        switch (this.readForum) {
+            case EVERYONE:
+                return true;
+            case MEMBERS:
+                return member != null && member.getRank().type <= GuildRank.MEMBER.type;
+            case ADMINS:
+                return member != null && member.getRank().type < GuildRank.MEMBER.type;
+            case OWNER:
+                return false;
+            default:
+                return true;
+        }
+    }
+
     public void setReadForum(SettingsState readForum) {
         this.readForum = readForum;
     }

Emulator/src/main/java/com/eu/habbo/habbohotel/items/interactions/InteractionRoomAds.java

@@ -29,6 +29,10 @@ public class InteractionRoomAds extends InteractionCustomValues {
         {
             this.put("offsetZ", "0");
         }
+
+        {
+            this.put("scale", "100");
+        }
     };
 
     public InteractionRoomAds(ResultSet set, Item baseItem) throws SQLException {

Emulator/src/main/java/com/eu/habbo/habbohotel/mentions/HabboMention.java

@@ -0,0 +1,90 @@
+package com.eu.habbo.habbohotel.mentions;
+
+import com.eu.habbo.habbohotel.rooms.Room;
+import com.eu.habbo.habbohotel.users.Habbo;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class HabboMention {
+
+    public static final int TYPE_DIRECT = 0;
+    public static final int TYPE_ROOM = 1;
+
+    private final int id;
+    private final int targetUserId;
+    private final int senderUserId;
+    private final String senderUsername;
+    private final int roomId;
+    private final String roomName;
+    private final String message;
+    private final int mentionType;
+    private final int timestamp;
+    private final boolean read;
+
+    public HabboMention(ResultSet set) throws SQLException {
+        this.id = set.getInt("id");
+        this.targetUserId = set.getInt("target_user_id");
+        this.senderUserId = set.getInt("sender_user_id");
+        this.senderUsername = set.getString("sender_username");
+        this.roomId = set.getInt("room_id");
+        this.roomName = set.getString("room_name");
+        this.message = set.getString("message");
+        this.mentionType = set.getInt("mention_type");
+        this.timestamp = set.getInt("timestamp");
+        this.read = set.getInt("read") == 1;
+    }
+
+    public HabboMention(int targetUserId, int id, Habbo sender, Room room, String roomName, String message, int mentionType, int timestamp) {
+        this.id = id;
+        this.targetUserId = targetUserId;
+        this.senderUserId = sender.getHabboInfo().getId();
+        this.senderUsername = sender.getHabboInfo().getUsername();
+        this.roomId = room.getId();
+        this.roomName = roomName;
+        this.message = message;
+        this.mentionType = mentionType;
+        this.timestamp = timestamp;
+        this.read = false;
+    }
+
+    public int getId() {
+        return this.id;
+    }
+
+    public int getTargetUserId() {
+        return this.targetUserId;
+    }
+
+    public int getSenderUserId() {
+        return this.senderUserId;
+    }
+
+    public String getSenderUsername() {
+        return this.senderUsername;
+    }
+
+    public int getRoomId() {
+        return this.roomId;
+    }
+
+    public String getRoomName() {
+        return this.roomName;
+    }
+
+    public String getMessage() {
+        return this.message;
+    }
+
+    public int getMentionType() {
+        return this.mentionType;
+    }
+
+    public int getTimestamp() {
+        return this.timestamp;
+    }
+
+    public boolean isRead() {
+        return this.read;
+    }
+}

Emulator/src/main/java/com/eu/habbo/habbohotel/mentions/MentionManager.java

@@ -0,0 +1,437 @@
+package com.eu.habbo.habbohotel.mentions;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.messenger.MessengerBuddy;
+import com.eu.habbo.habbohotel.rooms.Room;
+import com.eu.habbo.habbohotel.rooms.RoomChatType;
+import com.eu.habbo.habbohotel.users.Habbo;
+import com.eu.habbo.habbohotel.users.HabboManager;
+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.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class MentionManager {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(MentionManager.class);
+
+    private static final int ROOM_NAME_MAX_LENGTH = 64;
+    private static final int MESSAGE_MAX_LENGTH = 255;
+    private final ConcurrentHashMap<Integer, Long> cooldowns = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<Integer, Long> roomBroadcastCooldowns = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<Integer, Long> requestListCooldowns = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<Integer, Long> markReadCooldowns = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<Integer, Long> markAllCooldowns = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<Integer, Long> deleteCooldowns = new ConcurrentHashMap<>();
+
+    private volatile long lastPrune = System.currentTimeMillis();
+    private static final long PRUNE_INTERVAL_MS = 5 * 60_000L;
+
+    public boolean isEnabled() {
+        return Emulator.getConfig().getInt("mentions.enabled", 1) == 1;
+    }
+
+    /** Broadcast category resolved from a mention alias. */
+    public enum BroadcastScope {
+        NONE,
+        ROOM,
+        FRIENDS,
+        EVERYONE
+    }
+
+    public static final String PERMISSION_EVERYONE = "acc_mention_everyone";
+    public static final String PERMISSION_FRIENDS = "acc_mention_friends";
+
+    private Set<String> parseAliases(String configKey, String defaultValue) {
+        Set<String> aliases = new HashSet<>();
+        String raw = Emulator.getConfig().getValue(configKey, defaultValue);
+        for (String alias : raw.split(",")) {
+            String trimmed = alias.trim().toLowerCase();
+            if (!trimmed.isEmpty()) {
+                aliases.add(trimmed);
+            }
+        }
+        return aliases;
+    }
+
+    private Set<String> roomAliases() {
+        return parseAliases("mentions.room.aliases", "room,stanza");
+    }
+
+    private Set<String> friendsAliases() {
+        return parseAliases("mentions.friends.aliases", "friends,amici");
+    }
+
+    private Set<String> everyoneAliases() {
+        return parseAliases("mentions.everyone.aliases", "all,everyone,tutti");
+    }
+
+    private BroadcastScope classifyAlias(String alias,
+                                         Set<String> everyone,
+                                         Set<String> friends,
+                                         Set<String> room) {
+        if (alias.isEmpty()) return BroadcastScope.NONE;
+        if (everyone.contains(alias)) return BroadcastScope.EVERYONE;
+        if (friends.contains(alias)) return BroadcastScope.FRIENDS;
+        if (room.contains(alias)) return BroadcastScope.ROOM;
+        return BroadcastScope.NONE;
+    }
+
+    public void process(Habbo sender, Room room, String message, RoomChatType type) {
+        try {
+            if (!this.isEnabled()) {
+                return;
+            }
+
+            if (sender == null || room == null || message == null) {
+                return;
+            }
+
+            if (message.isEmpty() || message.indexOf('@') < 0) {
+                return;
+            }
+
+            int senderId = sender.getHabboInfo().getId();
+            long now = System.currentTimeMillis();
+            long cooldownMs = Emulator.getConfig().getInt("mentions.cooldown.ms", 3000);
+            Long last = this.cooldowns.get(senderId);
+            if (last != null && (now - last) < cooldownMs) {
+                return;
+            }
+
+            Set<String> roomAliases = this.roomAliases();
+            Set<String> friendsAliases = this.friendsAliases();
+            Set<String> everyoneAliases = this.everyoneAliases();
+
+            BroadcastScope broadcastScope = BroadcastScope.NONE;
+            LinkedHashSet<String> directTokens = new LinkedHashSet<>();
+
+            for (String token : message.split("\\s+")) {
+                if (token.length() < 2 || token.charAt(0) != '@') {
+                    continue;
+                }
+
+                String raw = token.substring(1);
+                String aliasCandidate = trimTrailingPunctuation(raw).toLowerCase();
+
+                BroadcastScope scope = this.classifyAlias(aliasCandidate, everyoneAliases, friendsAliases, roomAliases);
+
+                if (scope != BroadcastScope.NONE) {
+                    if (scope.ordinal() > broadcastScope.ordinal()) {
+                        broadcastScope = scope;
+                    }
+                } else if (!raw.isEmpty()) {
+                    directTokens.add(raw);
+                }
+            }
+
+            if (broadcastScope == BroadcastScope.EVERYONE && !sender.hasPermission(PERMISSION_EVERYONE)) {
+                broadcastScope = BroadcastScope.NONE;
+            } else if (broadcastScope == BroadcastScope.FRIENDS && !sender.hasPermission(PERMISSION_FRIENDS)) {
+                broadcastScope = BroadcastScope.NONE;
+            }
+
+            if (broadcastScope == BroadcastScope.NONE && directTokens.isEmpty()) {
+                return;
+            }
+
+            if (broadcastScope != BroadcastScope.NONE) {
+                long roomCooldownMs = Emulator.getConfig().getInt("mentions.room.cooldown.ms", 15000);
+                Long lastRoom = this.roomBroadcastCooldowns.get(senderId);
+                if (lastRoom != null && (now - lastRoom) < roomCooldownMs) {
+                    return;
+                }
+            }
+
+            int maxTargets = Emulator.getConfig().getInt("mentions.max.targets", 50);
+            if (maxTargets <= 0) maxTargets = 1;
+            int maxDirectTokens = Math.min(directTokens.size(), maxTargets);
+
+            List<Habbo> targets = new ArrayList<>();
+            Set<Integer> seen = new HashSet<>();
+
+            switch (broadcastScope) {
+                case EVERYONE:
+                    this.collectEveryoneTargets(senderId, targets, seen, maxTargets);
+                    break;
+                case FRIENDS:
+                    this.collectFriendsTargets(sender, senderId, targets, seen, maxTargets);
+                    break;
+                case ROOM:
+                    this.collectRoomTargets(room, senderId, targets, seen, maxTargets, true);
+                    break;
+                case NONE:
+                default:
+                    int processed = 0;
+                    for (String token : directTokens) {
+                        if (processed++ >= maxDirectTokens) break;
+                        Habbo habbo = this.resolveHabbo(room, token);
+                        if (habbo == null || habbo.getHabboInfo().getId() == senderId) {
+                            continue;
+                        }
+                        if (!acceptsMention(habbo, false)) {
+                            continue;
+                        }
+                        if (seen.add(habbo.getHabboInfo().getId())) {
+                            targets.add(habbo);
+                        }
+                        if (targets.size() >= maxTargets) {
+                            break;
+                        }
+                    }
+                    break;
+            }
+
+            if (targets.isEmpty()) {
+                return;
+            }
+
+            this.cooldowns.put(senderId, now);
+            if (broadcastScope != BroadcastScope.NONE) this.roomBroadcastCooldowns.put(senderId, now);
+            this.pruneCooldownsIfDue(now);
+
+            int mentionType = (broadcastScope != BroadcastScope.NONE) ? HabboMention.TYPE_ROOM : HabboMention.TYPE_DIRECT;
+            int timestamp = Emulator.getIntUnixTimestamp();
+            String roomName = truncate(room.getName(), ROOM_NAME_MAX_LENGTH);
+            String storedMessage = truncate(message, MESSAGE_MAX_LENGTH);
+
+            for (Habbo target : targets) {
+                this.store(target, sender, room, storedMessage, mentionType, timestamp, roomName);
+            }
+        } catch (Exception e) {
+            LOGGER.error("Failed to process mentions.", e);
+        }
+    }
+
+    private void collectRoomTargets(Room room, int senderId, List<Habbo> targets, Set<Integer> seen, int maxTargets, boolean isBroadcast) {
+        for (Habbo habbo : room.getHabbos()) {
+            if (habbo == null || habbo.getHabboInfo().getId() == senderId) continue;
+            if (!acceptsMention(habbo, isBroadcast)) continue;
+            if (seen.add(habbo.getHabboInfo().getId())) targets.add(habbo);
+            if (targets.size() >= maxTargets) break;
+        }
+    }
+
+    private void collectFriendsTargets(Habbo sender, int senderId, List<Habbo> targets, Set<Integer> seen, int maxTargets) {
+        if (sender.getMessenger() == null) return;
+        HabboManager habboManager = Emulator.getGameEnvironment().getHabboManager();
+        for (MessengerBuddy buddy : sender.getMessenger().getFriends().values()) {
+            if (buddy == null) continue;
+            int buddyId = buddy.getId();
+            if (buddyId == senderId) continue;
+            Habbo online = habboManager.getHabbo(buddyId);
+            if (online == null) continue;
+            if (!acceptsMention(online, true)) continue;
+            if (seen.add(buddyId)) targets.add(online);
+            if (targets.size() >= maxTargets) break;
+        }
+    }
+
+    private void collectEveryoneTargets(int senderId, List<Habbo> targets, Set<Integer> seen, int maxTargets) {
+        for (Habbo habbo : Emulator.getGameEnvironment().getHabboManager().getOnlineHabbos().values()) {
+            if (habbo == null || habbo.getHabboInfo().getId() == senderId) continue;
+            if (!acceptsMention(habbo, true)) continue;
+            if (seen.add(habbo.getHabboInfo().getId())) targets.add(habbo);
+            if (targets.size() >= maxTargets) break;
+        }
+    }
+
+    private boolean acceptsMention(Habbo recipient, boolean isBroadcast) {
+        if (recipient == null || recipient.getHabboStats() == null) return true;
+        if (!recipient.getHabboStats().mentionsEnabled()) return false;
+        if (isBroadcast && !recipient.getHabboStats().massMentionsEnabled()) return false;
+        return true;
+    }
+
+    private void store(Habbo target, Habbo sender, Room room, String message, int mentionType, int timestamp, String roomName) {
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement(
+                     "INSERT INTO habbo_mentions (target_user_id, sender_user_id, sender_username, room_id, room_name, message, mention_type, timestamp, `read`) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0)",
+                     Statement.RETURN_GENERATED_KEYS)) {
+            statement.setInt(1, target.getHabboInfo().getId());
+            statement.setInt(2, sender.getHabboInfo().getId());
+            statement.setString(3, sender.getHabboInfo().getUsername());
+            statement.setInt(4, room.getId());
+            statement.setString(5, roomName);
+            statement.setString(6, message);
+            statement.setInt(7, mentionType);
+            statement.setInt(8, timestamp);
+            statement.executeUpdate();
+
+            int generatedId = 0;
+            try (ResultSet keys = statement.getGeneratedKeys()) {
+                if (keys.next()) {
+                    generatedId = keys.getInt(1);
+                }
+            }
+
+            if (generatedId <= 0) {
+                return;
+            }
+
+            HabboMention mention = new HabboMention(target.getHabboInfo().getId(), generatedId, sender, room, roomName, message, mentionType, timestamp);
+
+            if (target.getClient() != null) {
+                target.getClient().sendResponse(new com.eu.habbo.messages.outgoing.mentions.MentionReceivedComposer(mention));
+            }
+        } catch (SQLException e) {
+            LOGGER.error("Failed to store mention.", e);
+        }
+    }
+
+    public List<HabboMention> getMentions(int userId, int limit) {
+        List<HabboMention> mentions = new ArrayList<>();
+        if (limit <= 0) limit = 50;
+        if (limit > 200) limit = 200;
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement(
+                     "SELECT * FROM habbo_mentions WHERE target_user_id = ? ORDER BY id DESC LIMIT ?")) {
+            statement.setInt(1, userId);
+            statement.setInt(2, limit);
+            try (ResultSet set = statement.executeQuery()) {
+                while (set.next()) {
+                    mentions.add(new HabboMention(set));
+                }
+            }
+        } catch (SQLException e) {
+            LOGGER.error("Failed to load mentions.", e);
+        }
+        return mentions;
+    }
+
+    public void markRead(int userId, int mode, int mentionId) {
+        if (mode != 0 && mode != 1) return;
+        if (mode == 1 && mentionId <= 0) return;
+
+        String query = mode == 1
+                ? "UPDATE habbo_mentions SET `read` = 1 WHERE target_user_id = ? AND id = ? AND `read` = 0"
+                : "UPDATE habbo_mentions SET `read` = 1 WHERE target_user_id = ? AND `read` = 0";
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement(query)) {
+            statement.setInt(1, userId);
+            if (mode == 1) {
+                statement.setInt(2, mentionId);
+            }
+            statement.executeUpdate();
+        } catch (SQLException e) {
+            LOGGER.error("Failed to mark mentions as read.", e);
+        }
+    }
+
+    public void delete(int userId, int mentionId) {
+        if (mentionId <= 0) return;
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement(
+                     "DELETE FROM habbo_mentions WHERE target_user_id = ? AND id = ?")) {
+            statement.setInt(1, userId);
+            statement.setInt(2, mentionId);
+            statement.executeUpdate();
+        } catch (SQLException e) {
+            LOGGER.error("Failed to delete mention.", e);
+        }
+    }
+
+    public boolean tryAcquireRequestList(int userId) {
+        long cooldownMs = Emulator.getConfig().getInt("mentions.request.cooldown.ms", 2000);
+        return tryAcquire(this.requestListCooldowns, userId, cooldownMs);
+    }
+
+    public boolean tryAcquireMarkRead(int userId, int mode) {
+        long cooldownMs;
+        ConcurrentHashMap<Integer, Long> bucket;
+        if (mode == 1) {
+            cooldownMs = Emulator.getConfig().getInt("mentions.markread.cooldown.ms", 500);
+            bucket = this.markReadCooldowns;
+        } else {
+            cooldownMs = Emulator.getConfig().getInt("mentions.markall.cooldown.ms", 5000);
+            bucket = this.markAllCooldowns;
+        }
+        return tryAcquire(bucket, userId, cooldownMs);
+    }
+
+    public boolean tryAcquireDelete(int userId) {
+        long cooldownMs = Emulator.getConfig().getInt("mentions.delete.cooldown.ms", 500);
+        return tryAcquire(this.deleteCooldowns, userId, cooldownMs);
+    }
+
+    private boolean tryAcquire(ConcurrentHashMap<Integer, Long> bucket, int userId, long cooldownMs) {
+        long now = System.currentTimeMillis();
+        Long last = bucket.get(userId);
+        if (last != null && (now - last) < cooldownMs) {
+            return false;
+        }
+        bucket.put(userId, now);
+        this.pruneCooldownsIfDue(now);
+        return true;
+    }
+
+    private void pruneCooldownsIfDue(long now) {
+        if (now - this.lastPrune < PRUNE_INTERVAL_MS) return;
+        this.lastPrune = now;
+
+        long mentionWindow = Emulator.getConfig().getInt("mentions.cooldown.ms", 3000);
+        long roomWindow = Emulator.getConfig().getInt("mentions.room.cooldown.ms", 15000);
+        long requestWindow = Emulator.getConfig().getInt("mentions.request.cooldown.ms", 2000);
+        long markReadWindow = Emulator.getConfig().getInt("mentions.markread.cooldown.ms", 500);
+        long markAllWindow = Emulator.getConfig().getInt("mentions.markall.cooldown.ms", 5000);
+        long deleteWindow = Emulator.getConfig().getInt("mentions.delete.cooldown.ms", 500);
+
+        prune(this.cooldowns, now, mentionWindow);
+        prune(this.roomBroadcastCooldowns, now, roomWindow);
+        prune(this.requestListCooldowns, now, requestWindow);
+        prune(this.markReadCooldowns, now, markReadWindow);
+        prune(this.markAllCooldowns, now, markAllWindow);
+        prune(this.deleteCooldowns, now, deleteWindow);
+    }
+
+    private static void prune(ConcurrentHashMap<Integer, Long> bucket, long now, long windowMs) {
+        Iterator<Map.Entry<Integer, Long>> it = bucket.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry<Integer, Long> entry = it.next();
+            Long value = entry.getValue();
+            if (value == null || (now - value) >= windowMs) {
+                it.remove();
+            }
+        }
+    }
+
+    private static final String TRAILING_PUNCTUATION = ".,!?;:)]}\"'";
+
+    private static String trimTrailingPunctuation(String value) {
+        int end = value.length();
+        while (end > 0 && TRAILING_PUNCTUATION.indexOf(value.charAt(end - 1)) >= 0) {
+            end--;
+        }
+        return value.substring(0, end);
+    }
+
+    private static String truncate(String value, int max) {
+        if (value == null) return "";
+        if (value.length() <= max) return value;
+        return value.substring(0, max);
+    }
+
+    private Habbo resolveHabbo(Room room, String rawToken) {
+        Habbo habbo = room.getHabbo(rawToken);
+        if (habbo != null) {
+            return habbo;
+        }
+        String trimmed = trimTrailingPunctuation(rawToken);
+        if (!trimmed.isEmpty() && !trimmed.equals(rawToken)) {
+            return room.getHabbo(trimmed);
+        }
+        return null;
+    }
+}

Emulator/src/main/java/com/eu/habbo/habbohotel/modtool/WordFilter.java

@@ -23,7 +23,6 @@ public class WordFilter {
     private static final Logger LOGGER = LoggerFactory.getLogger(WordFilter.class);
 
     private static final Pattern DIACRITICS_AND_FRIENDS = Pattern.compile("[\\p{InCombiningDiacriticalMarks}\\p{IsLm}\\p{IsSk}]+");
-    //Configuration. Loaded from database & updated accordingly.
     public static boolean ENABLED_FRIENDCHAT = true;
     public static String DEFAULT_REPLACEMENT = "bobba";
     protected THashSet<WordFilterWord> autoReportWords = new THashSet<>();
@@ -63,10 +62,12 @@ public class WordFilter {
                         continue;
                     }
 
-                    if (word.autoReport)
-                        this.autoReportWords.add(word);
-                    else if (word.hideMessage)
-                        this.hideMessageWords.add(word);
+                    if (!word.prefixOnly) {
+                        if (word.autoReport)
+                            this.autoReportWords.add(word);
+                        else if (word.hideMessage)
+                            this.hideMessageWords.add(word);
+                    }
 
                     this.words.add(word);
                 }
@@ -146,6 +147,8 @@ public class WordFilter {
         while (iterator.hasNext()) {
             WordFilterWord word = (WordFilterWord) iterator.next();
 
+            if (word.prefixOnly) continue;
+
             if (StringUtils.containsIgnoreCase(filteredMessage, word.key)) {
                 if (habbo != null) {
                     if (Emulator.getPluginManager().fireEvent(new UserTriggerWordFilterEvent(habbo, word)).isCancelled())
@@ -179,6 +182,8 @@ public class WordFilter {
         while (iterator.hasNext()) {
             WordFilterWord word = (WordFilterWord) iterator.next();
 
+            if (word.prefixOnly) continue;
+
             if (StringUtils.containsIgnoreCase(message, word.key)) {
                 if (habbo != null) {
                     if (Emulator.getPluginManager().fireEvent(new UserTriggerWordFilterEvent(habbo, word)).isCancelled())

Emulator/src/main/java/com/eu/habbo/habbohotel/modtool/WordFilterWord.java

@@ -9,6 +9,7 @@ public class WordFilterWord {
     public final boolean hideMessage;
     public final boolean autoReport;
     public final int muteTime;
+    public final boolean prefixOnly;
 
     public WordFilterWord(ResultSet set) throws SQLException {
         this.key = set.getString("key");
@@ -16,13 +17,27 @@ public class WordFilterWord {
         this.hideMessage = set.getInt("hide") == 1;
         this.autoReport = set.getInt("report") == 1;
         this.muteTime = set.getInt("mute");
+        this.prefixOnly = readBooleanColumn(set, "prefix_only");
     }
 
     public WordFilterWord(String key, String replacement) {
+        this(key, replacement, false);
+    }
+
+    public WordFilterWord(String key, String replacement, boolean prefixOnly) {
         this.key = key;
         this.replacement = replacement;
         this.hideMessage = false;
         this.autoReport = false;
         this.muteTime = 0;
+        this.prefixOnly = prefixOnly;
+    }
+
+    private static boolean readBooleanColumn(ResultSet set, String column) {
+        try {
+            return set.getInt(column) == 1;
+        } catch (SQLException e) {
+            return false;
+        }
     }
 }

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/RoomChatMessageBubbles.java

@@ -134,7 +134,18 @@ public class RoomChatMessageBubbles {
     }
 
     public static RoomChatMessageBubbles getBubble(int id) {
-        return BUBBLES.getOrDefault(id, NORMAL);
+        RoomChatMessageBubbles bubble = BUBBLES.get(id);
+        if (bubble != null) return bubble;
+
+        // Custom chat bubbles (client-side only, e.g. ids 253+) are not registered
+        // above. Instead of falling back to NORMAL (which made them render as the
+        // default bubble), pass the id through so the server relays it as-is and
+        // the client renders its own .bubble-<id> style. Capped to avoid abuse.
+        if (id > 0 && id <= 1000) {
+            return new RoomChatMessageBubbles(id, "CUSTOM_" + id, "", true, false);
+        }
+
+        return NORMAL;
     }
 
     private static void registerBubble(RoomChatMessageBubbles bubble) {

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/HabboManager.java

@@ -132,15 +132,12 @@ public class HabboManager {
                         Emulator.getPluginManager().fireEvent(new UserRegisteredEvent(habbo));
                     }
 
-                    if (!Emulator.debugging) {
-                        try (PreparedStatement stmt = connection.prepareStatement("UPDATE users SET auth_ticket = ? WHERE id = ? LIMIT 1")) {
-                            stmt.setString(1, "");
-                            stmt.setInt(2, habbo.getHabboInfo().getId());
-                            stmt.execute();
-                        } catch (SQLException e) {
-                            LOGGER.error("Caught SQL exception", e);
-                        }
-                    }
+                    // NB: il ticket SSO NON viene svuotato qui di proposito. Dietro
+                    // Cloudflare il WebSocket viene droppato e il client ritenta più
+                    // volte con lo STESSO ticket: se lo consumassimo al primo uso, i
+                    // retry (e l'hard-refresh) fallirebbero con "non-existing SSO token".
+                    // Il ticket resta valido fino alla scadenza (auth_ticket_expires_at,
+                    // TTL gestito dal CMS) o finché il CMS non ne scrive uno nuovo / logout.
                 }
             }
         } catch (SQLException e) {

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

@@ -94,6 +94,8 @@ public class HabboStats implements Runnable {
     public boolean hasGottenDefaultSavedSearches;
     private HabboInfo habboInfo;
     private boolean allowTrade;
+    private boolean mentionsEnabled;
+    private boolean massMentionsEnabled;
     private int clubExpireTimestamp;
     private int muteEndTime;
     public int maxFriends;
@@ -131,6 +133,8 @@ public class HabboStats implements Runnable {
         this.guilds = new ArrayList<>();
         this.tags = set.getString("tags").split(";");
         this.allowTrade = set.getString("can_trade").equals("1");
+        this.mentionsEnabled = "1".equals(safeColumnString(set, "mentions_enabled", "1"));
+        this.massMentionsEnabled = "1".equals(safeColumnString(set, "mass_mentions_enabled", "1"));
         this.votedRooms = new TIntArrayStack();
         this.clubExpireTimestamp = set.getInt("club_expire_timestamp");
         this.loginStreak = set.getInt("login_streak");
@@ -749,13 +753,6 @@ public class HabboStats implements Runnable {
         return 0;
     }
 
-    /**
-     * Ignore an user.
-     *
-     * @param gameClient The client to which this HabboStats instance belongs.
-     * @param userId The user to ignore.
-     * @return true if successfully ignored, false otherwise.
-     */
     public boolean ignoreUser(GameClient gameClient, int userId) {
         final Habbo target = Emulator.getGameEnvironment().getHabboManager().getHabbo(userId);
 
@@ -805,6 +802,44 @@ public class HabboStats implements Runnable {
         else return this.allowTrade;
     }
 
+    public boolean mentionsEnabled() {
+        return this.mentionsEnabled;
+    }
+
+    public boolean massMentionsEnabled() {
+        return this.massMentionsEnabled;
+    }
+
+    public void setMentionsEnabled(boolean enabled) {
+        this.mentionsEnabled = enabled;
+        persistFlag("mentions_enabled", enabled);
+    }
+
+    public void setMassMentionsEnabled(boolean enabled) {
+        this.massMentionsEnabled = enabled;
+        persistFlag("mass_mentions_enabled", enabled);
+    }
+
+    private void persistFlag(String column, boolean enabled) {
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement("UPDATE users_settings SET `" + column + "` = ? WHERE user_id = ? LIMIT 1")) {
+            statement.setString(1, enabled ? "1" : "0");
+            statement.setInt(2, this.habboInfo.getId());
+            statement.executeUpdate();
+        } catch (SQLException e) {
+            LOGGER.error("Failed to persist users_settings.{} for user {}", column, this.habboInfo.getId(), e);
+        }
+    }
+
+    private static String safeColumnString(ResultSet set, String column, String defaultValue) {
+        try {
+            String value = set.getString(column);
+            return value == null ? defaultValue : value;
+        } catch (SQLException e) {
+            return defaultValue;
+        }
+    }
+
     public void setAllowTrade(boolean allowTrade) {
         this.allowTrade = allowTrade;
     }

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

@@ -0,0 +1,430 @@
+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.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.StringJoiner;
+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;
+    }
+
+    /**
+     * Persists a single prize. An {@code id <= 0} inserts a brand-new prize and
+     * returns its generated id; a positive id updates the existing row (and
+     * re-enables it, so a previously soft-deleted prize can be brought back).
+     * {@code sortOrder} reflects the prize's position in the editor so the
+     * wheel layout matches what the admin sees. Returns the effective row id,
+     * or {@code 0} if the write failed.
+     */
+    public int savePrize(int id, String type, String value, int amount, int pointsType, int weight, String label, int sortOrder) {
+        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);
+        int safeSort = clamp(sortOrder, 0, MAX_PRIZES_PER_SAVE);
+
+        if (id > 0) {
+            try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+                 PreparedStatement statement = connection.prepareStatement(
+                         "UPDATE wheel_prizes SET type = ?, value = ?, amount = ?, points_type = ?, weight = ?, label = ?, sort_order = ?, enabled = 1 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, safeSort);
+                statement.setInt(8, id);
+                statement.executeUpdate();
+                return id;
+            } catch (SQLException e) {
+                LOGGER.error("Failed to save wheel prize {}", id, e);
+                return 0;
+            }
+        }
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement(
+                     "INSERT INTO wheel_prizes (type, value, amount, points_type, weight, label, enabled, sort_order) VALUES (?, ?, ?, ?, ?, ?, 1, ?)",
+                     Statement.RETURN_GENERATED_KEYS)) {
+            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, safeSort);
+            statement.executeUpdate();
+
+            try (ResultSet keys = statement.getGeneratedKeys()) {
+                if (keys.next()) return keys.getInt(1);
+            }
+        } catch (SQLException e) {
+            LOGGER.error("Failed to insert wheel prize", e);
+        }
+        return 0;
+    }
+
+    /**
+     * Soft-deletes every enabled prize whose id is not in {@code keptIds} by
+     * setting {@code enabled = 0}. This is intentionally non-destructive: rows
+     * stay in the table (so historical references and re-enabling remain
+     * possible) but {@link #loadPrizes()} only ever loads {@code enabled = 1}.
+     * An empty set disables all prizes.
+     */
+    public void disablePrizesNotIn(Set<Integer> keptIds) {
+        if (keptIds == null) return;
+
+        StringBuilder sql = new StringBuilder("UPDATE wheel_prizes SET enabled = 0 WHERE enabled = 1");
+        if (!keptIds.isEmpty()) {
+            StringJoiner ids = new StringJoiner(",", " AND id NOT IN (", ")");
+            for (Integer keptId : keptIds) {
+                ids.add(Integer.toString(keptId));
+            }
+            sql.append(ids);
+        }
+
+        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
+             PreparedStatement statement = connection.prepareStatement(sql.toString())) {
+            statement.executeUpdate();
+        } catch (SQLException e) {
+            LOGGER.error("Failed to disable removed wheel prizes", 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

@@ -39,6 +39,7 @@ import com.eu.habbo.messages.incoming.hotelview.*;
 import com.eu.habbo.messages.incoming.inventory.*;
 import com.eu.habbo.messages.incoming.inventory.nickicons.*;
 import com.eu.habbo.messages.incoming.inventory.prefixes.*;
+import com.eu.habbo.messages.incoming.mentions.*;
 import com.eu.habbo.messages.incoming.modtool.*;
 import com.eu.habbo.messages.incoming.navigator.*;
 import com.eu.habbo.messages.incoming.polls.AnswerPollEvent;
@@ -426,6 +427,9 @@ public class PacketManager {
     }
 
     void registerRooms() throws Exception {
+        this.registerHandler(Incoming.RequestMentionsEvent, RequestMentionsEvent.class);
+        this.registerHandler(Incoming.MarkMentionsReadEvent, MarkMentionsReadEvent.class);
+        this.registerHandler(Incoming.DeleteMentionEvent, DeleteMentionEvent.class);
         this.registerHandler(Incoming.RequestRoomLoadEvent, RequestRoomLoadEvent.class);
         this.registerHandler(Incoming.RequestHeightmapEvent, RequestRoomHeightmapEvent.class);
         this.registerHandler(Incoming.RequestRoomHeightmapEvent, RequestRoomHeightmapEvent.class);
@@ -745,5 +749,16 @@ public class PacketManager {
         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

@@ -486,4 +486,17 @@ public class Incoming {
     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;
+    public static final int RequestMentionsEvent = 4803;
+    public static final int MarkMentionsReadEvent = 4804;
+    public static final int DeleteMentionEvent = 4805;
 }

Emulator/src/main/java/com/eu/habbo/messages/incoming/guilds/GuildAcceptMembershipEvent.java

@@ -25,45 +25,55 @@ public class GuildAcceptMembershipEvent extends MessageHandler {
         int userId = this.packet.readInt();
 
         Guild guild = Emulator.getGameEnvironment().getGuildManager().getGuild(guildId);
+
+        if (guild == null) {
+            return;
+        }
+
+        GuildMember actorMember = Emulator.getGameEnvironment().getGuildManager().getGuildMember(guild, this.client.getHabbo());
+        boolean canAccept = guild.getOwnerId() == this.client.getHabbo().getHabboInfo().getId()
+                || this.client.getHabbo().hasPermission(Permission.ACC_GUILD_ADMIN)
+                || (actorMember != null && (actorMember.getRank().equals(GuildRank.ADMIN) || actorMember.getRank().equals(GuildRank.OWNER)));
+
+        if (!canAccept) {
+            return;
+        }
+
+        GuildMember targetMember = Emulator.getGameEnvironment().getGuildManager().getGuildMember(guildId, userId);
+
+        if (targetMember == null) {
+            this.client.sendResponse(new GuildAcceptMemberErrorComposer(guild.getId(), GuildAcceptMemberErrorComposer.NO_LONGER_MEMBER));
+            return;
+        }
+
+        if (targetMember.getRank().type != GuildRank.REQUESTED.type) {
+            this.client.sendResponse(new GuildAcceptMemberErrorComposer(guild.getId(), GuildAcceptMemberErrorComposer.ALREADY_ACCEPTED));
+            return;
+        }
+
         Habbo habbo = Emulator.getGameEnvironment().getHabboManager().getHabbo(userId);
 
-        if (guild != null) {
-            GuildMember groupMember = Emulator.getGameEnvironment().getGuildManager().getGuildMember(guild, this.client.getHabbo());
-            if (guild.getOwnerId() == this.client.getHabbo().getHabboInfo().getId()
-                || this.client.getHabbo().hasPermission(Permission.ACC_GUILD_ADMIN)
-                || (groupMember != null && (groupMember.getRank().equals(GuildRank.ADMIN) || groupMember.getRank().equals(GuildRank.OWNER)))) {
-                if (habbo != null) {
-                    if (habbo.getHabboStats().hasGuild(guild.getId())) {
-                        this.client.sendResponse(new GuildAcceptMemberErrorComposer(guild.getId(), GuildAcceptMemberErrorComposer.ALREADY_ACCEPTED));
-                        return;
-                    } else {
-                        //Check the user has requested
-                        GuildMember member = Emulator.getGameEnvironment().getGuildManager().getGuildMember(guild, habbo);
-                        if (member == null || member.getRank().type != GuildRank.REQUESTED.type) {
-                            this.client.sendResponse(new GuildAcceptMemberErrorComposer(guild.getId(), GuildAcceptMemberErrorComposer.NO_LONGER_MEMBER));
-                            return;
-                        } else {
-                            GuildAcceptedMembershipEvent event = new GuildAcceptedMembershipEvent(guild, userId, habbo);
-                            Emulator.getPluginManager().fireEvent(event);
-                            if (!event.isCancelled()) {
-                                habbo.getHabboStats().addGuild(guild.getId());
-                                Emulator.getGameEnvironment().getGuildManager().joinGuild(guild, this.client, habbo.getHabboInfo().getId(), true);
-                                guild.decreaseRequestCount();
-                                guild.increaseMemberCount();
-                                this.client.sendResponse(new GuildRefreshMembersListComposer(guild));
-                                Room room = habbo.getHabboInfo().getCurrentRoom();
-                                if (room != null) {
-                                    if (room.getGuildId() == guildId) {
-                                        habbo.getClient().sendResponse(new GuildInfoComposer(guild, habbo.getClient(), false, Emulator.getGameEnvironment().getGuildManager().getGuildMember(guildId, userId)));
-                                        room.refreshRightsForHabbo(habbo);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                } else {
-                    Emulator.getGameEnvironment().getGuildManager().joinGuild(guild, this.client, userId, true);
-                }
+        GuildAcceptedMembershipEvent event = new GuildAcceptedMembershipEvent(guild, userId, habbo);
+        Emulator.getPluginManager().fireEvent(event);
+
+        if (event.isCancelled()) {
+            return;
+        }
+
+        if (habbo != null) {
+            habbo.getHabboStats().addGuild(guild.getId());
+        }
+
+        Emulator.getGameEnvironment().getGuildManager().joinGuild(guild, this.client, userId, true);
+        guild.decreaseRequestCount();
+        guild.increaseMemberCount();
+        this.client.sendResponse(new GuildRefreshMembersListComposer(guild));
+
+        if (habbo != null) {
+            Room room = habbo.getHabboInfo().getCurrentRoom();
+            if (room != null && room.getGuildId() == guildId) {
+                habbo.getClient().sendResponse(new GuildInfoComposer(guild, habbo.getClient(), false, Emulator.getGameEnvironment().getGuildManager().getGuildMember(guildId, userId)));
+                room.refreshRightsForHabbo(habbo);
             }
         }
     }

Emulator/src/main/java/com/eu/habbo/messages/incoming/guilds/GuildDeclineMembershipEvent.java

@@ -29,6 +29,11 @@ public class GuildDeclineMembershipEvent extends MessageHandler {
         if (guild != null) {
             GuildMember member = Emulator.getGameEnvironment().getGuildManager().getGuildMember(guild, this.client.getHabbo());
             if (userId == this.client.getHabbo().getHabboInfo().getId() || guild.getOwnerId() == this.client.getHabbo().getHabboInfo().getId() || (member != null && (member.getRank().equals(GuildRank.ADMIN) || member.getRank().equals(GuildRank.OWNER))) || this.client.getHabbo().hasPermission(Permission.ACC_GUILD_ADMIN)) {
+                GuildMember target = Emulator.getGameEnvironment().getGuildManager().getGuildMember(guildId, userId);
+                if (target == null || target.getRank().type != GuildRank.REQUESTED.type) {
+                    return;
+                }
+
                 guild.decreaseRequestCount();
                 Emulator.getGameEnvironment().getGuildManager().removeMember(guild, userId);
                 this.client.sendResponse(new GuildMembersComposer(guild, Emulator.getGameEnvironment().getGuildManager().getGuildMembers(guild, 0, 0, ""), this.client.getHabbo(), 0, 0, "", true, Emulator.getGameEnvironment().getGuildManager().getGuildMembersCount(guild, 0, 0, "")));

Emulator/src/main/java/com/eu/habbo/messages/incoming/guilds/RequestGuildBuyEvent.java

@@ -30,20 +30,69 @@ public class RequestGuildBuyEvent extends MessageHandler {
         final String name = Emulator.getGameEnvironment().getWordFilter().filter(this.packet.readString(), this.client.getHabbo());
         final String description = Emulator.getGameEnvironment().getWordFilter().filter(this.packet.readString(), this.client.getHabbo());
 
-        if(name.length() > 29){
+        if (name.length() == 0 || name.length() > 29) {
             this.client.sendResponse(new GuildEditFailComposer(GuildEditFailComposer.INVALID_GUILD_NAME));
             return;
         }
-        if(description.length() > 254){
+        if (description.length() > 254) {
             return;
         }
 
-
         if (Emulator.getConfig().getBoolean("catalog.guild.hc_required", true) && !this.client.getHabbo().getHabboStats().hasActiveClub()) {
             this.client.sendResponse(new GuildEditFailComposer(GuildEditFailComposer.HC_REQUIRED));
             return;
         }
 
+        int roomId = this.packet.readInt();
+
+        Room r = Emulator.getGameEnvironment().getRoomManager().getRoom(roomId);
+
+        if (r == null) {
+            this.client.sendResponse(new AlertPurchaseFailedComposer(AlertPurchaseFailedComposer.SERVER_ERROR));
+            return;
+        }
+
+        if (r.hasGuild() || r.getGuildId() != 0) {
+            this.client.sendResponse(new GuildEditFailComposer(GuildEditFailComposer.ROOM_ALREADY_IN_USE));
+            return;
+        }
+
+        if (r.getOwnerId() != this.client.getHabbo().getHabboInfo().getId()) {
+            String message = Emulator.getTexts().getValue("scripter.warning.guild.buy.owner").replace("%username%", this.client.getHabbo().getHabboInfo().getUsername()).replace("%roomname%", r.getName().replace("%owner%", r.getOwnerName()));
+            ScripterManager.scripterDetected(this.client, message);
+            LOGGER.info(message);
+            return;
+        }
+
+        int colorOne = this.packet.readInt();
+        int colorTwo = this.packet.readInt();
+
+        int count = this.packet.readInt();
+
+        StringBuilder badge = new StringBuilder();
+
+        byte base = 1;
+
+        while (base < count) {
+            int id = this.packet.readInt();
+            int color = this.packet.readInt();
+            int pos = this.packet.readInt();
+
+            if (base == 1) {
+                badge.append("b");
+            } else {
+                badge.append("s");
+            }
+
+            badge.append(id < 100 ? "0" : "").append(id < 10 ? "0" : "").append(id).append(color < 10 ? "0" : "").append(color).append(pos);
+
+            base += 3;
+        }
+
+        // Only charge the player once every step has been validated. Previously the
+        // credits were deducted before the room was checked, so a purchase that
+        // failed afterwards (missing room, room already used by a guild, not the
+        // owner) still took the credits without ever creating the group.
         if (!this.client.getHabbo().hasPermission(Permission.ACC_INFINITE_CREDITS)) {
             int guildPrice = Emulator.getConfig().getInt("catalog.guild.price");
             if (this.client.getHabbo().getHabboInfo().getCredits() >= guildPrice) {
@@ -54,78 +103,34 @@ public class RequestGuildBuyEvent extends MessageHandler {
             }
         }
 
-        int roomId = this.packet.readInt();
+        Guild guild = Emulator.getGameEnvironment().getGuildManager().createGuild(this.client.getHabbo(), roomId, r.getName(), name, description, badge.toString(), colorOne, colorTwo);
 
-        Room r = Emulator.getGameEnvironment().getRoomManager().getRoom(roomId);
+        r.setGuild(guild.getId());
+        r.removeAllRights();
+        r.setNeedsUpdate(true);
 
-        if (r != null) {
-            if (r.hasGuild()) {
-                this.client.sendResponse(new GuildEditFailComposer(GuildEditFailComposer.ROOM_ALREADY_IN_USE));
-                return;
+        Emulator.getGameEnvironment().getGuildManager().addGuild(guild);
+
+        if (Emulator.getConfig().getBoolean("imager.internal.enabled")) {
+            Emulator.getBadgeImager().generate(guild);
+        }
+
+        this.client.sendResponse(new PurchaseOKComposer());
+        this.client.sendResponse(new GuildBoughtComposer(guild));
+        r.refreshGuild(guild);
+
+        for (Habbo habbo : r.getHabbos()) {
+            if (habbo.getClient() == null) {
+                continue;
             }
 
-            if (r.getOwnerId() == this.client.getHabbo().getHabboInfo().getId()) {
-                if (r.getGuildId() == 0) {
-                    int colorOne = this.packet.readInt();
-                    int colorTwo = this.packet.readInt();
+            habbo.getClient().sendResponse(new GuildInfoComposer(guild, habbo.getClient(), false, null));
 
-                    int count = this.packet.readInt();
-
-                    StringBuilder badge = new StringBuilder();
-
-                    byte base = 1;
-
-                    while (base < count) {
-                        int id = this.packet.readInt();
-                        int color = this.packet.readInt();
-                        int pos = this.packet.readInt();
-
-                        if (base == 1) {
-                            badge.append("b");
-                        } else {
-                            badge.append("s");
-                        }
-
-                        badge.append(id < 100 ? "0" : "").append(id < 10 ? "0" : "").append(id).append(color < 10 ? "0" : "").append(color).append(pos);
-
-                        base += 3;
-                    }
-
-                    Guild guild = Emulator.getGameEnvironment().getGuildManager().createGuild(this.client.getHabbo(), roomId, r.getName(), name, description, badge.toString(), colorOne, colorTwo);
-
-                    r.setGuild(guild.getId());
-                    r.removeAllRights();
-                    r.setNeedsUpdate(true);
-
-                    Emulator.getGameEnvironment().getGuildManager().addGuild(guild);
-
-                    if (Emulator.getConfig().getBoolean("imager.internal.enabled")) {
-                        Emulator.getBadgeImager().generate(guild);
-                    }
-
-                    this.client.sendResponse(new PurchaseOKComposer());
-                    this.client.sendResponse(new GuildBoughtComposer(guild));
-                    r.refreshGuild(guild);
-
-                    for (Habbo habbo : r.getHabbos()) {
-                        if (habbo.getClient() == null) {
-                            continue;
-                        }
-
-                        habbo.getClient().sendResponse(new GuildInfoComposer(guild, habbo.getClient(), false, null));
-
-                        if (habbo.getHabboInfo().getId() != this.client.getHabbo().getHabboInfo().getId()) {
-                            habbo.getClient().sendResponse(new RoomDataComposer(r, habbo, true, false));
-                        }
-                    }
-
-                    Emulator.getPluginManager().fireEvent(new GuildPurchasedEvent(guild, this.client.getHabbo()));
-                }
-            } else {
-                String message = Emulator.getTexts().getValue("scripter.warning.guild.buy.owner").replace("%username%", this.client.getHabbo().getHabboInfo().getUsername()).replace("%roomname%", r.getName().replace("%owner%", r.getOwnerName()));
-                ScripterManager.scripterDetected(this.client, message);
-                LOGGER.info(message);
+            if (habbo.getHabboInfo().getId() != this.client.getHabbo().getHabboInfo().getId()) {
+                habbo.getClient().sendResponse(new RoomDataComposer(r, habbo, true, false));
             }
         }
+
+        Emulator.getPluginManager().fireEvent(new GuildPurchasedEvent(guild, this.client.getHabbo()));
     }
 }

Emulator/src/main/java/com/eu/habbo/messages/incoming/guilds/forums/GuildForumDataEvent.java

@@ -2,7 +2,11 @@ package com.eu.habbo.messages.incoming.guilds.forums;
 
 import com.eu.habbo.Emulator;
 import com.eu.habbo.habbohotel.guilds.Guild;
+import com.eu.habbo.habbohotel.guilds.GuildMember;
+import com.eu.habbo.habbohotel.permissions.Permission;
 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.guilds.forums.GuildForumDataComposer;
 
 public class GuildForumDataEvent extends MessageHandler {
@@ -20,10 +24,18 @@ public class GuildForumDataEvent extends MessageHandler {
         if (guild == null) return;
         if (!guild.hasForum()) return;
 
+        GuildMember member = Emulator.getGameEnvironment().getGuildManager().getGuildMember(guildId, this.client.getHabbo().getHabboInfo().getId());
+        boolean staff = this.client.getHabbo().hasPermission(Permission.ACC_MODTOOL_TICKET_Q);
+
+        if (!guild.canHabboReadForum(this.client.getHabbo().getHabboInfo().getId(), member, staff)) {
+            this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FORUMS_ACCESS_DENIED.key).compose());
+            return;
+        }
+
         this.client.sendResponse(new GuildForumDataComposer(guild, this.client.getHabbo()));
 
         if (!Emulator.getGameEnvironment().getGuildManager().hasViewedForum(this.client.getHabbo().getHabboInfo().getId(), guildId)) {
             Emulator.getGameEnvironment().getGuildManager().addView(this.client.getHabbo().getHabboInfo().getId(), guildId);
         }
     }
-}
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/guilds/forums/GuildForumThreadsEvent.java

@@ -2,7 +2,11 @@ package com.eu.habbo.messages.incoming.guilds.forums;
 
 import com.eu.habbo.Emulator;
 import com.eu.habbo.habbohotel.guilds.Guild;
+import com.eu.habbo.habbohotel.guilds.GuildMember;
+import com.eu.habbo.habbohotel.permissions.Permission;
 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.guilds.forums.GuildForumDataComposer;
 import com.eu.habbo.messages.outgoing.guilds.forums.GuildForumThreadsComposer;
 import com.eu.habbo.messages.outgoing.handshake.ConnectionErrorComposer;
@@ -24,8 +28,15 @@ public class GuildForumThreadsEvent extends MessageHandler {
             this.client.sendResponse(new ConnectionErrorComposer(404));
             return;
         }
+        GuildMember member = Emulator.getGameEnvironment().getGuildManager().getGuildMember(guildId, this.client.getHabbo().getHabboInfo().getId());
+        boolean staff = this.client.getHabbo().hasPermission(Permission.ACC_MODTOOL_TICKET_Q);
+
+        if (!guild.canHabboReadForum(this.client.getHabbo().getHabboInfo().getId(), member, staff)) {
+            this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FORUMS_ACCESS_DENIED.key).compose());
+            return;
+        }
 
         this.client.sendResponse(new GuildForumDataComposer(guild, this.client.getHabbo()));
         this.client.sendResponse(new GuildForumThreadsComposer(guild, index));
     }
-}
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/guilds/forums/GuildForumThreadsMessagesEvent.java

@@ -38,7 +38,6 @@ public class GuildForumThreadsMessagesEvent extends MessageHandler {
             return;
         }
 
-        // Verify thread belongs to the requested guild
         if (thread.getGuildId() != guildId) {
             this.client.sendResponse(new ConnectionErrorComposer(403));
             return;
@@ -47,6 +46,11 @@ public class GuildForumThreadsMessagesEvent extends MessageHandler {
         GuildMember member = Emulator.getGameEnvironment().getGuildManager().getGuildMember(guildId, this.client.getHabbo().getHabboInfo().getId());
         boolean isGuildAdministrator = (guild.getOwnerId() == this.client.getHabbo().getHabboInfo().getId() || (member != null && member.getRank().equals(GuildRank.ADMIN)));
 
+        if (!guild.canHabboReadForum(this.client.getHabbo().getHabboInfo().getId(), member, hasStaffPermissions)) {
+            this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FORUMS_ACCESS_DENIED.key).compose());
+            return;
+        }
+
         if (thread.getState() != ForumThreadState.HIDDEN_BY_GUILD_ADMIN || hasStaffPermissions || isGuildAdministrator) {
             this.client.sendResponse(new GuildForumCommentsComposer(guildId, threadId, index, thread.getComments(limit, index)));
             this.client.sendResponse(new GuildForumDataComposer(guild, this.client.getHabbo()));

Emulator/src/main/java/com/eu/habbo/messages/incoming/handshake/MachineIDEvent.java

@@ -1,5 +1,6 @@
 package com.eu.habbo.messages.incoming.handshake;
 
+import com.eu.habbo.Emulator;
 import com.eu.habbo.messages.NoAuthMessage;
 import com.eu.habbo.messages.incoming.MessageHandler;
 import org.slf4j.Logger;
@@ -24,6 +25,15 @@ public class MachineIDEvent extends MessageHandler {
 
         this.client.setMachineId(storedMachineId);
 
+        // Persist the machine fingerprint onto the user so machine/super bans can
+        // target it (createOfflineUserBan copies users.machine_id). The Nitro client
+        // sends this UniqueID packet right after the SSO ticket, so the Habbo is
+        // normally already loaded by the time we get here.
+        if (!storedMachineId.isEmpty() && this.client.getHabbo() != null && this.client.getHabbo().getHabboInfo() != null) {
+            this.client.getHabbo().getHabboInfo().setMachineID(storedMachineId);
+            Emulator.getThreading().run(this.client.getHabbo());
+        }
+
         LOGGER.debug("Setting client MachineId to {}", storedMachineId);
     }
 }

Emulator/src/main/java/com/eu/habbo/messages/incoming/handshake/SecureLoginEvent.java

@@ -133,17 +133,10 @@ public class SecureLoginEvent extends MessageHandler {
                 this.client.setHabbo(habbo);
                 this.client.setMachineId(habbo.getHabboInfo().getMachineID());
 
-                // Clear the SSO ticket now that session is resumed (prevent reuse)
-                if (!Emulator.debugging) {
-                    try (java.sql.Connection conn = Emulator.getDatabase().getDataSource().getConnection();
-                         java.sql.PreparedStatement stmt = conn.prepareStatement("UPDATE users SET auth_ticket = ? WHERE id = ? LIMIT 1")) {
-                        stmt.setString(1, "");
-                        stmt.setInt(2, habbo.getHabboInfo().getId());
-                        stmt.execute();
-                    } catch (Exception e) {
-                        LOGGER.error("Failed to clear SSO ticket after session resume", e);
-                    }
-                }
+                // NB: NON svuotiamo il ticket SSO qui (vedi HabboManager.loadHabbo):
+                // dietro Cloudflare il client ritenta la connessione con lo stesso
+                // ticket, quindi deve restare valido fino alla scadenza TTL. Consumarlo
+                // farebbe fallire i retry / l'hard-refresh con "non-existing SSO token".
             } else {
                 // Normal login — load from database
                 habbo = Emulator.getGameEnvironment().getHabboManager().loadHabbo(sso);
@@ -168,6 +161,12 @@ public class SecureLoginEvent extends MessageHandler {
                             throw new NullPointerException(habbo.getHabboInfo().getUsername() + " has a NON EXISTING RANK!");
                         }
 
+                        // If the machine fingerprint already arrived (UniqueID before login),
+                        // persist it so machine/super bans can target this user.
+                        if (this.client.getMachineId() != null && !this.client.getMachineId().isEmpty()) {
+                            this.client.getHabbo().getHabboInfo().setMachineID(this.client.getMachineId());
+                        }
+
                         Emulator.getThreading().run(habbo);
                         Emulator.getGameEnvironment().getHabboManager().addHabbo(habbo);
                     } catch (Exception e) {

Emulator/src/main/java/com/eu/habbo/messages/incoming/inventory/prefixes/DeletePrefixEvent.java

@@ -6,6 +6,11 @@ import com.eu.habbo.messages.incoming.MessageHandler;
 import com.eu.habbo.messages.outgoing.inventory.prefixes.UserPrefixesComposer;
 
 public class DeletePrefixEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 500;
+    }
+
     @Override
     public void handle() throws Exception {
         int prefixId = this.packet.readInt();

Emulator/src/main/java/com/eu/habbo/messages/incoming/inventory/prefixes/PurchasePrefixEvent.java

@@ -1,15 +1,20 @@
 package com.eu.habbo.messages.incoming.inventory.prefixes;
 
 import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.modtool.WordFilterWord;
 import com.eu.habbo.habbohotel.users.Habbo;
 import com.eu.habbo.habbohotel.users.UserPrefix;
 import com.eu.habbo.messages.incoming.MessageHandler;
-import com.eu.habbo.messages.outgoing.generic.alerts.BubbleAlertKeys;
 import com.eu.habbo.messages.outgoing.generic.alerts.BubbleAlertComposer;
+import com.eu.habbo.messages.outgoing.generic.alerts.BubbleAlertKeys;
 import com.eu.habbo.messages.outgoing.inventory.nickicons.UserNickIconsComposer;
+import com.eu.habbo.messages.outgoing.inventory.prefixes.ActivePrefixUpdatedComposer;
+import com.eu.habbo.messages.outgoing.inventory.prefixes.CustomPrefixPurchaseFailedComposer;
 import com.eu.habbo.messages.outgoing.inventory.prefixes.PrefixReceivedComposer;
+import com.eu.habbo.messages.outgoing.rooms.users.RoomUserDataComposer;
 import com.eu.habbo.messages.outgoing.users.UserCreditsComposer;
 import com.eu.habbo.messages.outgoing.users.UserCurrencyComposer;
+import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -17,10 +22,18 @@ import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
 
 public class PurchasePrefixEvent extends MessageHandler {
     private static final Logger LOGGER = LoggerFactory.getLogger(PurchasePrefixEvent.class);
     private static final String[] ALLOWED_FONTS = { "", "pixel", "cherry", "vampiro" };
+    private static final String[] ALLOWED_EFFECTS = {
+            "", "glow", "shadow", "italic", "outline", "underline", "pulse", "bounce", "wave", "shake",
+            "discord-neon", "cartoon", "toon", "pop", "bold-glow", "rainbow", "frost", "gold", "glitch",
+            "fire", "matrix", "sparkle"
+    };
+    private static final int MAX_ICON_LENGTH = 16;
 
     @Override
     public int getRatelimit() {
@@ -39,81 +52,101 @@ public class PurchasePrefixEvent extends MessageHandler {
 
         if (habbo == null) return;
 
-        // Load settings
-        int maxLength = getSettingInt("max_length", 15);
-        int minRank = getSettingInt("min_rank_to_buy", 1);
-        int priceCredits = getSettingInt("price_credits", 5);
-        int pricePoints = getSettingInt("price_points", 0);
-        int pointsType = getSettingInt("points_type", 0);
-        int fontPriceCredits = getSettingInt("font_price_credits", 10);
-        int fontPricePoints = getSettingInt("font_price_points", 0);
-        int fontPointsType = getSettingInt("font_points_type", pointsType);
+        Map<String, Integer> settings = loadSettings();
+        int maxLength = setting(settings, "max_length", 15);
+        int minRank = setting(settings, "min_rank_to_buy", 1);
+        int priceCredits = setting(settings, "price_credits", 5);
+        int pricePoints = setting(settings, "price_points", 0);
+        int pointsType = setting(settings, "points_type", 0);
+        int fontPriceCredits = setting(settings, "font_price_credits", 10);
+        int fontPricePoints = setting(settings, "font_price_points", 0);
+        int fontPointsType = setting(settings, "font_points_type", pointsType);
+        int maxPrefixes = setting(settings, "max_prefixes", 60);
 
-        // Validate text
-        text = text.trim();
-
-        if (text.isEmpty() || text.length() > maxLength) {
-            this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FURNITURE_PLACEMENT_ERROR.key, "Prefix text is invalid or too long (max " + maxLength + " characters)."));
+        if (maxPrefixes > 0 && habbo.getInventory().getPrefixesComponent().getPrefixes().size() >= maxPrefixes) {
+            this.fail(habbo, "You already own the maximum number of prefixes (" + maxPrefixes + ").");
+            return;
+        }
+
+        text = text.trim();
+
+        if (text.isEmpty() || text.length() > maxLength) {
+            this.fail(habbo, "Prefix text is invalid or too long (max " + maxLength + " characters).");
+            return;
+        }
+
+        if (containsControlChars(text)) {
+            this.fail(habbo, "Prefix text contains invalid characters.");
+            return;
+        }
+
+        if (containsFilteredWord(text)) {
+            this.fail(habbo, "This prefix contains a blocked word.");
             return;
         }
 
-        // Validate color (single hex or comma-separated multi hex for per-letter colors)
         String[] colorParts = color.split(",");
+
+        if (colorParts.length > text.length()) {
+            this.fail(habbo, "Invalid color format.");
+            return;
+        }
+
         for (String part : colorParts) {
             if (!part.matches("^#[0-9A-Fa-f]{6}$")) {
-                this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FURNITURE_PLACEMENT_ERROR.key, "Invalid color format."));
+                this.fail(habbo, "Invalid color format.");
                 return;
             }
         }
 
-        // Check rank
         if (habbo.getHabboInfo().getRank().getId() < minRank) {
-            this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FURNITURE_PLACEMENT_ERROR.key, "Your rank is too low to purchase prefixes."));
-            return;
-        }
-
-        // Check blacklist
-        if (isBlacklisted(text)) {
-            this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FURNITURE_PLACEMENT_ERROR.key, "This prefix contains a blocked word."));
+            this.fail(habbo, "Your rank is too low to purchase prefixes.");
             return;
         }
 
         if (icon == null) icon = "";
         icon = icon.trim();
 
+        if (!isValidIcon(icon)) {
+            this.fail(habbo, "Invalid prefix icon.");
+            return;
+        }
+
         if (effect == null) effect = "";
-        effect = effect.trim();
+        effect = effect.trim().toLowerCase();
+
+        if (!isAllowedEffect(effect)) {
+            this.fail(habbo, "Invalid prefix effect.");
+            return;
+        }
 
         if (font == null) font = "";
         font = font.trim().toLowerCase();
 
         if (!isAllowedFont(font)) {
-            this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FURNITURE_PLACEMENT_ERROR.key, "Invalid font format."));
+            this.fail(habbo, "Invalid font format.");
             return;
         }
 
         int totalPriceCredits = priceCredits + (!font.isEmpty() ? fontPriceCredits : 0);
 
-        // Check credits
         if (totalPriceCredits > 0 && habbo.getHabboInfo().getCredits() < totalPriceCredits) {
-            this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FURNITURE_PLACEMENT_ERROR.key, "Not enough credits."));
+            this.fail(habbo, "Not enough credits.");
             return;
         }
 
         int totalPricePointsSameType = pricePoints + ((fontPricePoints > 0 && fontPointsType == pointsType && !font.isEmpty()) ? fontPricePoints : 0);
 
-        // Check points
         if (totalPricePointsSameType > 0 && habbo.getHabboInfo().getCurrencyAmount(pointsType) < totalPricePointsSameType) {
-            this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FURNITURE_PLACEMENT_ERROR.key, "Not enough points."));
+            this.fail(habbo, "Not enough points.");
             return;
         }
 
         if (!font.isEmpty() && fontPricePoints > 0 && fontPointsType != pointsType && habbo.getHabboInfo().getCurrencyAmount(fontPointsType) < fontPricePoints) {
-            this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FURNITURE_PLACEMENT_ERROR.key, "Not enough points."));
+            this.fail(habbo, "Not enough points.");
             return;
         }
 
-        // Deduct currency
         if (totalPriceCredits > 0) {
             habbo.getHabboInfo().addCredits(-totalPriceCredits);
             this.client.sendResponse(new UserCreditsComposer(habbo));
@@ -129,47 +162,57 @@ public class PurchasePrefixEvent extends MessageHandler {
             this.client.sendResponse(new UserCurrencyComposer(habbo));
         }
 
-        // Create prefix
         int storedPoints = totalPricePointsSameType;
         int storedPointsType = (storedPoints > 0) ? pointsType : ((!font.isEmpty() && fontPricePoints > 0) ? fontPointsType : pointsType);
 
         UserPrefix prefix = new UserPrefix(habbo.getHabboInfo().getId(), text, color, icon, effect, font, 0, text, storedPoints, storedPointsType, true);
         prefix.run(); // Insert into DB synchronously to get the ID
         habbo.getInventory().getPrefixesComponent().addPrefix(prefix);
-
+        habbo.getInventory().getPrefixesComponent().setActive(prefix.getId());
         this.client.sendResponse(new PrefixReceivedComposer(prefix));
+        this.client.sendResponse(new ActivePrefixUpdatedComposer(prefix));
         this.client.sendResponse(new UserNickIconsComposer(habbo));
-    }
 
-    private int getSettingInt(String key, int defaultValue) {
-        try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
-             PreparedStatement statement = connection.prepareStatement("SELECT `value` FROM custom_prefix_settings WHERE key_name = ?")) {
-            statement.setString(1, key);
-            try (ResultSet set = statement.executeQuery()) {
-                if (set.next()) {
-                    return Integer.parseInt(set.getString("value"));
-                }
-            }
-        } catch (SQLException | NumberFormatException e) {
-            LOGGER.error("Error reading prefix setting: " + key, e);
+        if (habbo.getHabboInfo().getCurrentRoom() != null) {
+            habbo.getHabboInfo().getCurrentRoom().sendComposer(new RoomUserDataComposer(habbo).compose());
         }
-        return defaultValue;
     }
 
-    private boolean isBlacklisted(String text) {
-        String lowerText = text.toLowerCase();
+    private void fail(Habbo habbo, String message) {
+        this.client.sendResponse(new BubbleAlertComposer(BubbleAlertKeys.FURNITURE_PLACEMENT_ERROR.key, message));
+        this.client.sendResponse(new CustomPrefixPurchaseFailedComposer(message));
+    }
+
+    private Map<String, Integer> loadSettings() {
+        Map<String, Integer> settings = new HashMap<>();
         try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
-             PreparedStatement statement = connection.prepareStatement("SELECT word FROM custom_prefix_blacklist")) {
-            try (ResultSet set = statement.executeQuery()) {
-                while (set.next()) {
-                    if (lowerText.contains(set.getString("word").toLowerCase())) {
-                        return true;
-                    }
-                }
+             PreparedStatement statement = connection.prepareStatement("SELECT key_name, `value` FROM custom_prefix_settings");
+             ResultSet set = statement.executeQuery()) {
+            while (set.next()) {
+                try {
+                    settings.put(set.getString("key_name"), Integer.parseInt(set.getString("value")));
+                } catch (NumberFormatException ignored) {}
             }
         } catch (SQLException e) {
-            LOGGER.error("Error checking prefix blacklist", e);
+            LOGGER.error("Error reading prefix settings", e);
         }
+        return settings;
+    }
+
+    private int setting(Map<String, Integer> settings, String key, int defaultValue) {
+        Integer value = settings.get(key);
+        return value != null ? value : defaultValue;
+    }
+
+    private boolean containsFilteredWord(String text) {
+        if (text == null || text.isEmpty()) return false;
+
+        for (WordFilterWord word : Emulator.getGameEnvironment().getWordFilter().getWords()) {
+            if (word.key != null && !word.key.isEmpty() && StringUtils.containsIgnoreCase(text, word.key)) {
+                return true;
+            }
+        }
+
         return false;
     }
 
@@ -182,4 +225,35 @@ public class PurchasePrefixEvent extends MessageHandler {
 
         return false;
     }
+
+    private boolean isAllowedEffect(String effect) {
+        for (String allowedEffect : ALLOWED_EFFECTS) {
+            if (allowedEffect.equals(effect)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private boolean isValidIcon(String icon) {
+        if (icon.isEmpty()) return true;
+        if (icon.length() > MAX_ICON_LENGTH) return false;
+
+        for (int i = 0; i < icon.length(); i++) {
+            char c = icon.charAt(i);
+            if (c < 0x20 || c == 0x7F || c == '<' || c == '>') return false;
+        }
+
+        return true;
+    }
+
+    private boolean containsControlChars(String text) {
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c < 0x20 || c == 0x7F) return true;
+        }
+
+        return false;
+    }
 }

Emulator/src/main/java/com/eu/habbo/messages/incoming/inventory/prefixes/RequestUserPrefixesEvent.java

@@ -4,6 +4,11 @@ import com.eu.habbo.messages.incoming.MessageHandler;
 import com.eu.habbo.messages.outgoing.inventory.prefixes.UserPrefixesComposer;
 
 public class RequestUserPrefixesEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 500;
+    }
+
     @Override
     public void handle() throws Exception {
         this.client.sendResponse(new UserPrefixesComposer(this.client.getHabbo()));

Emulator/src/main/java/com/eu/habbo/messages/incoming/inventory/prefixes/SetActivePrefixEvent.java

@@ -2,11 +2,16 @@ package com.eu.habbo.messages.incoming.inventory.prefixes;
 
 import com.eu.habbo.habbohotel.users.UserPrefix;
 import com.eu.habbo.messages.incoming.MessageHandler;
-import com.eu.habbo.messages.outgoing.inventory.prefixes.ActivePrefixUpdatedComposer;
 import com.eu.habbo.messages.outgoing.inventory.nickicons.UserNickIconsComposer;
+import com.eu.habbo.messages.outgoing.inventory.prefixes.ActivePrefixUpdatedComposer;
 import com.eu.habbo.messages.outgoing.rooms.users.RoomUserDataComposer;
 
 public class SetActivePrefixEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
     @Override
     public void handle() throws Exception {
         int prefixId = this.packet.readInt();

Emulator/src/main/java/com/eu/habbo/messages/incoming/inventory/prefixes/SetDisplayOrderEvent.java

@@ -7,6 +7,11 @@ import com.eu.habbo.messages.outgoing.inventory.nickicons.UserNickIconsComposer;
 import com.eu.habbo.messages.outgoing.rooms.users.RoomUserDataComposer;
 
 public class SetDisplayOrderEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 1000;
+    }
+
     @Override
     public void handle() throws Exception {
         Habbo habbo = this.client.getHabbo();
@@ -23,4 +28,4 @@ public class SetDisplayOrderEvent extends MessageHandler {
             habbo.getHabboInfo().getCurrentRoom().sendComposer(new RoomUserDataComposer(habbo).compose());
         }
     }
-}
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/mentions/DeleteMentionEvent.java

@@ -0,0 +1,27 @@
+package com.eu.habbo.messages.incoming.mentions;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.mentions.MentionManager;
+import com.eu.habbo.messages.incoming.MessageHandler;
+
+public class DeleteMentionEvent extends MessageHandler {
+    @Override
+    public void handle() throws Exception {
+        if (this.client == null || this.client.getHabbo() == null) return;
+
+        int userId = this.client.getHabbo().getHabboInfo().getId();
+        int mentionId = this.packet.readInt();
+
+        if (mentionId <= 0) {
+            return;
+        }
+
+        MentionManager manager = Emulator.getGameEnvironment().getMentionManager();
+
+        if (!manager.tryAcquireDelete(userId)) {
+            return;
+        }
+
+        manager.delete(userId, mentionId);
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/mentions/MarkMentionsReadEvent.java

@@ -0,0 +1,35 @@
+package com.eu.habbo.messages.incoming.mentions;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.mentions.MentionManager;
+import com.eu.habbo.messages.incoming.MessageHandler;
+
+public class MarkMentionsReadEvent extends MessageHandler {
+    @Override
+    public void handle() throws Exception {
+        if (this.client == null || this.client.getHabbo() == null) return;
+
+        int userId = this.client.getHabbo().getHabboInfo().getId();
+        int mode = this.packet.readInt();
+        int mentionId = this.packet.readInt();
+
+        // Only mode 0 (mark-all) and mode 1 (mark-single) are valid. Reject
+        // anything else so a crafted packet can't fall into the mark-all branch
+        // by accident.
+        if (mode != 0 && mode != 1) {
+            return;
+        }
+
+        if (mode == 1 && mentionId <= 0) {
+            return;
+        }
+
+        MentionManager manager = Emulator.getGameEnvironment().getMentionManager();
+
+        if (!manager.tryAcquireMarkRead(userId, mode)) {
+            return;
+        }
+
+        manager.markRead(userId, mode, mentionId);
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/incoming/mentions/RequestMentionsEvent.java

@@ -0,0 +1,29 @@
+package com.eu.habbo.messages.incoming.mentions;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.mentions.HabboMention;
+import com.eu.habbo.habbohotel.mentions.MentionManager;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.mentions.MentionsListComposer;
+
+import java.util.List;
+
+public class RequestMentionsEvent extends MessageHandler {
+    @Override
+    public void handle() throws Exception {
+        if (this.client == null || this.client.getHabbo() == null) return;
+
+        int userId = this.client.getHabbo().getHabboInfo().getId();
+
+        MentionManager manager = Emulator.getGameEnvironment().getMentionManager();
+
+        if (!manager.tryAcquireRequestList(userId)) {
+            return;
+        }
+
+        int limit = Emulator.getConfig().getInt("mentions.store.limit", 50);
+
+        List<HabboMention> mentions = manager.getMentions(userId, limit);
+        this.client.sendResponse(new MentionsListComposer(mentions));
+    }
+}

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

@@ -0,0 +1,27 @@
+package com.eu.habbo.messages.incoming.rarevalues;
+
+import com.eu.habbo.Emulator;
+import com.eu.habbo.habbohotel.catalog.CatalogManager;
+import com.eu.habbo.messages.incoming.MessageHandler;
+import com.eu.habbo.messages.outgoing.rarevalues.RareValuesComposer;
+
+public class RequestRareValuesEvent extends MessageHandler {
+    @Override
+    public int getRatelimit() {
+        return 5000;
+    }
+
+    @Override
+    public void handle() throws Exception {
+        if (this.client.getHabbo() == null) return;
+
+        CatalogManager catalog = Emulator.getGameEnvironment().getCatalogManager();
+        byte[] snapshot = catalog.getRareValuesPayloadSnapshot();
+        if (snapshot != null) {
+            this.client.sendResponse(new RareValuesComposer(snapshot));
+            return;
+        }
+
+        this.client.sendResponse(new RareValuesComposer(catalog.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,16 +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;
-
-            if (bot.getOwnerActionIds().length == 0)
-                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:
@@ -163,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/rooms/users/RoomUserShoutEvent.java

@@ -34,6 +34,9 @@ public class RoomUserShoutEvent extends MessageHandler {
                 if (RoomChatMessage.SAVE_ROOM_CHATS) {
                     Emulator.getThreading().run(message);
                 }
+
+                Emulator.getGameEnvironment().getMentionManager()
+                    .process(this.client.getHabbo(), this.client.getHabbo().getHabboInfo().getCurrentRoom(), message.getMessage(), RoomChatType.SHOUT);
             }
         } else {
             String reportMessage = Emulator.getTexts().getValue("scripter.warning.chat.length").replace("%username%", this.client.getHabbo().getHabboInfo().getUsername()).replace("%length%", message.getMessage().length() + "");

Emulator/src/main/java/com/eu/habbo/messages/incoming/rooms/users/RoomUserTalkEvent.java

@@ -36,6 +36,9 @@ public class RoomUserTalkEvent extends MessageHandler {
                 if (RoomChatMessage.SAVE_ROOM_CHATS) {
                     Emulator.getThreading().run(message);
                 }
+
+                Emulator.getGameEnvironment().getMentionManager()
+                    .process(this.client.getHabbo(), room, message.getMessage(), RoomChatType.TALK);
             }
         } else {
             String reportMessage = Emulator.getTexts().getValue("scripter.warning.chat.length").replace("%username%", this.client.getHabbo().getHabboInfo().getUsername()).replace("%length%", message.getMessage().length() + "");

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,57 @@
+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;
+
+import java.util.HashSet;
+import java.util.Set;
+
+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;
+
+        // The client sends the full authoritative list of prizes in display
+        // order. id <= 0 means "insert a new prize"; any existing prize whose
+        // id is absent from this list was removed in the editor and gets
+        // soft-disabled below.
+        Set<Integer> keptIds = new HashSet<>();
+
+        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();
+            int savedId = wheel.savePrize(id, type, value, amount, pointsType, weight, label, i);
+            if (savedId > 0) keptIds.add(savedId);
+        }
+
+        wheel.disablePrizesNotIn(keptIds);
+        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

@@ -579,6 +579,7 @@ public class Outgoing {
     public static final int PrefixReceivedComposer = 7002;
     public static final int ActivePrefixUpdatedComposer = 7003;
     public static final int UserNickIconsComposer = 7004;
+    public static final int CustomPrefixPurchaseFailedComposer = 7005;
     public static final int AvailableCommandsComposer = 4050;
 
     // YouTube Room Broadcast
@@ -594,4 +595,15 @@ public class Outgoing {
     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;
+    public static final int MentionReceivedComposer = 4801;
+    public static final int MentionsListComposer = 4802;
+
 }

Emulator/src/main/java/com/eu/habbo/messages/outgoing/inventory/prefixes/CustomPrefixPurchaseFailedComposer.java

@@ -0,0 +1,20 @@
+package com.eu.habbo.messages.outgoing.inventory.prefixes;
+
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+public class CustomPrefixPurchaseFailedComposer extends MessageComposer {
+    private final String message;
+
+    public CustomPrefixPurchaseFailedComposer(String message) {
+        this.message = message != null ? message : "";
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.CustomPrefixPurchaseFailedComposer);
+        this.response.appendString(this.message);
+        return this.response;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/mentions/MentionReceivedComposer.java

@@ -0,0 +1,28 @@
+package com.eu.habbo.messages.outgoing.mentions;
+
+import com.eu.habbo.habbohotel.mentions.HabboMention;
+import com.eu.habbo.messages.ServerMessage;
+import com.eu.habbo.messages.outgoing.MessageComposer;
+import com.eu.habbo.messages.outgoing.Outgoing;
+
+public class MentionReceivedComposer extends MessageComposer {
+    private final HabboMention mention;
+
+    public MentionReceivedComposer(HabboMention mention) {
+        this.mention = mention;
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.MentionReceivedComposer);
+        this.response.appendInt(this.mention.getId());
+        this.response.appendInt(this.mention.getSenderUserId());
+        this.response.appendString(this.mention.getSenderUsername());
+        this.response.appendInt(this.mention.getRoomId());
+        this.response.appendString(this.mention.getRoomName());
+        this.response.appendString(this.mention.getMessage());
+        this.response.appendInt(this.mention.getMentionType());
+        this.response.appendInt(this.mention.getTimestamp());
+        return this.response;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/outgoing/mentions/MentionsListComposer.java

@@ -0,0 +1,36 @@
+package com.eu.habbo.messages.outgoing.mentions;
+
+import com.eu.habbo.habbohotel.mentions.HabboMention;
+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 MentionsListComposer extends MessageComposer {
+    private final List<HabboMention> mentions;
+
+    public MentionsListComposer(List<HabboMention> mentions) {
+        this.mentions = mentions;
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.MentionsListComposer);
+        this.response.appendInt(this.mentions.size());
+
+        for (HabboMention mention : this.mentions) {
+            this.response.appendInt(mention.getId());
+            this.response.appendInt(mention.getSenderUserId());
+            this.response.appendString(mention.getSenderUsername());
+            this.response.appendInt(mention.getRoomId());
+            this.response.appendString(mention.getRoomName());
+            this.response.appendString(mention.getMessage());
+            this.response.appendInt(mention.getMentionType());
+            this.response.appendInt(mention.getTimestamp());
+            this.response.appendBoolean(mention.isRead());
+        }
+
+        return this.response;
+    }
+}

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

@@ -0,0 +1,46 @@
+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;
+
+public class RareValuesComposer extends MessageComposer {
+    private final TIntObjectMap<int[]> values;
+    private final byte[] snapshot;
+
+    public RareValuesComposer(byte[] snapshot) {
+        this.values = null;
+        this.snapshot = snapshot;
+    }
+
+    public RareValuesComposer(TIntObjectMap<int[]> values) {
+        this.values = values;
+        this.snapshot = null;
+    }
+
+    @Override
+    protected ServerMessage composeInternal() {
+        this.response.init(Outgoing.RareValuesComposer);
+
+        if (this.snapshot != null) {
+            this.response.appendRawBytes(this.snapshot);
+            return this.response;
+        }
+
+        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/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;
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/rcon/UpdateSoundboard.java

@@ -0,0 +1,21 @@
+package com.eu.habbo.messages.rcon;
+
+import com.eu.habbo.Emulator;
+import com.google.gson.Gson;
+
+// Ricarica i suoni della Soundboard dal DB (live), così i suoni aggiunti/caricati
+// dal CMS (/admin/soundboard) si applicano senza riavviare l'emulatore.
+public class UpdateSoundboard extends RCONMessage<UpdateSoundboard.SoundboardJSON> {
+
+    public UpdateSoundboard() {
+        super(SoundboardJSON.class);
+    }
+
+    @Override
+    public void handle(Gson gson, SoundboardJSON object) {
+        Emulator.getGameEnvironment().getSoundboardManager().reload();
+    }
+
+    static class SoundboardJSON {
+    }
+}

Emulator/src/main/java/com/eu/habbo/messages/rcon/UpdateWheel.java

@@ -0,0 +1,21 @@
+package com.eu.habbo.messages.rcon;
+
+import com.eu.habbo.Emulator;
+import com.google.gson.Gson;
+
+// Ricarica i premi/settings della Ruota della Fortuna dal DB (live), così le
+// modifiche fatte dal CMS (/admin/wheel) si applicano senza riavviare l'emulatore.
+public class UpdateWheel extends RCONMessage<UpdateWheel.WheelJSON> {
+
+    public UpdateWheel() {
+        super(WheelJSON.class);
+    }
+
+    @Override
+    public void handle(Gson gson, WheelJSON object) {
+        Emulator.getGameEnvironment().getWheelManager().reload();
+    }
+
+    static class WheelJSON {
+    }
+}

Emulator/src/main/java/com/eu/habbo/networking/gameserver/decoders/GameMessageHandler.java

@@ -11,6 +11,7 @@ import io.netty.handler.codec.DecoderException;
 import io.netty.handler.codec.TooLongFrameException;
 import io.netty.handler.codec.UnsupportedMessageTypeException;
 import io.netty.handler.ssl.NotSslRecordException;
+import io.netty.util.ReferenceCountUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -39,6 +40,19 @@ public class GameMessageHandler extends ChannelInboundHandlerAdapter {
 
     @Override
     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        if (!(msg instanceof ClientMessage)) {
+            try {
+                if (Emulator.getConfig().getBoolean("debug.mode")) {
+                    LOGGER.debug("Discarding non-game message {} from {}",
+                            msg.getClass().getSimpleName(), ctx.channel().remoteAddress());
+                }
+            } finally {
+                ReferenceCountUtil.release(msg);
+                ctx.channel().close();
+            }
+            return;
+        }
+
         ClientMessage message = (ClientMessage) msg;
 
         try {

Emulator/src/main/java/com/eu/habbo/networking/rconserver/RCONServer.java

@@ -45,6 +45,8 @@ public class RCONServer extends Server {
         this.addRCONMessage("sendroombundle", SendRoomBundle.class);
         this.addRCONMessage("setrank", SetRank.class);
         this.addRCONMessage("updatewordfilter", UpdateWordfilter.class);
+        this.addRCONMessage("updatewheel", UpdateWheel.class);
+        this.addRCONMessage("updatesoundboard", UpdateSoundboard.class);
         this.addRCONMessage("updatecatalog", UpdateCatalog.class);
         this.addRCONMessage("executecommand", ExecuteCommand.class);
         this.addRCONMessage("progressachievement", ProgressAchievement.class);