Merge pull request #19 from Lorenzune/pr/wired-reward-mute-fixes-20260318

fix(wired): improve rewards and room mute feedback

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

@@ -29,7 +29,7 @@ public class UnmuteCommand extends Command {
                 }
 
                 if (habbo.getHabboInfo().getCurrentRoom() != null && habbo.getHabboInfo().getCurrentRoom().isMuted(habbo)) {
-                    habbo.getHabboInfo().getCurrentRoom().muteHabbo(habbo, 1);
+                    habbo.getHabboInfo().getCurrentRoom().unmuteHabbo(habbo);
                 }
 
                 gameClient.getHabbo().whisper(Emulator.getTexts().getValue("commands.succes.cmd_unmute").replace("%user%", params[1]), RoomChatMessageBubbles.ALERT);

Emulator/src/main/java/com/eu/habbo/habbohotel/items/interactions/wired/effects/WiredEffectGiveReward.java

@@ -140,15 +140,6 @@ public class WiredEffectGiveReward extends InteractionWiredEffect {
         return type;
     }
 
-    @Override
-    public void onClick(GameClient client, Room room, Object[] objects) throws Exception {
-        super.onClick(client, room, objects);
-
-        if (client.getHabbo().hasPermission(Permission.ACC_SUPERWIRED)) {
-            client.getHabbo().whisper(Emulator.getTexts().getValue("hotel.wired.superwired.info"), RoomChatMessageBubbles.BOT);
-        }
-    }
-
     @Override
     public void serializeWiredData(ServerMessage message, Room room) {
         message.appendBoolean(false);

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

@@ -1874,11 +1874,15 @@ public class Room implements Comparable<Room>, ISerialize, Runnable {
   }
 
   public void muteHabbo(Habbo habbo, int minutes) {
-    this.rightsManager.muteHabbo(habbo, minutes);
+    this.chatManager.muteHabbo(habbo, minutes);
+  }
+
+  public void unmuteHabbo(Habbo habbo) {
+    this.chatManager.unmuteHabbo(habbo);
   }
 
   public boolean isMuted(Habbo habbo) {
-    return this.rightsManager.isMuted(habbo);
+    return this.chatManager.isMuted(habbo);
   }
 
   public void habboEntered(Habbo habbo) {

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

@@ -156,6 +156,15 @@ public class RoomChatManager {
         }
     }
 
+    /**
+     * Removes a room mute from a Habbo.
+     */
+    public void unmuteHabbo(Habbo habbo) {
+        synchronized (this.mutedHabbos) {
+            this.mutedHabbos.remove(habbo.getHabboInfo().getId());
+        }
+    }
+
     /**
      * Checks if a Habbo is muted.
      */
@@ -183,7 +192,8 @@ public class RoomChatManager {
      */
     public int getMuteTimeRemaining(Habbo habbo) {
         if (this.mutedHabbos.containsKey(habbo.getHabboInfo().getId())) {
-            return this.mutedHabbos.get(habbo.getHabboInfo().getId()) - Emulator.getIntUnixTimestamp();
+            return Math.max(0,
+                this.mutedHabbos.get(habbo.getHabboInfo().getId()) - Emulator.getIntUnixTimestamp());
         }
         return 0;
     }
@@ -298,7 +308,7 @@ public class RoomChatManager {
 
             if (this.isMuted(habbo)) {
                 habbo.getClient().sendResponse(new MutedWhisperComposer(
-                    this.mutedHabbos.get(habbo.getHabboInfo().getId()) - Emulator.getIntUnixTimestamp()));
+                    Math.max(1, this.getMuteTimeRemaining(habbo))));
                 return;
             }
         }

Emulator/src/main/java/com/eu/habbo/habbohotel/wired/WiredHandler.java

@@ -285,53 +285,72 @@ public class WiredHandler {
         }
     }
 
-    private static void giveReward(Habbo habbo, WiredEffectGiveReward wiredBox, WiredGiveRewardItem reward) {
+    private static void persistReward(int wiredId, int habboId, int rewardId, int timestamp) {
-        if (wiredBox.limit > 0)
-            wiredBox.given++;
-
         try (Connection connection = Emulator.getDatabase().getDataSource().getConnection(); PreparedStatement statement = connection.prepareStatement("INSERT INTO wired_rewards_given (wired_item, user_id, reward_id, timestamp) VALUES ( ?, ?, ?, ?)")) {
-            statement.setInt(1, wiredBox.getId());
+            statement.setInt(1, wiredId);
-            statement.setInt(2, habbo.getHabboInfo().getId());
+            statement.setInt(2, habboId);
-            statement.setInt(3, reward.id);
+            statement.setInt(3, rewardId);
-            statement.setInt(4, Emulator.getIntUnixTimestamp());
+            statement.setInt(4, timestamp);
             statement.execute();
         } catch (SQLException e) {
             LOGGER.error("Caught SQL exception", e);
         }
+    }
 
+    private static void completeReward(Habbo habbo, WiredEffectGiveReward wiredBox, WiredGiveRewardItem reward, int successCode) {
+        if (wiredBox.limit > 0)
+            wiredBox.given++;
+
+        persistReward(wiredBox.getId(), habbo.getHabboInfo().getId(), reward.id, Emulator.getIntUnixTimestamp());
+        habbo.getClient().sendResponse(new WiredRewardAlertComposer(successCode));
+    }
+
+    private static boolean giveReward(Habbo habbo, WiredEffectGiveReward wiredBox, WiredGiveRewardItem reward) {
         if (reward.badge) {
             UserWiredRewardReceived rewardReceived = new UserWiredRewardReceived(habbo, wiredBox, "badge", reward.data);
             if (Emulator.getPluginManager().fireEvent(rewardReceived).isCancelled())
-                return;
+                return false;
 
             if (rewardReceived.value.isEmpty())
-                return;
+                return false;
             
-            if (habbo.getInventory().getBadgesComponent().hasBadge(rewardReceived.value))
+            if (habbo.getInventory().getBadgesComponent().hasBadge(rewardReceived.value)) {
-                return;
+                habbo.getClient().sendResponse(new WiredRewardAlertComposer(WiredRewardAlertComposer.REWARD_ALREADY_RECEIVED));
+                return false;
+            }
 
             HabboBadge badge = new HabboBadge(0, rewardReceived.value, 0, habbo);
             Emulator.getThreading().run(badge);
             habbo.getInventory().getBadgesComponent().addBadge(badge);
             habbo.getClient().sendResponse(new AddUserBadgeComposer(badge));
-            habbo.getClient().sendResponse(new WiredRewardAlertComposer(WiredRewardAlertComposer.REWARD_RECEIVED_BADGE));
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_BADGE);
-        } else {
+            return true;
+        }
+
         String[] data = reward.data.split("#");
 
-            if (data.length == 2) {
+        if (data.length != 2)
+            return false;
+
         UserWiredRewardReceived rewardReceived = new UserWiredRewardReceived(habbo, wiredBox, data[0], data[1]);
         if (Emulator.getPluginManager().fireEvent(rewardReceived).isCancelled())
-                    return;
+            return false;
 
         if (rewardReceived.value.isEmpty())
-                    return;
+            return false;
 
         if (rewardReceived.type.equalsIgnoreCase("credits")) {
-                    int credits = Integer.parseInt(rewardReceived.value);
+            habbo.giveCredits(Integer.parseInt(rewardReceived.value));
-                    habbo.giveCredits(credits);
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
+            return true;
+        } else if (rewardReceived.type.equalsIgnoreCase("diamonds") || rewardReceived.type.equalsIgnoreCase("diamond")) {
+            habbo.givePoints(5, Integer.parseInt(rewardReceived.value));
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
+            return true;
         } else if (rewardReceived.type.equalsIgnoreCase("pixels")) {
-                    int pixels = Integer.parseInt(rewardReceived.value);
+            habbo.givePixels(Integer.parseInt(rewardReceived.value));
-                    habbo.givePixels(pixels);
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
+            return true;
         } else if (rewardReceived.type.startsWith("points")) {
             int points = Integer.parseInt(rewardReceived.value);
             int type = 5;
@@ -342,31 +361,39 @@ public class WiredHandler {
             }
 
             habbo.givePoints(type, points);
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
+            return true;
         } else if (rewardReceived.type.equalsIgnoreCase("furni")) {
             Item baseItem = Emulator.getGameEnvironment().getItemManager().getItem(Integer.parseInt(rewardReceived.value));
-                    if (baseItem != null) {
+            if (baseItem == null)
-                        HabboItem item = Emulator.getGameEnvironment().getItemManager().createItem(habbo.getHabboInfo().getId(), baseItem, 0, 0, "");
+                return false;
+
+            HabboItem item = Emulator.getGameEnvironment().getItemManager().createItem(habbo.getHabboInfo().getId(), baseItem, 0, 0, "");
+            if (item == null)
+                return false;
 
-                        if (item != null) {
             habbo.getClient().sendResponse(new AddHabboItemComposer(item));
             habbo.getClient().getHabbo().getInventory().getItemsComponent().addItem(item);
             habbo.getClient().sendResponse(new PurchaseOKComposer(null));
             habbo.getClient().sendResponse(new InventoryRefreshComposer());
-                            habbo.getClient().sendResponse(new WiredRewardAlertComposer(WiredRewardAlertComposer.REWARD_RECEIVED_ITEM));
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
-                        }
+            return true;
-                    }
         } else if (rewardReceived.type.equalsIgnoreCase("respect")) {
             habbo.getHabboStats().respectPointsReceived += Integer.parseInt(rewardReceived.value);
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
+            return true;
         } else if (rewardReceived.type.equalsIgnoreCase("cata")) {
             CatalogItem item = Emulator.getGameEnvironment().getCatalogManager().getCatalogItem(Integer.parseInt(rewardReceived.value));
 
-                    if (item != null) {
+            if (item == null)
+                return false;
+
             Emulator.getGameEnvironment().getCatalogManager().purchaseItem(null, item, habbo, 1, "", true);
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
+            return true;
         }
-                    habbo.getClient().sendResponse(new WiredRewardAlertComposer(WiredRewardAlertComposer.REWARD_RECEIVED_ITEM));
+
-                }
+        return false;
-            }
-        }
     }
 
     public static boolean getReward(Habbo habbo, WiredEffectGiveReward wiredBox) {
@@ -433,22 +460,26 @@ public class WiredHandler {
                             }
 
                             if (!found) {
-                                giveReward(habbo, wiredBox, item);
+                                return giveReward(habbo, wiredBox, item);
-                                return true;
                             }
                         }
+
+                        habbo.getClient().sendResponse(new WiredRewardAlertComposer(WiredRewardAlertComposer.REWARD_ALL_COLLECTED));
+                        return false;
                     } else {
                         int randomNumber = Emulator.getRandom().nextInt(101);
 
                         int count = 0;
                         for (WiredGiveRewardItem item : wiredBox.rewardItems) {
                             if (randomNumber >= count && randomNumber <= (count + item.probability)) {
-                                giveReward(habbo, wiredBox, item);
+                                return giveReward(habbo, wiredBox, item);
-                                return true;
                             }
 
                             count += item.probability;
                         }
+
+                        habbo.getClient().sendResponse(new WiredRewardAlertComposer(WiredRewardAlertComposer.UNLUCKY_NO_REWARD));
+                        return false;
                     }
                 }
             }

Emulator/src/main/java/com/eu/habbo/habbohotel/wired/core/WiredManager.java

@@ -687,15 +687,7 @@ public final class WiredManager {
         });
     }
 
-    private static void giveReward(Habbo habbo, WiredEffectGiveReward wiredBox, WiredGiveRewardItem reward) {
+    private static void persistReward(int wiredId, int habboId, int rewardId, int timestamp) {
-        if (wiredBox.getLimit() > 0)
-            wiredBox.incrementGiven();
-
-        final int wiredId = wiredBox.getId();
-        final int habboId = habbo.getHabboInfo().getId();
-        final int rewardId = reward.id;
-        final int timestamp = Emulator.getIntUnixTimestamp();
-        
         Emulator.getThreading().run(() -> {
             try (Connection connection = Emulator.getDatabase().getDataSource().getConnection();
                  PreparedStatement statement = connection.prepareStatement("INSERT INTO wired_rewards_given (wired_item, user_id, reward_id, timestamp) VALUES ( ?, ?, ?, ?)")) {
@@ -708,41 +700,75 @@ public final class WiredManager {
                 LOGGER.error("Caught SQL exception", e);
             }
         });
+    }
 
+    private static void completeReward(Habbo habbo, WiredEffectGiveReward wiredBox, WiredGiveRewardItem reward, int successCode) {
+        if (wiredBox.getLimit() > 0) {
+            wiredBox.incrementGiven();
+        }
+
+        persistReward(wiredBox.getId(), habbo.getHabboInfo().getId(), reward.id, Emulator.getIntUnixTimestamp());
+        habbo.getClient().sendResponse(new WiredRewardAlertComposer(successCode));
+    }
+
+    private static boolean giveReward(Habbo habbo, WiredEffectGiveReward wiredBox, WiredGiveRewardItem reward) {
         if (reward.badge) {
             UserWiredRewardReceived rewardReceived = new UserWiredRewardReceived(habbo, wiredBox, "badge", reward.data);
-            if (Emulator.getPluginManager().fireEvent(rewardReceived).isCancelled())
+            if (Emulator.getPluginManager().fireEvent(rewardReceived).isCancelled()) {
-                return;
+                return false;
+            }
 
-            if (rewardReceived.value.isEmpty())
+            if (rewardReceived.value.isEmpty()) {
-                return;
+                return false;
+            }
 
-            if (habbo.getInventory().getBadgesComponent().hasBadge(rewardReceived.value))
+            if (habbo.getInventory().getBadgesComponent().hasBadge(rewardReceived.value)) {
-                return;
+                habbo.getClient().sendResponse(new WiredRewardAlertComposer(WiredRewardAlertComposer.REWARD_ALREADY_RECEIVED));
+                return false;
+            }
 
             HabboBadge badge = new HabboBadge(0, rewardReceived.value, 0, habbo);
             Emulator.getThreading().run(badge);
             habbo.getInventory().getBadgesComponent().addBadge(badge);
             habbo.getClient().sendResponse(new AddUserBadgeComposer(badge));
-            habbo.getClient().sendResponse(new WiredRewardAlertComposer(WiredRewardAlertComposer.REWARD_RECEIVED_BADGE));
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_BADGE);
-        } else {
+            return true;
+        }
+
         String[] data = reward.data.split("#");
 
-            if (data.length == 2) {
+        if (data.length != 2) {
-                UserWiredRewardReceived rewardReceived = new UserWiredRewardReceived(habbo, wiredBox, data[0], data[1]);
+            return false;
-                if (Emulator.getPluginManager().fireEvent(rewardReceived).isCancelled())
+        }
-                    return;
 
-                if (rewardReceived.value.isEmpty())
+        UserWiredRewardReceived rewardReceived = new UserWiredRewardReceived(habbo, wiredBox, data[0], data[1]);
-                    return;
+        if (Emulator.getPluginManager().fireEvent(rewardReceived).isCancelled()) {
+            return false;
+        }
+
+        if (rewardReceived.value.isEmpty()) {
+            return false;
+        }
 
         if (rewardReceived.type.equalsIgnoreCase("credits")) {
-                    int credits = Integer.parseInt(rewardReceived.value);
+            habbo.giveCredits(Integer.parseInt(rewardReceived.value));
-                    habbo.giveCredits(credits);
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
-                } else if (rewardReceived.type.equalsIgnoreCase("pixels")) {
+            return true;
-                    int pixels = Integer.parseInt(rewardReceived.value);
+        }
-                    habbo.givePixels(pixels);
+
-                } else if (rewardReceived.type.startsWith("points")) {
+        if (rewardReceived.type.equalsIgnoreCase("diamonds") || rewardReceived.type.equalsIgnoreCase("diamond")) {
+            habbo.givePoints(5, Integer.parseInt(rewardReceived.value));
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
+            return true;
+        }
+
+        if (rewardReceived.type.equalsIgnoreCase("pixels")) {
+            habbo.givePixels(Integer.parseInt(rewardReceived.value));
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
+            return true;
+        }
+
+        if (rewardReceived.type.startsWith("points")) {
             int points = Integer.parseInt(rewardReceived.value);
             int type = 5;
 
@@ -752,31 +778,47 @@ public final class WiredManager {
             }
 
             habbo.givePoints(type, points);
-                } else if (rewardReceived.type.equalsIgnoreCase("furni")) {
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
-                    Item baseItem = Emulator.getGameEnvironment().getItemManager().getItem(Integer.parseInt(rewardReceived.value));
+            return true;
-                    if (baseItem != null) {
+        }
-                        HabboItem item = Emulator.getGameEnvironment().getItemManager().createItem(habbo.getHabboInfo().getId(), baseItem, 0, 0, "");
+
+        if (rewardReceived.type.equalsIgnoreCase("furni")) {
+            Item baseItem = Emulator.getGameEnvironment().getItemManager().getItem(Integer.parseInt(rewardReceived.value));
+            if (baseItem == null) {
+                return false;
+            }
+
+            HabboItem item = Emulator.getGameEnvironment().getItemManager().createItem(habbo.getHabboInfo().getId(), baseItem, 0, 0, "");
+            if (item == null) {
+                return false;
+            }
 
-                        if (item != null) {
             habbo.getClient().sendResponse(new AddHabboItemComposer(item));
             habbo.getClient().getHabbo().getInventory().getItemsComponent().addItem(item);
             habbo.getClient().sendResponse(new PurchaseOKComposer(null));
             habbo.getClient().sendResponse(new InventoryRefreshComposer());
-                            habbo.getClient().sendResponse(new WiredRewardAlertComposer(WiredRewardAlertComposer.REWARD_RECEIVED_ITEM));
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
+            return true;
+        }
+
+        if (rewardReceived.type.equalsIgnoreCase("respect")) {
+            habbo.getHabboStats().respectPointsReceived += Integer.parseInt(rewardReceived.value);
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
+            return true;
+        }
+
+        if (rewardReceived.type.equalsIgnoreCase("cata")) {
+            CatalogItem item = Emulator.getGameEnvironment().getCatalogManager().getCatalogItem(Integer.parseInt(rewardReceived.value));
+            if (item == null) {
+                return false;
             }
-                    }
-                } else if (rewardReceived.type.equalsIgnoreCase("respect")) {
-                    habbo.getHabboStats().respectPointsReceived += Integer.parseInt(rewardReceived.value);
-                } else if (rewardReceived.type.equalsIgnoreCase("cata")) {
-                    CatalogItem item = Emulator.getGameEnvironment().getCatalogManager().getCatalogItem(Integer.parseInt(rewardReceived.value));
 
-                    if (item != null) {
             Emulator.getGameEnvironment().getCatalogManager().purchaseItem(null, item, habbo, 1, "", true);
+            completeReward(habbo, wiredBox, reward, WiredRewardAlertComposer.REWARD_RECEIVED_ITEM);
+            return true;
         }
-                    habbo.getClient().sendResponse(new WiredRewardAlertComposer(WiredRewardAlertComposer.REWARD_RECEIVED_ITEM));
+
-                }
+        return false;
-            }
-        }
     }
 
     public static boolean getReward(Habbo habbo, WiredEffectGiveReward wiredBox) {
@@ -843,22 +885,26 @@ public final class WiredManager {
                             }
 
                             if (!found) {
-                                giveReward(habbo, wiredBox, item);
+                                return giveReward(habbo, wiredBox, item);
-                                return true;
                             }
                         }
+
+                        habbo.getClient().sendResponse(new WiredRewardAlertComposer(WiredRewardAlertComposer.REWARD_ALL_COLLECTED));
+                        return false;
                     } else {
                         int randomNumber = Emulator.getRandom().nextInt(101);
 
                         int count = 0;
                         for (WiredGiveRewardItem item : wiredBox.getRewardItems()) {
                             if (randomNumber >= count && randomNumber <= (count + item.probability)) {
-                                giveReward(habbo, wiredBox, item);
+                                return giveReward(habbo, wiredBox, item);
-                                return true;
                             }
 
                             count += item.probability;
                         }
+
+                        habbo.getClient().sendResponse(new WiredRewardAlertComposer(WiredRewardAlertComposer.UNLUCKY_NO_REWARD));
+                        return false;
                     }
                 }
             }

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

@@ -8,7 +8,7 @@ public class MutedWhisperComposer extends MessageComposer {
     private final int seconds;
 
     public MutedWhisperComposer(int seconds) {
-        this.seconds = seconds;
+        this.seconds = Math.max(0, seconds);
     }
 
     @Override