Add official Habbo release 39 flash client support

Havana-Server/src/main/java/org/alexdev/havana/dao/mysql/NavigatorDao.java

@@ -53,6 +53,38 @@ public class NavigatorDao {
         return categories;
     }
 
+    /**
+     * Get the styles for the public rooms
+     *
+     * @return the list of recent rooms
+     */
+    public static Map<Integer, NavigatorStyle> getNavigatorStyles() {
+        Map<Integer, NavigatorStyle> style = new HashMap<>();
+
+        Connection sqlConnection = null;
+        PreparedStatement preparedStatement = null;
+        ResultSet resultSet = null;
+
+        try {
+            sqlConnection = Storage.getStorage().getConnection();
+            preparedStatement = Storage.getStorage().prepare("SELECT * FROM navigator_styles", sqlConnection);
+            resultSet = preparedStatement.executeQuery();
+
+            while (resultSet.next()) {
+                style.put(resultSet.getInt("room_id"), new NavigatorStyle(resultSet.getInt("room_id"), resultSet.getString("description"), resultSet.getString("thumbnail_url"), resultSet.getInt("thumbnail_layout")));
+            }
+
+        } catch (Exception e) {
+            Storage.logError(e);
+        } finally {
+            Storage.closeSilently(resultSet);
+            Storage.closeSilently(preparedStatement);
+            Storage.closeSilently(sqlConnection);
+        }
+
+        return style;
+    }
+
     /**
      * Get the list of recent rooms from database set by limit and category id.
      *

Havana-Server/src/main/java/org/alexdev/havana/game/inventory/Inventory.java

@@ -101,6 +101,14 @@ public class Inventory {
     private Map<Integer,Item> getCasts() {
         LinkedHashMap<Integer, Item> casts = new LinkedHashMap<>();
 
+        if (this.player.getNetwork().isFlashConnection()) {
+            int stripSlotId = 0;
+
+            for (Item item : this.displayedItems) {
+                addItemCast(casts, stripSlotId++, item);
+            }
+        }
+
         if (this.paginatedItems.containsKey(this.handStripPageIndex)) {
             int stripSlotId = this.handStripPageIndex * MAX_ITEMS_PER_PAGE;
 

Havana-Server/src/main/java/org/alexdev/havana/game/item/Item.java

@@ -251,6 +251,22 @@ public class Item {
      * @return true, if successful.
      */
     public boolean isWalkable(Entity entity, Position selectedPosition) {
+        if (entity != null) {
+            if (entity.getType() == EntityType.PLAYER) {
+                Player player = (Player) entity;
+
+                if (player.getNetwork().isFlashConnection()) {
+                    if (this.getDefinition().getInteractionType() == InteractionType.IDOL_SCOREBOARD) {
+                        return false;
+                    }
+
+                    if (this.getDefinition().getInteractionType() == InteractionType.IDOL_VOTE_CHAIR) {
+                        return false;
+                    }
+                }
+            }
+        }
+
         if (entity == null && this.hasBehaviour(ItemBehaviour.CAN_NOT_STACK_ON_TOP))
             return false;
 

Havana-Server/src/main/java/org/alexdev/havana/game/item/interactors/types/pool/PoolInteractor.java

@@ -23,11 +23,11 @@ public class PoolInteractor {
 
         // Only check these below if the user is in a pool room.
         if (room.getModel().getName().startsWith("pool_") ||
-            room.getModel().getName().equals("md_a")) {
+                room.getModel().getName().equals("md_a")) {
             if (fromItem != null) {
                 // Check if they have swimmers before trying to enter pool
                 if (fromItem.getDefinition().getSprite().equals("poolEnter") ||
-                    fromItem.getDefinition().getSprite().equals("poolExit")) {
+                        fromItem.getDefinition().getSprite().equals("poolExit")) {
                     return entity.getDetails().getPoolFigure().length() > 0;
                 }
             }
@@ -35,21 +35,39 @@ public class PoolInteractor {
             if (toItem != null) {
                 // Check if they have swimmers before trying to enter pool
                 if (toItem.getDefinition().getSprite().equals("poolEnter") ||
-                    toItem.getDefinition().getSprite().equals("poolExit")) {
+                        toItem.getDefinition().getSprite().equals("poolExit")) {
                     return entity.getDetails().getPoolFigure().length() > 0;
                 }
 
                 // Don't allow to "enter" the pool if they're already swimming
                 if (entity.getRoomUser().containsStatus(StatusType.SWIM) &&
-                    toItem.getDefinition().getSprite().equals("poolEnter")) {
+                        toItem.getDefinition().getSprite().equals("poolEnter")) {
                     return false;
                 }
 
                 // Don't allow to "leave" the pool if they're not swimming
                 if (!entity.getRoomUser().containsStatus(StatusType.SWIM) &&
-                    toItem.getDefinition().getSprite().equals("poolExit")) {
+                        toItem.getDefinition().getSprite().equals("poolExit")) {
                     return false;
                 }
+
+                // Don't allow users to cut people in queue, force them to garound
+                if (toItem.getDefinition().getSprite().contains("queue_tile2")) {
+                    if (entity.getType() == EntityType.PLAYER && ((Player)entity).getNetwork().isFlashConnection()) {
+                        return false;
+                    }
+                }
+
+                // Don't allow people to enter the booth if it's closed, or don't allow
+                // if they attempt to use the pool lift without swimmers
+                if (toItem.getDefinition().getSprite().equals("poolBooth") ||
+                        toItem.getDefinition().getSprite().equals("poolLift")) {
+                    if (entity.getType() == EntityType.PLAYER && ((Player)entity).getNetwork().isFlashConnection()) {
+                        return false;
+                    }
+
+                    return !toItem.getCurrentProgramValue().equals("close");
+                }
             }
         }
 

Havana-Server/src/main/java/org/alexdev/havana/game/messenger/MessengerUser.java

@@ -99,6 +99,24 @@ public class MessengerUser {
         }
 
         Room room = player.getRoomUser().getRoom();
+
+        // Don't allow follow into rooms that you cannot gain entry into normally
+        if (friend.getNetwork().isFlashConnection()) {
+            int roomId = room.getId();
+
+            if (WalkwaysManager.getInstance().getWalkways().stream().anyMatch(walkway -> walkway.getRoomTargetId() == room.getId())) {
+                var roomData = WalkwaysManager.getInstance().getWalkways().stream().filter(walkway -> walkway.getRoomTargetId() == room.getId()).findFirst().orElse(null);
+
+                if (roomData != null) {
+                    roomId = roomData.getRoomId();
+                }
+            }
+
+            if (room.isPublicRoom() && NavigatorManager.getInstance().getNavigatorStyle(roomId) == null) {
+                return false;
+            }
+        }
+
         return (!room.getModel().getName().startsWith("bb_") && !room.getModel().getName().equals("snowwar"));
     }
 

Havana-Server/src/main/java/org/alexdev/havana/game/navigator/NavigatorManager.java

@@ -9,9 +9,11 @@ import java.util.*;
 public class NavigatorManager {
     private static NavigatorManager instance;
     private final HashMap<Integer, NavigatorCategory> categoryMap;
+    private final Map<Integer, NavigatorStyle> navigatorStyles;
 
     private NavigatorManager() {
         this.categoryMap = NavigatorDao.getCategories();
+        this.navigatorStyles = NavigatorDao.getNavigatorStyles();
         //NavigatorDao.resetBadPrivateRoomCategories();
     }
 
@@ -72,6 +74,20 @@ public class NavigatorManager {
         return this.categoryMap;
     }
 
+    /**
+     * Get the navigator style by room id, will give default style if the room id doesn't exist.
+     *
+     * @param roomId the room id
+     * @return the style
+     */
+    public NavigatorStyle getNavigatorStyle(int roomId) {
+        if (this.navigatorStyles.containsKey(roomId)) {
+            return this.navigatorStyles.get(roomId);
+        }
+
+        return null;//new NavigatorStyle(-1, "officialrooms_fr/percy_jackson_nav.png", 1);
+    }
+
     /**
      * Get instance of {@link NavigatorManager}
      *

Havana-Server/src/main/java/org/alexdev/havana/game/player/Player.java

@@ -20,7 +20,12 @@ import org.alexdev.havana.game.messenger.Messenger;
 import org.alexdev.havana.game.player.guides.PlayerGuideManager;
 import org.alexdev.havana.game.player.statistics.PlayerStatistic;
 import org.alexdev.havana.game.player.statistics.PlayerStatisticManager;
+import org.alexdev.havana.game.room.RoomManager;
 import org.alexdev.havana.game.room.entities.RoomPlayer;
+import org.alexdev.havana.messages.flash.outgoing.HOME_ROOM;
+import org.alexdev.havana.messages.flash.outgoing.modtool.FLASH_MODTOOL;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_FAVOURITES;
+import org.alexdev.havana.messages.incoming.navigator.ADD_FAVORITE_ROOM;
 import org.alexdev.havana.messages.outgoing.alerts.ALERT;
 import org.alexdev.havana.messages.outgoing.alerts.HOTEL_LOGOUT;
 import org.alexdev.havana.messages.outgoing.alerts.HOTEL_LOGOUT.LogoutReason;
@@ -188,6 +193,17 @@ public class Player extends Entity {
         this.send(new LOGIN());
         this.send(new AVATAR_EFFECTS(this.effects));
 
+        if (this.network.isFlashConnection()) {
+            int roomId = PlayerDao.getHomeRoom(this.details.getId());
+
+            if (RoomDao.getRoomById(roomId) == null) {
+                PlayerDao.saveHomeRoom(this.details.getId(), 0);
+                roomId = 0;
+            }
+
+            this.send(new HOME_ROOM(roomId));
+        }
+
         if (GameConfiguration.getInstance().getBoolean("welcome.message.enabled")) {
             String alertMessage = GameConfiguration.getInstance().getString("welcome.message.content");
             alertMessage = StringUtil.replaceAlertMessage(alertMessage, this);
@@ -264,6 +280,14 @@ public class Player extends Entity {
         }
 
         ClubSubscription.countMemberDays(this);
+
+        if (this.network.isFlashConnection()) {
+            this.send(new FLASH_FAVOURITES(ADD_FAVORITE_ROOM.MAX_FAVOURITES, RoomManager.getInstance().getFavouriteRooms(this.getDetails().getId(), true)));
+
+            if (this.getDetails().getRank().getRankId() >= PlayerRank.MODERATOR.getRankId()) {
+                this.send(new FLASH_MODTOOL());
+            }
+        }
     }
 
     /**

Havana-Server/src/main/java/org/alexdev/havana/game/player/PlayerManager.java

@@ -214,7 +214,11 @@ public class PlayerManager {
 
         // Notify all users of shutdown timeout
         for (Player p : this.players) {
-            p.send(new INFO_HOTEL_CLOSING(maintenanceAt));
+            if (p.getNetwork().isFlashConnection()) {
+                p.send(new ALERT("The hotel is currently closing in " + Math.toIntExact(maintenanceAt.toMinutes()) + " minutes!"));
+            } else {
+                p.send(new INFO_HOTEL_CLOSING(maintenanceAt));
+            }
         }
     }
 

Havana-Server/src/main/java/org/alexdev/havana/game/room/Room.java

@@ -90,6 +90,21 @@ public class Room {
         }
     }
 
+    /**
+     * Sends a packet to flash clients in room only.
+     *
+     * @param composer the composer to send
+     */
+    public void sendFlashClients(MessageComposer composer) {
+        for (Player player : this.roomEntityManager.getPlayers()) {
+            if (!player.getNetwork().isFlashConnection()) {
+                continue;
+            }
+
+            player.send(composer);
+        }
+    }
+
     /**
      * Checks if the user id is the owner of the room.
      *
@@ -259,8 +274,10 @@ public class Room {
             }
         }
 
-        if (isPublic) {
+        if (!player.getNetwork().isFlashConnection()) {
-            roomId = roomId + RoomManager.PUBLIC_ROOM_OFFSET;
+            if (isPublic) {
+                roomId = roomId + RoomManager.PUBLIC_ROOM_OFFSET;
+            }
         }
 
         player.send(new ROOMFORWARD(isPublic, roomId));

Havana-Server/src/main/java/org/alexdev/havana/game/room/entities/RoomPlayer.java

@@ -285,6 +285,10 @@ public class RoomPlayer extends RoomEntity {
         // Send refresh to room if inside room
         if (this.getRoom() != null) {
             this.getRoom().send(new FIGURE_CHANGE(this.getInstanceId(), this.player.getDetails()));
+
+            if (this.player.getNetwork().isFlashConnection()) {
+                this.player.send(new FIGURE_CHANGE(-1, this.player.getDetails()));
+            }
         }
     }
 

Havana-Server/src/main/java/org/alexdev/havana/messages/MessageHandler.java

@@ -6,6 +6,12 @@ import org.alexdev.havana.game.player.Player;
 import org.alexdev.havana.game.room.Room;
 import org.alexdev.havana.game.room.RoomManager;
 import org.alexdev.havana.log.Log;
+import org.alexdev.havana.messages.flash.incoming.SET_HOME_ROOM;
+import org.alexdev.havana.messages.flash.incoming.modtool.FLASH_MODTOOL_ROOMINFO;
+import org.alexdev.havana.messages.flash.incoming.modtool.FLASH_MODTOOL_ROOM_CHATLOG;
+import org.alexdev.havana.messages.flash.incoming.navigator.*;
+import org.alexdev.havana.messages.flash.incoming.navigator.beta.FLASH_GETGUESTROOMS;
+import org.alexdev.havana.messages.flash.incoming.rooms.*;
 import org.alexdev.havana.messages.incoming.catalogue.GET_ALIAS_LIST;
 import org.alexdev.havana.messages.incoming.catalogue.GET_CATALOGUE_PAGE;
 import org.alexdev.havana.messages.incoming.catalogue.GET_CATALOG_INDEX;
@@ -108,6 +114,7 @@ public class MessageHandler {
         registerJukeboxPackets();
         registerPollPackets();
         registerTutorPackets();
+        registerFlashModTool();
 
         registerEvent(230, (player, reader) -> {
             if (player.getRoomUser().getRoom() == null) {
@@ -203,6 +210,7 @@ public class MessageHandler {
         registerEvent(1817, new GET_SESSION_PARAMETERS());
         registerEvent(813, new UNIQUEID());
         registerEvent(1170, new VERSIONCHECK());
+        registerEvent(251, new GET_FURNI_VERSIONS());
     }
 
     /**
@@ -247,6 +255,24 @@ public class MessageHandler {
         registerEvent(18, new GETFVRF());
         registerEvent(19, new ADD_FAVORITE_ROOM());
         registerEvent(20, new DEL_FAVORITE_ROOM());
+
+        // Flash
+        registerEvent(434, new FLASH_USERFLATS());
+        registerEvent(382, new FLASH_POPULARTAGS());
+        registerEvent(437, new FLASH_SEARCH());
+        registerEvent(438, new FLASH_SEARCH_TAGS());
+        registerEvent(430, new FLASH_POPULARROOMS());
+        registerEvent(431, new FLASH_HIGHESTVOTEDROOMS());
+        registerEvent(380, new FLASH_PUBLICROOMS());
+        registerEvent(387, new FLASH_CANCREATEROOM());
+        registerEvent(439, new FLASH_EVENTROOMS());
+        registerEvent(433, new FLASH_FRIENDS_IN_ROOM());
+        registerEvent(432, new FLASH_ROOMS_FRIENDS_OWN());
+        registerEvent(436, new FLASH_ROOMS_RECENTLY_VISTED());
+        registerEvent(435, new FLASH_FAVOURITE_ROOMS());
+
+        // Flash r34
+        registerEvent(381, new FLASH_GETGUESTROOMS());
     }
 
     /**
@@ -266,6 +292,20 @@ public class MessageHandler {
         registerEvent(63, new G_ITEMS());
         registerEvent(98, new LETUSERIN());
         registerEvent(261, new RATEFLAT());
+
+        // Flash
+        registerEvent(385, new FLASH_ROOM_INFO());
+        registerEvent(391, new TRYFLAT());
+        //registerEvent(390, new GET_ROOM_INFO());
+        registerEvent(390, new GETROOMAD());
+        registerEvent(390, new G_HMAP());
+
+        registerEvent(388, new FLASH_GETPUBLICROOMDATA());
+        registerEvent(400, new FLASH_ROOMEDITDATA());
+        registerEvent(401, new FLASH_ROOMSAVEDATA());
+        registerEvent(386, new FLASH_ROOMICONDATA());
+        registerEvent(375, new FLASH_GETWARDROBE());
+        registerEvent(376, new FLASH_SAVEWARDROBE());
     }
 
     /**
@@ -291,6 +331,8 @@ public class MessageHandler {
         registerEvent(371, new RESPECT_USER());
         registerEvent(114, new PTM());
         registerEvent(263, new GET_USER_TAGS());
+        registerEvent(44, new CHANGE_LOOKS());
+        registerEvent(384, new SET_HOME_ROOM());
     }
 
 
@@ -535,6 +577,11 @@ public class MessageHandler {
         registerEvent(249, new RESET_TUTORIAL());
     }
 
+    private void registerFlashModTool() {
+        registerEvent(459, new FLASH_MODTOOL_ROOMINFO());
+        registerEvent(456, new FLASH_MODTOOL_ROOM_CHATLOG());
+    }
+
     /**
      * Register event.
      *

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/SET_HOME_ROOM.java

@@ -0,0 +1,29 @@
+package org.alexdev.havana.messages.flash.incoming;
+
+import org.alexdev.havana.dao.mysql.PlayerDao;
+import org.alexdev.havana.dao.mysql.RoomDao;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.flash.outgoing.HOME_ROOM;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+public class SET_HOME_ROOM implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        int roomId = reader.readInt();
+
+        if (roomId > 0) {
+             Room room = RoomDao.getRoomById(roomId);
+
+             if (room == null || room.isPublicRoom() || room.getData().getOwnerId() != player.getDetails().getId()) {
+                 return;
+             }
+        } else {
+            roomId = 0;
+        }
+
+        PlayerDao.saveHomeRoom(player.getDetails().getId(), roomId);
+        player.send(new HOME_ROOM(roomId));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/modtool/FLASH_MODTOOL_ROOMINFO.java

@@ -0,0 +1,21 @@
+package org.alexdev.havana.messages.flash.incoming.modtool;
+
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.player.PlayerRank;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.flash.outgoing.modtool.FLASH_MODTOOL_ROOMDATA;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+public class FLASH_MODTOOL_ROOMINFO implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        Room room = player.getRoomUser().getRoom();
+
+        if (room == null || player.getDetails().getRank().getRankId() < PlayerRank.MODERATOR.getRankId()) {
+            return;
+        }
+
+        player.send(new FLASH_MODTOOL_ROOMDATA(room));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/modtool/FLASH_MODTOOL_ROOM_CHATLOG.java

@@ -0,0 +1,22 @@
+package org.alexdev.havana.messages.flash.incoming.modtool;
+
+import org.alexdev.havana.dao.mysql.RoomDao;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.player.PlayerRank;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.flash.outgoing.modtool.FLASH_MODTOOL_CHATLOG;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+public class FLASH_MODTOOL_ROOM_CHATLOG implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        Room room = player.getRoomUser().getRoom();
+
+        if (room == null || player.getDetails().getRank().getRankId() < PlayerRank.MODERATOR.getRankId()) {
+            return;
+        }
+
+        player.send(new FLASH_MODTOOL_CHATLOG(room, RoomDao.getModChatlog(room.getId())));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/FLASH_CANCREATEROOM.java

@@ -0,0 +1,25 @@
+package org.alexdev.havana.messages.flash.incoming.navigator;
+
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+public class FLASH_CANCREATEROOM implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        player.send(new MessageComposer() {
+            @Override
+            public void compose(NettyResponse response) {
+                response.writeBool(false);
+                response.writeInt(25);
+            }
+
+            @Override
+            public short getHeader() {
+                return 512;
+            }
+        });
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/FLASH_EVENTROOMS.java

@@ -0,0 +1,39 @@
+package org.alexdev.havana.messages.flash.incoming.navigator;
+
+import org.alexdev.havana.dao.mysql.NavigatorDao;
+import org.alexdev.havana.game.events.EventsManager;
+import org.alexdev.havana.game.navigator.NavigatorCategory;
+import org.alexdev.havana.game.navigator.NavigatorManager;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_FLAT_RESULTS;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class FLASH_EVENTROOMS implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        if (player.getNetwork().isBetaConnected()) {
+            return;
+        }
+
+        int mode = Integer.parseInt(reader.readString());
+        List<Room> roomList = new ArrayList<>();
+        
+        if (mode == -1) {
+            roomList = EventsManager.getInstance().getEventList().stream().map(event -> RoomManager.getInstance().getRoomById(event.getRoomId())).collect(Collectors.toList());
+        } else {
+            roomList = EventsManager.getInstance().getEvents(mode).stream().map(event -> RoomManager.getInstance().getRoomById(event.getRoomId())).collect(Collectors.toList());
+        }
+
+        RoomManager.getInstance().sortRooms(roomList);
+        RoomManager.getInstance().ratingSantiyCheck(roomList);
+
+        player.send(new FLASH_FLAT_RESULTS(roomList, mode, true));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/FLASH_FAVOURITE_ROOMS.java

@@ -0,0 +1,23 @@
+package org.alexdev.havana.messages.flash.incoming.navigator;
+
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_FLAT_RESULTS;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+public class FLASH_FAVOURITE_ROOMS implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        if (player.getNetwork().isBetaConnected()) {
+            return;
+        }
+
+        var roomList = RoomManager.getInstance().getFavouriteRooms(player.getDetails().getId(), true);
+
+        RoomManager.getInstance().sortRooms(roomList);
+        RoomManager.getInstance().ratingSantiyCheck(roomList);
+
+        player.send(new FLASH_FLAT_RESULTS(roomList, -3, false));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/FLASH_FRIENDS_IN_ROOM.java

@@ -0,0 +1,44 @@
+package org.alexdev.havana.messages.flash.incoming.navigator;
+
+import org.alexdev.havana.game.messenger.MessengerUser;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.player.PlayerManager;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_FLAT_RESULTS;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FLASH_FRIENDS_IN_ROOM implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        if (player.getNetwork().isBetaConnected()) {
+            return;
+        }
+
+        List<Room> friendsInRoom = new ArrayList<>();
+
+        for (MessengerUser messengerUser : player.getMessenger().getFriends().values()) {
+            if (!messengerUser.isOnline()) {
+                continue;
+            }
+
+            var friend = PlayerManager.getInstance().getPlayerById(messengerUser.getUserId());
+            var friendRoom = friend.getRoomUser().getRoom();
+
+            if (friendRoom != null && !friendRoom.isPublicRoom()) {
+                if (friendsInRoom.stream().noneMatch(room -> room.getId() == friendRoom.getId())) {
+                    friendsInRoom.add(friendRoom);
+                }
+            }
+        }
+
+        RoomManager.getInstance().sortRooms(friendsInRoom);
+        RoomManager.getInstance().ratingSantiyCheck(friendsInRoom);
+
+        player.send(new FLASH_FLAT_RESULTS(friendsInRoom, -3, false));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/FLASH_HIGHESTVOTEDROOMS.java

@@ -0,0 +1,28 @@
+package org.alexdev.havana.messages.flash.incoming.navigator;
+
+import org.alexdev.havana.dao.mysql.NavigatorDao;
+import org.alexdev.havana.dao.mysql.RoomDao;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_FLAT_RESULTS;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+import java.util.List;
+
+public class FLASH_HIGHESTVOTEDROOMS implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        if (player.getNetwork().isBetaConnected()) {
+            return;
+        }
+
+        List<Room> roomList = RoomManager.getInstance().replaceQueryRooms(RoomDao.getHighestRatedRooms(30, 0));
+
+        RoomManager.getInstance().sortRooms(roomList);
+        RoomManager.getInstance().ratingSantiyCheck(roomList);
+
+        player.send(new FLASH_FLAT_RESULTS(roomList, -3, false));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/FLASH_POPULARROOMS.java

@@ -0,0 +1,48 @@
+package org.alexdev.havana.messages.flash.incoming.navigator;
+
+import org.alexdev.havana.dao.mysql.NavigatorDao;
+import org.alexdev.havana.game.navigator.NavigatorCategory;
+import org.alexdev.havana.game.navigator.NavigatorManager;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_FLAT_RESULTS;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FLASH_POPULARROOMS implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        if (player.getNetwork().isBetaConnected()) {
+            return;
+        }
+
+        var value = reader.readString();
+        int mode = -1;
+
+        List<Room> roomList = new ArrayList<>();
+
+        if (StringUtils.isNumeric(value)) {
+            mode = Integer.parseInt(value);
+
+            NavigatorCategory navigatorCategory = NavigatorManager.getInstance().getCategoryById(mode);
+
+            if (navigatorCategory != null) {
+                roomList.addAll(RoomManager.getInstance().replaceQueryRooms(NavigatorDao.getRecentRooms(30, navigatorCategory.getId())));
+            }
+        }
+
+        if (mode == -1) {
+            roomList.addAll(RoomManager.getInstance().replaceQueryRooms(NavigatorDao.getRopularRooms(30, false)));
+        }
+
+        RoomManager.getInstance().sortRooms(roomList);
+        RoomManager.getInstance().ratingSantiyCheck(roomList);
+
+        player.send(new FLASH_FLAT_RESULTS(roomList, mode, false));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/FLASH_POPULARTAGS.java

@@ -0,0 +1,40 @@
+package org.alexdev.havana.messages.flash.incoming.navigator;
+
+import org.alexdev.havana.dao.mysql.TagDao;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class FLASH_POPULARTAGS implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        if (player.getNetwork().isBetaConnected()) {
+            return;
+        }
+
+        var popularTags = TagDao.getRoomTagData(50);
+
+        player.send(new MessageComposer() {
+            @Override
+            public void compose(NettyResponse response) {
+                response.writeInt(popularTags.size());
+
+                var i = new AtomicInteger(1);
+
+                for (var tagData : popularTags.entrySet()) {
+                    response.writeString(tagData.getKey());
+                    response.writeInt(tagData.getValue());
+                }
+            }
+
+            @Override
+            public short getHeader() {
+                return 452;
+            }
+        });
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/FLASH_PUBLICROOMS.java

@@ -0,0 +1,40 @@
+package org.alexdev.havana.messages.flash.incoming.navigator;
+
+import org.alexdev.havana.dao.mysql.RoomDao;
+import org.alexdev.havana.game.navigator.NavigatorManager;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.incoming.navigator.beta.BETA_FLASH_PUBLICROOMS;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_FRONTPAGERESULT;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FLASH_PUBLICROOMS implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        if (player.getNetwork().isBetaConnected()) {
+            new BETA_FLASH_PUBLICROOMS().handle(player, reader);
+            return;
+        }
+
+        List<Room> roomList = new ArrayList<>();
+
+        for (Room room : RoomManager.getInstance().replaceQueryRooms(RoomDao.getRoomsByUserId(0))) {
+            if (room.getData().isNavigatorHide()) {
+                continue;
+            }
+
+
+            roomList.add(room);
+        }
+
+        roomList.removeIf(room -> NavigatorManager.getInstance().getNavigatorStyle(room.getId()) == null);
+        RoomManager.getInstance().sortRooms(roomList);
+
+        player.send(new FLASH_FRONTPAGERESULT(roomList));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/FLASH_ROOMS_FRIENDS_OWN.java

@@ -0,0 +1,34 @@
+package org.alexdev.havana.messages.flash.incoming.navigator;
+
+import org.alexdev.havana.dao.mysql.NavigatorDao;
+import org.alexdev.havana.game.messenger.MessengerUser;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_FLAT_RESULTS;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FLASH_ROOMS_FRIENDS_OWN implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        if (player.getNetwork().isBetaConnected()) {
+            return;
+        }
+
+        List<String> friendsInRoom = new ArrayList<>();
+
+        for (MessengerUser messengerUser : player.getMessenger().getFriends().values()) {
+            friendsInRoom.add(String.valueOf(messengerUser.getUserId()));
+        }
+
+        var roomList = RoomManager.getInstance().replaceQueryRooms(NavigatorDao.getFriendRooms(30, friendsInRoom));
+
+        RoomManager.getInstance().sortRooms(roomList);
+        RoomManager.getInstance().ratingSantiyCheck(roomList);
+
+        player.send(new FLASH_FLAT_RESULTS(roomList, -3, false));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/FLASH_ROOMS_RECENTLY_VISTED.java

@@ -0,0 +1,23 @@
+package org.alexdev.havana.messages.flash.incoming.navigator;
+
+import org.alexdev.havana.dao.mysql.NavigatorDao;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_FLAT_RESULTS;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+public class FLASH_ROOMS_RECENTLY_VISTED implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        if (player.getNetwork().isBetaConnected()) {
+            return;
+        }
+
+        var roomList = RoomManager.getInstance().replaceQueryRooms(NavigatorDao.getRecentlyVisited(30, player.getDetails().getId()));
+        //RoomManager.getInstance().sortRooms(roomList);
+        RoomManager.getInstance().ratingSantiyCheck(roomList);
+
+        player.send(new FLASH_FLAT_RESULTS(roomList, -3, false));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/FLASH_SEARCH.java

@@ -0,0 +1,40 @@
+package org.alexdev.havana.messages.flash.incoming.navigator;
+
+import org.alexdev.havana.dao.mysql.PlayerDao;
+import org.alexdev.havana.dao.mysql.RoomDao;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_SEARCHRESULTS;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+import org.alexdev.havana.util.SearchUtil;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class FLASH_SEARCH implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        String searchQuery = reader.readString();
+        int roomOwner = -1;
+
+        if (searchQuery.contains("owner:")) {
+            var ownerTag = SearchUtil.getOwnerTag(searchQuery);
+
+            if (ownerTag != null) {
+                roomOwner = PlayerDao.getId(ownerTag.replaceFirst("owner:", ""));
+            }
+
+            searchQuery = Arrays.stream(searchQuery.split(" ")).filter(s -> !s.toLowerCase().startsWith("owner:")).collect(Collectors.joining(","));
+        }
+
+        List<Room> roomList = RoomManager.getInstance().replaceQueryRooms(RoomDao.searchRooms(searchQuery, roomOwner, RoomDao.FLASH_SEARCH_LIMIT));
+
+        RoomManager.getInstance().sortRooms(roomList);
+        RoomManager.getInstance().ratingSantiyCheck(roomList);
+
+        player.send(new FLASH_SEARCHRESULTS(roomList, searchQuery));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/FLASH_SEARCH_TAGS.java

@@ -0,0 +1,28 @@
+package org.alexdev.havana.messages.flash.incoming.navigator;
+
+import org.alexdev.havana.dao.mysql.RoomDao;
+import org.alexdev.havana.dao.mysql.TagDao;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_SEARCHRESULTS;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FLASH_SEARCH_TAGS implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        String searchTag = reader.readString();
+
+
+        List<Room> roomList = RoomManager.getInstance().replaceQueryRooms(TagDao.querySearchRooms(searchTag));
+
+        RoomManager.getInstance().sortRooms(roomList);
+        RoomManager.getInstance().ratingSantiyCheck(roomList);
+
+        player.send(new FLASH_SEARCHRESULTS(roomList, searchTag));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/FLASH_USERFLATS.java

@@ -0,0 +1,24 @@
+package org.alexdev.havana.messages.flash.incoming.navigator;
+
+import org.alexdev.havana.dao.mysql.RoomDao;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_FLAT_RESULTS;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_GET_GUEST_ROOM_RESULT;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+import java.util.List;
+
+public class FLASH_USERFLATS implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        List<Room> roomList = RoomManager.getInstance().replaceQueryRooms(RoomDao.getRoomsByUserId(player.getDetails().getId()));
+
+        RoomManager.getInstance().sortRooms(roomList);
+        RoomManager.getInstance().ratingSantiyCheck(roomList);
+
+        player.send(new FLASH_FLAT_RESULTS(roomList, -3, false));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/beta/BETA_FLASH_PUBLICROOMS.java

@@ -0,0 +1,47 @@
+package org.alexdev.havana.messages.flash.incoming.navigator.beta;
+
+import org.alexdev.havana.dao.mysql.NavigatorDao;
+import org.alexdev.havana.dao.mysql.RoomDao;
+import org.alexdev.havana.game.navigator.NavigatorCategory;
+import org.alexdev.havana.game.navigator.NavigatorManager;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_FRONTPAGERESULT;
+import org.alexdev.havana.messages.flash.outgoing.navigator.beta.BETA_FLASH_FRONTPAGERESULT;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class BETA_FLASH_PUBLICROOMS implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        List<Room> popularRoomList = RoomManager.getInstance().replaceQueryRooms(NavigatorDao.getRopularRooms(6, false));
+
+        RoomManager.getInstance().sortRooms(popularRoomList);
+        RoomManager.getInstance().ratingSantiyCheck(popularRoomList);
+
+        Map<String, Integer> categoryList = new LinkedHashMap<>();
+
+        for (var kvp : NavigatorDao.getPopularCategories(3).entrySet()) {
+            var categoryId = kvp.getKey();
+            var roomVisitors = kvp.getValue();
+            var category = NavigatorManager.getInstance().getCategoryById(categoryId);
+
+            categoryList.put(category.getName(), roomVisitors);
+
+        }
+
+        player.send(new BETA_FLASH_FRONTPAGERESULT(popularRoomList,
+                RoomManager.getInstance().getRoomsByMode(1, player).size(),
+                RoomManager.getInstance().getRoomsByMode(4, player).size(),
+                RoomManager.getInstance().getRoomsByMode(5, player).size(),
+                RoomManager.getInstance().getRoomsByMode(6, player).size(),
+                categoryList));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/navigator/beta/FLASH_GETGUESTROOMS.java

@@ -0,0 +1,31 @@
+package org.alexdev.havana.messages.flash.incoming.navigator.beta;
+
+import org.alexdev.havana.dao.mysql.NavigatorDao;
+import org.alexdev.havana.dao.mysql.RoomDao;
+import org.alexdev.havana.game.messenger.MessengerUser;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.player.PlayerManager;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_GET_GUEST_ROOM_RESULT;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class FLASH_GETGUESTROOMS implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        int forceDisplay = reader.readInt();
+        int mode = reader.readInt();
+
+        List<Room> roomList = RoomManager.getInstance().getRoomsByMode(mode, player);//RoomManager.getInstance().replaceQueryRooms(RoomDao.getRoomsByUserId(player.getDetails().getId()));
+
+        RoomManager.getInstance().sortRooms(roomList);
+        RoomManager.getInstance().ratingSantiyCheck(roomList);
+
+        player.send(new FLASH_GET_GUEST_ROOM_RESULT(forceDisplay, mode, roomList));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/rooms/FLASH_GETPUBLICROOMDATA.java

@@ -0,0 +1,27 @@
+package org.alexdev.havana.messages.flash.incoming.rooms;
+
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.rooms.FLASH_PUBLICROOMCASTS;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+public class FLASH_GETPUBLICROOMDATA implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        int roomId = reader.remainingBytes().length > 0 ? reader.readInt() : player.getRoomUser().getRoom().getId();;/* - 1000;  -    WAS USED FOR RELEAS38 */
+
+        Room room = RoomManager.getInstance().getRoomById(roomId);
+
+        if (room == null) {
+            return;
+        }
+
+        if (room.getData().isNavigatorHide()) {
+            roomId = room.getFollowRedirect();
+        }
+
+        player.send(new FLASH_PUBLICROOMCASTS(roomId, room.getData().getCcts()));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/rooms/FLASH_GETWARDROBE.java

@@ -0,0 +1,14 @@
+package org.alexdev.havana.messages.flash.incoming.rooms;
+
+import org.alexdev.havana.dao.mysql.WardrobeDao;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.messages.flash.outgoing.rooms.WARDROBE;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+public class FLASH_GETWARDROBE implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        player.send(new WARDROBE(WardrobeDao.getWardrobe(player.getDetails().getId())));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/rooms/FLASH_ROOMEDITDATA.java

@@ -0,0 +1,23 @@
+package org.alexdev.havana.messages.flash.incoming.rooms;
+
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.rooms.FLASH_EDITDATA;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+public class FLASH_ROOMEDITDATA implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        int roomId = reader.readInt();
+
+        Room room = RoomManager.getInstance().getRoomById(roomId);
+
+        if (room == null || !room.isOwner(player.getDetails().getId())) {
+            return;
+        }
+
+        player.send(new FLASH_EDITDATA(room));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/rooms/FLASH_ROOMICONDATA.java

@@ -0,0 +1,103 @@
+package org.alexdev.havana.messages.flash.incoming.rooms;
+
+import org.alexdev.havana.dao.mysql.RoomDao;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.FLASH_FLATINFO;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class FLASH_ROOMICONDATA implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        int roomId = reader.readInt();
+
+        Room room = RoomManager.getInstance().getRoomById(roomId);
+
+        if (room == null || !room.isOwner(player.getDetails().getId())) {
+            return;
+        }
+
+        Map<Integer, Integer> items = new HashMap<>();
+
+        //int background = reader.readInt();
+        int background = reader.readInt();
+        int topLayer = reader.readInt();
+        int itemAmount = reader.readInt();
+
+        for (int i = 0; i < itemAmount; i++) {
+            int position = reader.readInt();
+            int item = reader.readInt();
+
+            if (position < 0 || position > 10)
+                return;
+
+            if (item < 1 || item > 27)
+                return;
+
+            if (items.containsKey(position)) {
+                return;
+            }
+
+            items.put(position, item);
+        }
+
+        if (background < 1 || background > 24)
+            return;
+
+        if (topLayer < 0 || topLayer > 11)
+            return;
+
+        StringBuilder formattedItems = new StringBuilder();
+        formattedItems.append(background).append("|");
+        formattedItems.append(topLayer).append("|");
+
+        int i = 0;
+        for (var kvp : items.entrySet()) {
+            i++;
+
+            formattedItems.append(kvp.getKey());
+            formattedItems.append(",");
+            formattedItems.append(kvp.getValue());
+
+            if (i != items.size()) {
+                formattedItems.append(" ");
+            }
+        }
+
+        room.getData().setIconData(formattedItems.toString());
+        RoomDao.saveIcon(room.getId(), formattedItems.toString());
+
+        player.send(new MessageComposer() {
+            @Override
+            public void compose(NettyResponse response) {
+                response.writeInt(roomId);
+            }
+
+            @Override
+            public short getHeader() {
+                return 467;
+            }
+        });
+
+        player.send(new MessageComposer() {
+            @Override
+            public void compose(NettyResponse response) {
+                response.writeInt(roomId);
+            }
+
+            @Override
+            public short getHeader() {
+                return 456;
+            }
+        });
+
+        //player.send(new FLASH_FLATINFO(player, room, overrideLock, false, false));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/rooms/FLASH_ROOMSAVEDATA.java

@@ -0,0 +1,116 @@
+package org.alexdev.havana.messages.flash.incoming.rooms;
+
+import org.alexdev.havana.dao.mysql.RoomDao;
+import org.alexdev.havana.dao.mysql.TagDao;
+import org.alexdev.havana.game.navigator.NavigatorManager;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+import org.alexdev.havana.util.StringUtil;
+
+public class FLASH_ROOMSAVEDATA implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        int roomId = reader.readInt();
+
+        Room room = RoomManager.getInstance().getRoomById(roomId);
+
+        if (room == null || !room.isOwner(player.getDetails().getId())) {
+            return;
+        }
+
+        String name = StringUtil.filterInput(reader.readString(), true);
+        String description = StringUtil.filterInput(reader.readString(), true);
+        int roomState = reader.readInt();
+        String password = StringUtil.filterInput(reader.readString(), true);
+        int maxUsers = reader.readInt();
+
+        if (name.isBlank()) {
+            return;
+        }
+
+        reader.readBoolean();
+        reader.readBoolean();
+        reader.readBoolean();
+
+        int categoryId = reader.readInt();
+        int tagCount = reader.readInt();
+
+        if (maxUsers < 10 || maxUsers > 50) {
+            maxUsers = 25;
+        }
+
+        var category = NavigatorManager.getInstance().getCategoryById(categoryId);
+
+        if (category == null) {
+            category = NavigatorManager.getInstance().getCategoryById(2);
+        }
+
+        if (category.getMinimumRoleSetFlat().getRankId() > player.getDetails().getRank().getRankId()) {
+            category = NavigatorManager.getInstance().getCategoryById(2);
+        }
+
+        if (category.isNode() || category.isPublicSpaces()) {
+            category = NavigatorManager.getInstance().getCategoryById(2);
+        }
+
+        categoryId = category.getId();
+
+        if (roomState != 0 && roomState != 1 && roomState != 2) {
+            roomState = 0;
+        }
+
+        TagDao.removeTags(0, roomId, 0);
+
+        if (tagCount > 0 && tagCount < 3) {
+            for (int i = 0; i < tagCount; i++) {
+                String tag = StringUtil.isValidTag(StringUtil.filterInput(reader.readString(), true), 0, roomId, 0);
+
+                if (tag == null) {
+                    continue;
+                }
+
+                StringUtil.addTag(tag, 0, roomId, 0);
+            }
+        }
+
+        room.getData().setName(name);
+        room.getData().setDescription(description);
+        room.getData().setAccessType(roomState);
+        room.getData().setPassword(password);
+        room.getData().setVisitorsMax(maxUsers);
+        room.getData().setCategoryId(categoryId);
+        RoomDao.save(room);
+
+        player.send(new MessageComposer() {
+            @Override
+            public void compose(NettyResponse response) {
+                response.writeInt(roomId);
+            }
+
+            @Override
+            public short getHeader() {
+                return 467;
+            }
+        });
+
+        player.send(new MessageComposer() {
+            @Override
+            public void compose(NettyResponse response) {
+                response.writeInt(roomId);
+            }
+
+            @Override
+            public short getHeader() {
+                return 456;
+            }
+        });
+
+       // boolean overrideLock = room.isOwner(player.getDetails().getId());
+        //player.send(new FLASH_FLATINFO(player, room, overrideLock, false, false));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/rooms/FLASH_ROOM_INFO.java

@@ -0,0 +1,35 @@
+package org.alexdev.havana.messages.flash.incoming.rooms;
+
+import org.alexdev.havana.messages.flash.outgoing.FLASH_FLATINFO;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+public class FLASH_ROOM_INFO implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        int roomId = reader.readInt();
+
+        Room room = RoomManager.getInstance().getRoomById(roomId);
+
+        if (room == null) {
+            return;
+        }
+
+        boolean isLoading = reader.readBoolean();
+        boolean checkEntry = reader.readBoolean();
+        boolean overrideLock = false;
+
+        if (room.isOwner(player.getDetails().getId())) {
+            overrideLock = true;
+        }
+
+        if (player.getRoomUser().getAuthenticateId() == roomId) {
+            overrideLock = true;
+        }
+
+        player.send(new FLASH_FLATINFO(player, room, overrideLock, isLoading, checkEntry));
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/incoming/rooms/FLASH_SAVEWARDROBE.java

@@ -0,0 +1,34 @@
+package org.alexdev.havana.messages.flash.incoming.rooms;
+
+import org.alexdev.havana.dao.mysql.WardrobeDao;
+import org.alexdev.havana.game.player.Wardrobe;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+
+import java.util.List;
+
+public class FLASH_SAVEWARDROBE implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        int slotId = reader.readInt();
+        String figure = reader.readString();
+        String sex = reader.readString().equals("M") ? "M" : "F";
+
+        if (slotId < 1 || slotId > 5) {
+            return;
+        }
+
+        int userId = player.getDetails().getId();
+
+        List<Wardrobe> wardrobeList = WardrobeDao.getWardrobe(userId);
+        Wardrobe wardrobeData = wardrobeList.stream().filter(wardrobe -> wardrobe.getSlotId() == slotId).findFirst().orElse(null);
+
+        if (wardrobeData == null) {
+            WardrobeDao.addWardrobe(userId, slotId, figure, sex);
+        } else {
+            WardrobeDao.updateWardrobe(userId, slotId, figure, sex);
+        }
+
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/FLASH_FLATINFO.java

@@ -0,0 +1,144 @@
+package org.alexdev.havana.messages.flash.outgoing;
+
+import org.alexdev.havana.game.fuserights.Fuseright;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.messages.types.PlayerMessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+import org.apache.commons.lang3.StringUtils;
+
+public class FLASH_FLATINFO extends PlayerMessageComposer {
+    private final Player player;
+    private final Room room;
+    private final boolean isLoading;
+    private final boolean checkEntry;
+    private final boolean overrideLock;
+
+    public FLASH_FLATINFO(Player player, Room room, boolean overrideLock, boolean isLoading, boolean checkEntry) {
+        this.player = player;
+        this.room = room;
+        this.overrideLock = overrideLock;
+        this.isLoading = isLoading;
+        this.checkEntry = checkEntry;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        if (player.getNetwork().isBetaConnected()) {
+            response.writeBool(this.isLoading);
+            response.writeInt(this.room.getId());
+            response.writeBool(this.checkEntry);
+
+            response.writeString(room.getData().getName()); // Room name
+            response.writeString(room.getData().getOwnerName()); // Room owner name
+            response.writeInt(room.getData().getAccessTypeId()); // Accesstype (0 = open, 1 = closed, 2 = password)
+            response.writeInt(room.getData().getVisitorsNow()); // Current visitor amount
+            response.writeInt(room.getData().getVisitorsMax()); // Max visitor amount
+            response.writeString(room.getData().getDescription()); // Room description
+            response.writeInt(0);
+            response.writeBool(room.getCategory().hasAllowTrading()); // can trade
+            response.writeInt(0);
+            response.writeInt(room.getData().getTags().size());
+
+            for (String tag : room.getData().getTags()) {
+                response.writeString(tag);
+            }
+
+            // Icon shit
+            try {
+                String[] iconData = room.getData().getIconData().split("\\|");
+
+                int background = StringUtils.isNumeric(iconData[0]) ? Integer.parseInt(iconData[0]) : 0;
+                int topLayer = StringUtils.isNumeric(iconData[1]) ? Integer.parseInt(iconData[1]) : 0;
+                String[] items = iconData[2].split(" ");
+
+                response.writeInt(background);
+                response.writeInt(topLayer);
+                response.writeInt(items.length);
+
+                for (String data : items) {
+                    try {
+                        String[] iconItems = data.split(",");
+
+                        int iconPosition = StringUtils.isNumeric(iconItems[0]) ? Integer.parseInt(iconItems[0]) : 0;
+                        int iconId = StringUtils.isNumeric(iconItems[1]) ? Integer.parseInt(iconItems[1]) : 0;
+
+                        response.writeInt(iconPosition);
+                        response.writeInt(iconId);
+                    } catch (Exception ex) {
+                        ex.printStackTrace();
+                    }
+                }
+
+            } catch (Exception ex) {
+                response.writeInt(0);
+                response.writeInt(0);
+                response.writeInt(0);
+            }
+        } else {
+            response.writeBool(this.isLoading);
+            response.writeInt(this.room.getId());
+            response.writeBool(this.checkEntry);
+
+            response.writeString(this.room.getData().getName());
+
+            if (this.room.isOwner(player.getDetails().getId()) || this.room.getData().showOwnerName() || this.player.hasFuse(Fuseright.SEE_ALL_ROOMOWNERS)) {
+                response.writeString(this.room.getData().getOwnerName());
+            } else {
+                response.writeString("-");
+            }
+
+            response.writeInt(overrideLock ? 0 : this.room.getData().getAccessTypeId());
+            response.writeInt(this.room.getData().getVisitorsNow());
+            response.writeInt(this.room.getData().getVisitorsMax());
+            response.writeString(this.room.getData().getDescription());
+            response.writeBool(true);
+            response.writeBool(this.room.getCategory().hasAllowTrading()); // Allow trading
+
+            response.writeInt(this.room.getData().getRating()); // Is called "marker" in Lingo code
+            response.writeInt(this.room.getData().getCategoryId());
+            response.writeString("");
+
+            var tags = room.getData().getTags();
+            response.writeInt(tags.size());
+
+            for (String tag : tags) {
+                response.writeString(tag);
+            }
+
+            try {
+                String[] iconData = room.getData().getIconData().split("\\|");
+
+                int background = StringUtils.isNumeric(iconData[0]) ? Integer.parseInt(iconData[0]) : 0;
+                int topLayer = StringUtils.isNumeric(iconData[1]) ? Integer.parseInt(iconData[1]) : 0;
+                String[] items = iconData[2].split(" ");
+
+                response.writeInt(background);
+                response.writeInt(topLayer);
+                response.writeInt(items.length);
+
+                for (String data : items) {
+                    String[] iconItems = data.split(",");
+
+                    int iconPosition = StringUtils.isNumeric(iconItems[0]) ? Integer.parseInt(iconItems[0]) : 0;
+                    int iconId = StringUtils.isNumeric(iconItems[1]) ? Integer.parseInt(iconItems[1]) : 0;
+
+                    response.writeInt(iconPosition);
+                    response.writeInt(iconId);
+                }
+            } catch (Exception ex) {
+                response.writeInt(0);
+                response.writeInt(0);
+                response.writeInt(0);
+            }
+
+            response.writeBool(true);
+        }
+    }
+
+    @Override
+    public short getHeader() {
+        return 454;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/FLASH_ROOMENTRYINFO.java

@@ -0,0 +1,47 @@
+package org.alexdev.havana.messages.flash.outgoing;
+
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.messages.types.PlayerMessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+public class FLASH_ROOMENTRYINFO extends PlayerMessageComposer {
+    private final Player player;
+    private final Room room;
+
+    public FLASH_ROOMENTRYINFO(Player player, Room room) {
+        this.player = player;
+        this.room = room;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        if (this.player.getNetwork().isBetaConnected()) {
+            response.writeInt(this.room.getId());
+            response.writeBool(this.room.isOwner(player.getDetails().getId()));
+            response.writeBool(false);
+            response.writeBool(false);
+        } else {
+            response.writeBool(!this.room.isPublicRoom());
+
+            if (this.room.isPublicRoom()) {
+                response.writeString(this.room.getData().getDescription());
+                response.writeBool(false);
+            } else {
+                response.writeInt(this.room.getId());
+
+                if (this.room.isOwner(player.getDetails().getId())) {
+                    response.writeBool(true);
+                } else {
+                    response.writeBool(false);
+                }
+            }
+        }
+    }
+
+    @Override
+    public short getHeader() {
+        return 471;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/HOME_ROOM.java

@@ -0,0 +1,22 @@
+package org.alexdev.havana.messages.flash.outgoing;
+
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+public class HOME_ROOM extends MessageComposer {
+    private final int roomId;
+
+    public HOME_ROOM(int roomId) {
+        this.roomId = roomId;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeInt(this.roomId);
+    }
+
+    @Override
+    public short getHeader() {
+        return 455;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/modtool/FLASH_MODTOOL.java

@@ -0,0 +1,123 @@
+package org.alexdev.havana.messages.flash.outgoing.modtool;
+
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+import java.util.List;
+
+public class FLASH_MODTOOL extends MessageComposer {
+    private List<String> userMessagePresets;
+    private List<String> roomMessagePresets;
+
+    public FLASH_MODTOOL() {
+        // TODO: Remove this yucky hardcoded bullshit
+        this.userMessagePresets = List.of("test");
+        this.roomMessagePresets = List.of("room preset 1");
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeInt(-1);
+        response.writeInt(this.userMessagePresets.size());
+
+        for (String preset : this.userMessagePresets) {
+            response.writeString(preset);
+        }
+
+        response.writeInt(0);
+        response.writeInt(14);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+
+        response.writeInt(this.roomMessagePresets.size());
+
+        for (String preset : this.roomMessagePresets) {
+            response.writeString(preset);
+        }
+
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeString("test");
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeString("test");
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeInt(1);
+        response.writeString("test");
+    }
+
+    @Override
+    public short getHeader() {
+        return 531;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/modtool/FLASH_MODTOOL_CHATLOG.java

@@ -0,0 +1,41 @@
+package org.alexdev.havana.messages.flash.outgoing.modtool;
+
+import org.alexdev.havana.game.moderation.ChatMessage;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+import org.alexdev.havana.util.StringUtil;
+
+import java.util.Calendar;
+import java.util.List;
+
+public class FLASH_MODTOOL_CHATLOG extends MessageComposer {
+    private final List<ChatMessage> modChatlog;
+    private final Room room;
+
+    public FLASH_MODTOOL_CHATLOG(Room room, List<ChatMessage> modChatlog) {
+        this.room = room;
+        this.modChatlog = modChatlog;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeBool(this.room.isPublicRoom());
+        response.writeInt(this.room.getId());
+        response.writeString(this.room.getData().getName());
+        response.writeInt(this.modChatlog.size());
+
+        for (ChatMessage chatMessage : this.modChatlog) {
+            response.writeInt(chatMessage.getCalendar().get(Calendar.HOUR_OF_DAY));
+            response.writeInt(chatMessage.getCalendar().get(Calendar.MINUTE));
+            response.writeInt(chatMessage.getPlayerId());
+            response.writeString(chatMessage.getPlayerName());
+            response.writeString(StringUtil.filterInput(chatMessage.getMessage(), true));
+        }
+    }
+
+    @Override
+    public short getHeader() {
+        return 535;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/modtool/FLASH_MODTOOL_ROOMDATA.java

@@ -0,0 +1,49 @@
+package org.alexdev.havana.messages.flash.outgoing.modtool;
+
+import org.alexdev.havana.game.events.EventsManager;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+public class FLASH_MODTOOL_ROOMDATA extends MessageComposer {
+    private final Room room;
+
+    public FLASH_MODTOOL_ROOMDATA(Room room) {
+        this.room = room;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeInt(this.room.getId());
+        response.writeInt(this.room.getData().getTotalVisitorsNow()); // user count
+        response.writeBool(this.room.getEntityManager().getPlayers().stream().anyMatch(user -> user.getDetails().getId() == room.getData().getOwnerId()));
+        response.writeInt(this.room.getData().getOwnerId());
+        response.writeString(this.room.getData().getOwnerName());
+        response.writeInt(this.room.getId());
+        response.writeString(this.room.getData().getName());
+        response.writeString(this.room.getData().getDescription());
+        response.writeInt(this.room.getData().getTags().size());
+
+        for (String tag : this.room.getData().getTags()) {
+            response.writeString(tag);
+        }
+
+        var event = EventsManager.getInstance().getEventByRoomId(this.room.getId());
+        response.writeBool(event != null);
+
+        if (event != null) {
+            response.writeString(event.getName());
+            response.writeString(event.getDescription());
+            response.writeInt(event.getTags().size());
+
+            for (String tag : event.getTags()) {
+                response.writeString(tag);
+            }
+        }
+    }
+
+    @Override
+    public short getHeader() {
+        return 538;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/navigator/FLASH_FAVOURITES.java

@@ -0,0 +1,33 @@
+package org.alexdev.havana.messages.flash.outgoing.navigator;
+
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+import java.util.List;
+
+public class FLASH_FAVOURITES extends MessageComposer {
+    private final int limit;
+    private final List<Room> favouriteRooms;
+
+    public FLASH_FAVOURITES(int limit, List<Room> favouriteRooms) {
+        this.limit = limit;
+        this.favouriteRooms = favouriteRooms;
+    }
+
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeInt(this.limit);
+        response.writeInt(this.favouriteRooms.size());
+
+        for (Room room : this.favouriteRooms) {
+            response.writeInt(room.getId());
+        }
+    }
+
+    @Override
+    public short getHeader() {
+        return 458;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/navigator/FLASH_FAVOURITE_STATUS.java

@@ -0,0 +1,25 @@
+package org.alexdev.havana.messages.flash.outgoing.navigator;
+
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+public class FLASH_FAVOURITE_STATUS extends MessageComposer {
+    private int roomId;
+    private boolean isAdded;
+
+    public FLASH_FAVOURITE_STATUS(int roomId, boolean isAdded) {
+        this.roomId = roomId;
+        this.isAdded = isAdded;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeInt(this.roomId);
+        response.writeBool(this.isAdded);
+    }
+
+    @Override
+    public short getHeader() {
+        return 459;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/navigator/FLASH_FLAT_RESULTS.java

@@ -0,0 +1,119 @@
+package org.alexdev.havana.messages.flash.outgoing.navigator;
+
+import org.alexdev.havana.game.events.EventsManager;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+import org.alexdev.havana.util.DateUtil;
+import org.apache.commons.lang3.StringUtils;
+
+import java.text.DateFormat;
+import java.util.List;
+import java.util.Locale;
+
+public class FLASH_FLAT_RESULTS extends MessageComposer {
+    private final List<Room> roomList;
+    private final int mode;
+    private final boolean showEvents;
+
+    public FLASH_FLAT_RESULTS(List<Room> roomList, int mode, boolean showEvents) {
+        this.roomList = roomList;
+        this.mode = mode;
+        this.showEvents = showEvents;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeInt(0);
+        response.writeString("");
+        response.writeInt(this.roomList.size());
+
+        for (Room room : this.roomList) {
+            response.writeInt(room.getData().getId());
+
+            var event = EventsManager.getInstance().getEventByRoomId(room.getId());
+            DateFormat timeFormatter = DateFormat.getTimeInstance(DateFormat.DEFAULT, Locale.US);
+
+            if (this.showEvents && event != null) {
+                response.writeBool(true);
+                response.writeString(event.getName());
+                response.writeString(room.getData().getOwnerName());
+                response.writeInt(room.getData().getAccessTypeId()); // room state
+                response.writeInt(room.getData().getVisitorsNow());
+                response.writeInt(room.getData().getVisitorsMax());
+                response.writeString(room.getData().getDescription());
+                response.writeInt(1);
+                response.writeBool(room.getCategory().hasAllowTrading()); // can trade?
+                response.writeInt(room.getData().getRating());
+                response.writeInt(event.getCategoryId());
+                response.writeString(DateUtil.getDate(event.getExpireTime() - EventsManager.getEventLifetime(), "hh:mm a").replace(".", "").toUpperCase());
+
+                var tags = room.getData().getTags();
+                response.writeInt(tags.size());
+
+                for (String tag : tags) {
+                    response.writeString(tag);
+                }
+            } else {
+                response.writeBool(false);
+                response.writeString(room.getData().getName());
+                response.writeString(room.getData().getOwnerName());
+                response.writeInt(room.getData().getAccessTypeId()); // room state
+                response.writeInt(room.getData().getVisitorsNow());
+                response.writeInt(room.getData().getVisitorsMax());
+                response.writeString(room.getData().getDescription());
+                response.writeInt(1);
+                response.writeBool(room.getCategory().hasAllowTrading()); // can trade?
+                response.writeInt(room.getData().getRating());
+                response.writeInt(room.getData().getCategoryId());
+                response.writeString("");
+
+                var tags = room.getData().getTags();
+                response.writeInt(tags.size());
+
+                for (String tag : tags) {
+                    response.writeString(tag);
+                }
+            }
+
+
+            try {
+                String[] iconData = room.getData().getIconData().split("\\|");
+
+                int background = StringUtils.isNumeric(iconData[0]) ? Integer.parseInt(iconData[0]) : 0;
+                int topLayer = StringUtils.isNumeric(iconData[1]) ? Integer.parseInt(iconData[1]) : 0;
+                String[] items = iconData[2].split(" ");
+
+                response.writeInt(background);
+                response.writeInt(topLayer);
+                response.writeInt(items.length);
+
+                for (String data : items) {
+                    try {
+                        String[] iconItems = data.split(",");
+
+                        int iconPosition = StringUtils.isNumeric(iconItems[0]) ? Integer.parseInt(iconItems[0]) : 0;
+                        int iconId = StringUtils.isNumeric(iconItems[1]) ? Integer.parseInt(iconItems[1]) : 0;
+
+                        response.writeInt(iconPosition);
+                        response.writeInt(iconId);
+                    } catch (Exception ex) {
+                        ex.printStackTrace();
+                    }
+                }
+
+            } catch (Exception ex) {
+                response.writeInt(0);
+                response.writeInt(0);
+                response.writeInt(0);
+            }
+
+            //response.writeBool(false);
+        }
+    }
+
+    @Override
+    public short getHeader() {
+        return 451;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/navigator/FLASH_FRONTPAGERESULT.java

@@ -0,0 +1,48 @@
+package org.alexdev.havana.messages.flash.outgoing.navigator;
+
+import org.alexdev.havana.game.navigator.NavigatorManager;
+import org.alexdev.havana.game.navigator.NavigatorStyle;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+import java.util.List;
+
+public class FLASH_FRONTPAGERESULT extends MessageComposer {
+    private final List<Room> roomList;
+
+    public FLASH_FRONTPAGERESULT(List<Room> roomList) {
+        this.roomList = roomList;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeInt(1);
+        response.writeString("Public Rooms");
+
+        response.writeInt(this.roomList.size());
+
+        for (Room room : this.roomList) {
+            NavigatorStyle navigatorStyle = NavigatorManager.getInstance().getNavigatorStyle(room.getId());
+            response.writeString(room.getData().getName());
+            response.writeString(navigatorStyle.getDescription());
+            response.writeInt(navigatorStyle.getThumbnailLayout()); // type??
+            response.writeString(room.getData().getName());
+            response.writeString(navigatorStyle.getThumbnailUrl());
+            response.writeInt(room.getData().getTotalVisitorsNow()); // users now
+            response.writeInt(3); // public listing type
+            response.writeString(navigatorStyle.getThumbnailUrl());
+            response.writeInt(room.getData().getId());
+            response.writeInt(0);
+            response.writeString(room.getData().getCcts());
+            response.writeInt(room.getData().getTotalVisitorsMax()); // max users
+            response.writeInt(room.getId()); // room id
+        }
+
+    }
+
+    @Override
+    public short getHeader() {
+        return 450;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/navigator/FLASH_GET_GUEST_ROOM_RESULT.java

@@ -0,0 +1,143 @@
+package org.alexdev.havana.messages.flash.outgoing.navigator;
+
+import org.alexdev.havana.game.events.EventsManager;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+import org.alexdev.havana.util.DateUtil;
+import org.apache.commons.lang3.StringUtils;
+
+import java.text.DateFormat;
+import java.util.List;
+import java.util.Locale;
+
+public class FLASH_GET_GUEST_ROOM_RESULT extends MessageComposer {
+    private final int forceDisplay;
+    private final int opCode;
+    private final List<Room> roomList;
+
+    public FLASH_GET_GUEST_ROOM_RESULT(int forceDisplay, int opCode, List<Room> roomList) {
+        this.forceDisplay = forceDisplay;
+        this.opCode = opCode;
+        this.roomList = roomList;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        /*response.writeInt(0);
+        response.writeString("");
+        response.writeInt(this.roomList.size());
+
+        for (Room room : this.roomList) {*/
+        response.writeInt(this.forceDisplay);
+        response.writeInt(this.opCode);
+        response.writeString("");
+
+        response.writeInt(this.roomList.size());
+
+        for (Room room : this.roomList) {
+            serialise(response, room);
+        }
+
+       /* response.writeInt(1000); // Room ID
+        response.writeBool(false);
+        response.writeString("Room 1"); // Room name
+        response.writeString("Alex"); // Room owner name
+        response.writeInt(0); // Accesstype (0 = open, 1 = closed, 2 = password)
+        response.writeInt(0); // Current visitor amount
+        response.writeInt(25); // Max visitor amount
+        response.writeString("Description"); // Room description
+        response.writeInt(0);
+        response.writeBool(false);
+        response.writeInt(0);
+        response.writeInt(0);
+        response.writeString("tag1");
+        response.writeString("tag2");
+        response.writeInt(0);
+        response.writeInt(0);
+        response.writeInt(0);*/
+
+        /*response.writeInt(0);
+        response.writeInt(0);
+        response.writeInt(0);
+        response.writeInt(2); // Icon ID?
+        response.writeString("Category"); // Room category name
+        response.writeString("tag1");
+        response.writeString("tag2");
+        response.writeBool(false);
+
+        response.writeInt(1001); // Room ID
+        response.writeInt(0);
+        response.writeString("Room 1"); // Room name
+        response.writeString("Alex"); // Room owner name
+        response.writeInt(0); // Accesstype (0 = open, 1 = closed, 2 = password)
+        response.writeInt(0); // Current visitor amount
+        response.writeInt(25); // Max visitor amount
+        response.writeString("Description"); // Room description
+        response.writeInt(0);
+        response.writeInt(0);
+        response.writeInt(0);
+        response.writeInt(2); // Icon ID?
+        response.writeString("Category"); // Room category name
+        response.writeString("tag1");
+        response.writeString("tag2");
+        response.writeBool(false);*/
+        //}
+    }
+
+    public static void serialise(NettyResponse response, Room room) {
+        response.writeInt(room.getId()); // Room ID
+        response.writeBool(false); // Is event
+        response.writeString(room.getData().getName()); // Room name
+        response.writeString(room.getData().getOwnerName()); // Room owner name
+        response.writeInt(room.getData().getAccessTypeId()); // Accesstype (0 = open, 1 = closed, 2 = password)
+        response.writeInt(room.getData().getVisitorsNow()); // Current visitor amount
+        response.writeInt(room.getData().getVisitorsMax()); // Max visitor amount
+        response.writeString(room.getData().getDescription()); // Room description
+        response.writeInt(0);
+        response.writeBool(room.getCategory().hasAllowTrading()); // can trade
+        response.writeInt(0);
+        response.writeInt(room.getData().getTags().size());
+
+        for (String tag : room.getData().getTags()) {
+            response.writeString(tag);
+        }
+
+        // Icon shit
+        try {
+            String[] iconData = room.getData().getIconData().split("\\|");
+
+            int background = StringUtils.isNumeric(iconData[0]) ? Integer.parseInt(iconData[0]) : 0;
+            int topLayer = StringUtils.isNumeric(iconData[1]) ? Integer.parseInt(iconData[1]) : 0;
+            String[] items = iconData[2].split(" ");
+
+            response.writeInt(background);
+            response.writeInt(topLayer);
+            response.writeInt(items.length);
+
+            for (String data : items) {
+                try {
+                    String[] iconItems = data.split(",");
+
+                    int iconPosition = StringUtils.isNumeric(iconItems[0]) ? Integer.parseInt(iconItems[0]) : 0;
+                    int iconId = StringUtils.isNumeric(iconItems[1]) ? Integer.parseInt(iconItems[1]) : 0;
+
+                    response.writeInt(iconPosition);
+                    response.writeInt(iconId);
+                } catch (Exception ex) {
+                    ex.printStackTrace();
+                }
+            }
+
+        } catch (Exception ex) {
+            response.writeInt(0);
+            response.writeInt(0);
+            response.writeInt(0);
+        }
+    }
+
+    @Override
+    public short getHeader() {
+        return 451;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/navigator/FLASH_SEARCHRESULTS.java

@@ -0,0 +1,58 @@
+package org.alexdev.havana.messages.flash.outgoing.navigator;
+
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+import java.util.List;
+
+public class FLASH_SEARCHRESULTS extends MessageComposer {
+    private final List<Room> roomList;
+    private final String searchQuery;
+
+    public FLASH_SEARCHRESULTS(List<Room> roomList, String searchQuery) {
+        this.roomList = roomList;
+        this.searchQuery = searchQuery;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeInt(1);
+        response.writeInt(9);
+        response.writeString(this.searchQuery);
+
+        response.writeInt(this.roomList.size());
+
+        for (Room room : this.roomList) {
+            response.writeInt(room.getData().getId());
+            response.writeBool(false);
+            response.writeString(room.getData().getName());
+            response.writeString(room.getData().getOwnerName());
+            response.writeInt(room.getData().getAccessTypeId()); // room state
+            response.writeInt(room.getData().getVisitorsNow());
+            response.writeInt(room.getData().getVisitorsMax());
+            response.writeString(room.getData().getDescription());
+            response.writeInt(1);
+            response.writeBool(room.getCategory().hasAllowTrading()); // can trade?
+            response.writeInt(room.getData().getRating());
+            response.writeInt(0);
+            response.writeString("");
+
+            var tags = room.getData().getTags();
+            response.writeInt(tags.size());
+
+            for (String tag : tags) {
+                response.writeString(tag);
+            }
+
+            response.writeInt(0);
+            response.writeInt(0);
+            response.writeInt(0);
+        }
+    }
+
+    @Override
+    public short getHeader() {
+        return 451;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/navigator/beta/BETA_FLASH_FRONTPAGERESULT.java

@@ -0,0 +1,66 @@
+package org.alexdev.havana.messages.flash.outgoing.navigator.beta;
+
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_GET_GUEST_ROOM_RESULT;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+import java.util.List;
+import java.util.Map;
+
+public class BETA_FLASH_FRONTPAGERESULT extends MessageComposer {
+    private final List<Room> roomList;
+    private final int popularRoomCount;
+    private final int friendsInRoomCount;
+    private final int myRoomsCount;
+    private final int favouriteRoomsCount;
+    private final Map<String, Integer> categoryList;
+
+    public BETA_FLASH_FRONTPAGERESULT(List<Room> roomList, int popularRoomCount, int friendsInRoomCount, int myRoomsCount, int favouriteRoomsCount, Map<String, Integer> categoryList) {
+        this.roomList = roomList;
+        this.popularRoomCount = popularRoomCount;
+        this.friendsInRoomCount = friendsInRoomCount;
+        this.myRoomsCount = myRoomsCount;
+        this.favouriteRoomsCount = favouriteRoomsCount;
+        this.categoryList = categoryList;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeInt(this.roomList.size()); // Amount
+
+        for (var room : this.roomList) {
+            FLASH_GET_GUEST_ROOM_RESULT.serialise(response, room);
+        }
+
+        response.writeBool(false);
+        response.writeInt(-1);
+        response.writeBool(false);
+
+        response.writeInt(4);
+
+        response.writeInt(1); // nav category id
+        response.writeInt(this.popularRoomCount); // room population
+
+        response.writeInt(4); // nav category id
+        response.writeInt(this.friendsInRoomCount); // room population
+
+        response.writeInt(5); // nav category id
+        response.writeInt(this.myRoomsCount); // room population
+
+        response.writeInt(6); // nav category id
+        response.writeInt(this.favouriteRoomsCount); // room population
+
+        response.writeInt(this.categoryList.size()); // categories
+
+        for (var kvp : this.categoryList.entrySet()) {
+            response.writeString(kvp.getKey());
+            response.writeInt(kvp.getValue());
+        }
+    }
+
+    @Override
+    public short getHeader() {
+        return 450;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/rooms/FLASH_EDITDATA.java

@@ -0,0 +1,54 @@
+package org.alexdev.havana.messages.flash.outgoing.rooms;
+
+import org.alexdev.havana.game.player.PlayerDetails;
+import org.alexdev.havana.game.player.PlayerManager;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+public class FLASH_EDITDATA extends MessageComposer {
+    private final Room room;
+
+    public FLASH_EDITDATA(Room room) {
+        this.room = room;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeInt(this.room.getData().getId());
+        response.writeString(this.room.getData().getName());
+        response.writeString(this.room.getData().getDescription());
+        response.writeInt(this.room.getData().getAccessTypeId());
+        response.writeInt(this.room.getData().getCategoryId());
+        response.writeInt(this.room.getData().getVisitorsMax());
+        response.writeInt(this.room.getData().getVisitorsMax());
+
+        response.writeBool(false);
+        response.writeBool(false);
+        response.writeBool(false);
+
+        var tags = room.getData().getTags();
+        response.writeInt(tags.size());
+
+        for (String tag : tags) {
+            response.writeString(tag);
+        }
+
+
+        response.writeInt(this.room.getRights().size());
+
+        for (int userId : this.room.getRights()) {
+            PlayerDetails playerDetails = PlayerManager.getInstance().getPlayerData(userId);
+
+            response.writeInt(userId);
+            response.writeString(playerDetails.getName());
+        }
+
+        response.writeInt(this.room.getRights().size());
+    }
+
+    @Override
+    public short getHeader() {
+        return 465;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/rooms/FLASH_PUBLICROOMCASTS.java

@@ -0,0 +1,26 @@
+package org.alexdev.havana.messages.flash.outgoing.rooms;
+
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+public class FLASH_PUBLICROOMCASTS extends MessageComposer {
+    private final int roomId;
+    private final String ccts;
+
+    public FLASH_PUBLICROOMCASTS(int roomId, String ccts) {
+        this.roomId = roomId;
+        this.ccts = ccts;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeInt(this.roomId);
+        response.writeString(this.ccts);
+        response.writeInt(this.roomId);
+    }
+
+    @Override
+    public short getHeader() {
+        return 453;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/flash/outgoing/rooms/WARDROBE.java

@@ -0,0 +1,32 @@
+package org.alexdev.havana.messages.flash.outgoing.rooms;
+
+import org.alexdev.havana.game.player.Wardrobe;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+import java.util.List;
+
+public class WARDROBE extends MessageComposer {
+    private final List<Wardrobe> wardrobe;
+
+    public WARDROBE(List<Wardrobe> wardrobe) {
+        this.wardrobe = wardrobe;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeBool(false);
+        response.writeInt(this.wardrobe.size());
+
+        for (var wardrobeItem : this.wardrobe) {
+            response.writeInt(wardrobeItem.getSlotId());
+            response.writeString(wardrobeItem.getFigure());
+            response.writeString(wardrobeItem.getSex());
+        }
+    }
+
+    @Override
+    public short getHeader() {
+        return 267;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/catalogue/GRPC.java

@@ -210,7 +210,7 @@ public class GRPC implements MessageEvent {
             if (items.size() == 0 && !(itemDefinition != null && (itemDefinition.hasBehaviour(ItemBehaviour.EFFECT) || itemDefinition.getSprite().equals("film"))))
                 return;
 
-            boolean showItemDelivered = player.getRoomUser().getRoom() != null;
+            boolean showItemDelivered = player.getNetwork().isFlashConnection() || player.getRoomUser().getRoom() != null;
 
             // Don't send item delivered if they just buy film
             if (item.getDefinition() != null && item.getDefinition().getSprite().equals("film")) {

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/events/CREATE_ROOMEVENT.java

@@ -28,7 +28,21 @@ public class CREATE_ROOMEVENT implements MessageEvent {
         String name = WordfilterManager.filterSentence(StringUtil.filterInput(reader.readString(), true));
         String description = WordfilterManager.filterSentence(StringUtil.filterInput(reader.readString(), true));
 
-        Event event = EventsManager.getInstance().createEvent(player, category, name, description, new ArrayList<>());
+        List<String> tags = new ArrayList<>();
+
+        if (player.getNetwork().isFlashConnection()) {
+            int amount = reader.readInt();
+
+            for (int i = 0; i < amount; i++) {
+                if (i > 1) {
+                    break;
+                }
+
+                tags.add(StringUtil.filterInput(reader.readString(), true).replace(",", " "));
+            }
+        }
+
+        Event event = EventsManager.getInstance().createEvent(player, category, name, description, tags);
         player.getRoomUser().getRoom().send(new ROOMEEVENT_INFO(event));
     }
 }

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/events/EDIT_ROOMEVENT.java

@@ -50,6 +50,23 @@ public class EDIT_ROOMEVENT implements MessageEvent {
         event.setName(name);
         event.setDescription(description);
 
+        List<String> tags = new ArrayList<>();
+
+        if (player.getNetwork().isFlashConnection()) {
+            int amount = reader.readInt();
+
+            for (int i = 0; i < amount; i++) {
+                if (i > 1) {
+                    break;
+                }
+
+                tags.add(StringUtil.filterInput(reader.readString(), true).replace(",", " "));
+            }
+
+            event.getTags().clear();
+            event.getTags().addAll(tags);
+        }
+
         room.send(new ROOMEEVENT_INFO(event));
         EventsDao.save(event);
     }

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/handshake/GET_FURNI_VERSIONS.java

@@ -0,0 +1,35 @@
+package org.alexdev.havana.messages.incoming.handshake;
+
+import org.alexdev.havana.game.item.ItemVersionManager;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+public class GET_FURNI_VERSIONS implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        if (player.getNetwork().isFlashConnection())
+            return;
+
+        var itemVersions = ItemVersionManager.getInstance().getItemVersions();
+
+        player.send(new MessageComposer() {
+            @Override
+            public void compose(NettyResponse response) {
+                response.writeInt(itemVersions.size());
+
+                for (var kvp : itemVersions.entrySet()) {
+                    response.writeString(kvp.getKey());
+                    response.writeInt(kvp.getValue());
+                }
+            }
+
+            @Override
+            public short getHeader() {
+                return 495;
+            }
+        });
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/handshake/INIT_CRYPTO.java

@@ -4,6 +4,7 @@ import org.alexdev.havana.game.GameScheduler;
 import org.alexdev.havana.game.encryption.DiffieHellman;
 import org.alexdev.havana.game.player.Player;
 import org.alexdev.havana.messages.outgoing.handshake.CRYPTO_PARAMETERS;
+import org.alexdev.havana.messages.outgoing.handshake.SESSION_PARAMETERS;
 import org.alexdev.havana.messages.types.MessageEvent;
 import org.alexdev.havana.server.netty.streams.NettyRequest;
 
@@ -17,10 +18,23 @@ public class INIT_CRYPTO implements MessageEvent {
             return;
         }
 
+        //String prime = Util.getRSA().sign(dh.getPrime().toString());
+        //String generator = Util.getRSA().sign(dh.getGenerator().toString());
+
+        //player.sendObject("DAQBHIIIKHJIPAIQAdd-MM-yyyy\u0002SAHPB/client\u0002QBHIJWVVVSNKQCFUBJASMSLKUUOJCOLJQPNSBIRSVQBRXZQOTGPMNJIHLVJCRRULBLUO" + (char)1);
+
+
         String pToken = DiffieHellman.generateRandomNumString(24);
 
-        player.send(new CRYPTO_PARAMETERS(pToken));
+        if (player.getNetwork().isFlashConnection()) {
-        player.getNetwork().setToken(pToken);
+            player.send(new SESSION_PARAMETERS(player.getDetails()));
-    }
+        } else {
+            player.send(new CRYPTO_PARAMETERS(pToken));
+            player.getNetwork().setToken(pToken);
 
+            // Try again
+            // this.retrySend(player);
+        }
+
+    }
 }

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/navigator/ADD_FAVORITE_ROOM.java

@@ -4,6 +4,7 @@ import org.alexdev.havana.dao.mysql.RoomFavouritesDao;
 import org.alexdev.havana.game.player.Player;
 import org.alexdev.havana.game.room.Room;
 import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_FAVOURITE_STATUS;
 import org.alexdev.havana.messages.types.MessageEvent;
 import org.alexdev.havana.server.netty.streams.NettyRequest;
 
@@ -14,25 +15,32 @@ public class ADD_FAVORITE_ROOM implements MessageEvent {
 
     @Override
     public void handle(Player player, NettyRequest reader) throws Exception {
-        int roomType = reader.readInt();
+        int roomId = -1;
-        int roomId = reader.readInt();
 
-        if (roomType == 1) {
+        if (!player.getNetwork().isFlashConnection()) {
-            roomId = (roomId - RoomManager.PUBLIC_ROOM_OFFSET);
+            int roomType = reader.readInt();
-        }
+            roomId = reader.readInt();
 
-        Room room = RoomManager.getInstance().getRoomById(roomId);
+            if (roomType == 1) {
-
+                roomId = (roomId - RoomManager.PUBLIC_ROOM_OFFSET);
-        if (room == null) {
-            return; // Room was null, ignore request
-        }
-
-        List<Room> favouritesList = RoomManager.getInstance().getFavouriteRooms(player.getDetails().getId(), false);
-
-        for (Room favroom : favouritesList) {
-            if (favroom.getId() == roomId) {
-                return; // Room already added, ignore request
             }
+
+            Room room = RoomManager.getInstance().getRoomById(roomId);
+
+            if (room == null) {
+                return; // Room was null, ignore request
+            }
+
+            List<Room> favouritesList = RoomManager.getInstance().getFavouriteRooms(player.getDetails().getId(), false);
+
+            for (Room favroom : favouritesList) {
+                if (favroom.getId() == roomId) {
+                    return; // Room already added, ignore request
+                }
+            }
+        } else {
+            reader.readInt();
+            roomId = reader.readInt();
         }
 
         if (RoomManager.getInstance().getRoomById(roomId) == null) {
@@ -49,5 +57,9 @@ public class ADD_FAVORITE_ROOM implements MessageEvent {
         }
 
         RoomFavouritesDao.addFavouriteRoom(player.getDetails().getId(), roomId);
+
+        if (player.getNetwork().isFlashConnection()) {
+            player.send(new FLASH_FAVOURITE_STATUS(roomId, true));
+        }
     }
 }

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/navigator/DEL_FAVORITE_ROOM.java

@@ -3,19 +3,31 @@ package org.alexdev.havana.messages.incoming.navigator;
 import org.alexdev.havana.dao.mysql.RoomFavouritesDao;
 import org.alexdev.havana.game.player.Player;
 import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.navigator.FLASH_FAVOURITE_STATUS;
 import org.alexdev.havana.messages.types.MessageEvent;
 import org.alexdev.havana.server.netty.streams.NettyRequest;
 
 public class DEL_FAVORITE_ROOM implements MessageEvent {
     @Override
     public void handle(Player player, NettyRequest reader) throws Exception {
-        int roomType = reader.readInt();
+        int roomId = -1;
-        int roomId = reader.readInt();
 
-        if (roomType == 1) {
+        if (!player.getNetwork().isFlashConnection()) {
-            roomId = (roomId - RoomManager.PUBLIC_ROOM_OFFSET);
+            int roomType = reader.readInt();
+            roomId = reader.readInt();
+
+            if (roomType == 1) {
+                roomId = (roomId - RoomManager.PUBLIC_ROOM_OFFSET);
+            }
+        } else {
+            reader.readInt();
+            roomId = reader.readInt();
         }
 
         RoomFavouritesDao.removeFavouriteRoom(player.getDetails().getId(), roomId);
+
+        if (player.getNetwork().isFlashConnection()) {
+            player.send(new FLASH_FAVOURITE_STATUS(roomId, false));
+        }
     }
 }

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/rooms/GETROOMAD.java

@@ -1,14 +1,19 @@
 package org.alexdev.havana.messages.incoming.rooms;
 
-import org.alexdev.havana.game.ads.AdManager;
 import org.alexdev.havana.game.ads.Advertisement;
 import org.alexdev.havana.game.player.Player;
 import org.alexdev.havana.game.room.Room;
-import org.alexdev.havana.messages.outgoing.rooms.ROOMAD;
+import org.alexdev.havana.game.ads.AdManager;
+import org.alexdev.havana.messages.flash.outgoing.FLASH_FLATINFO;
+import org.alexdev.havana.messages.flash.outgoing.FLASH_ROOMENTRYINFO;
+import org.alexdev.havana.messages.outgoing.rooms.*;
+import org.alexdev.havana.messages.outgoing.rooms.user.USER_OBJECTS;
 import org.alexdev.havana.messages.types.MessageEvent;
 import org.alexdev.havana.server.netty.streams.NettyRequest;
 import org.alexdev.havana.util.config.GameConfiguration;
 
+import java.util.List;
+
 public class GETROOMAD implements MessageEvent {
     @Override
     public void handle(Player player, NettyRequest reader) throws Exception {
@@ -46,6 +51,35 @@ public class GETROOMAD implements MessageEvent {
 
         player.send(new ROOMAD(image, url));
 
+        if (player.getNetwork().isFlashConnection()) {
+            player.send(new OBJECTS_WORLD(room.getItemManager().getPublicItems()));
+            player.send(new ITEMS(room));
+            player.send(new ACTIVE_OBJECTS(room));
+
+            player.getMessenger().sendStatusUpdate();
+
+            player.send(new USER_OBJECTS(room.getEntities()));
+            room.send(new USER_OBJECTS(player));
+
+            player.send(new FLASH_ROOMENTRYINFO(player, room));
+
+            if (!room.isPublicRoom()) {
+                player.send(new FLASH_FLATINFO(player, room, false, true, false));
+            }
+
+            if (player.getNetwork().isBetaConnected()) {
+                player.send(new HEIGHTMAP(player.getRoomUser().getRoom().getModel()));
+                player.send(new FLOOR_MAP(player.getRoomUser().getRoom().getModel()));
+
+                if (!player.getRoomUser().getRoom().isPublicRoom()) {
+                    player.send(new HEIGHTMAP_UPDATE(player.getRoomUser().getRoom(), player.getRoomUser().getRoom().getModel()));
+                }
+
+                player.send(new USER_OBJECTS(List.of()));
+            }
+
+            new G_STAT().handle(player, null);
+        }
 
         /*player.send(new MessageComposer() {
             @Override

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/rooms/G_HMAP.java

@@ -40,5 +40,15 @@ public class G_HMAP implements MessageEvent {
 
             return;
         }
+
+        if (player.getNetwork().isFlashConnection()) {
+            player.send(new FLOOR_MAP(player.getRoomUser().getRoom().getModel()));
+
+            if (!player.getRoomUser().getRoom().isPublicRoom()) {
+                player.send(new HEIGHTMAP_UPDATE(player.getRoomUser().getRoom(), player.getRoomUser().getRoom().getModel()));
+            }
+
+            player.send(new USER_OBJECTS(List.of()));
+        }
     }
 }

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/rooms/G_STAT.java

@@ -90,6 +90,12 @@ public class G_STAT implements MessageEvent {
             if (roomEntity.getRoomUser().isSleeping()) {
                 player.send(new USER_SLEEP(roomEntity.getRoomUser().getInstanceId(), roomEntity.getRoomUser().isSleeping()));
             }
+
+            if (player.getNetwork().isFlashConnection()) {
+                if (roomEntity.getRoomUser().isCarrying()) {
+                    player.send(new USER_CARRY_OBJECT(roomEntity.getRoomUser().getInstanceId(), roomEntity.getRoomUser().getCarryId(), roomEntity.getRoomUser().getCarryValue()));
+                }
+            }
         }
 
         for (Item item : room.getItems()) {

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/rooms/items/PLACESTUFF.java

@@ -176,6 +176,11 @@ public class PLACESTUFF implements MessageEvent {
         room.getMapping().addItem(player, item);
 
         player.getInventory().getItems().remove(item);
+
+        if (player.getNetwork().isFlashConnection()) {
+            player.getInventory().getView("new");
+        }
+
         player.getRoomUser().getTimerManager().resetRoomTimer();
     }
 }

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/rooms/items/REMOVEITEM.java

@@ -44,6 +44,10 @@ public class REMOVEITEM implements MessageEvent {
         room.getMapping().pickupItem(player, item);
         item.delete();
 
+        if (player.getNetwork().isFlashConnection()) {
+            player.getInventory().getView("new");
+        }
+
         player.getRoomUser().getTimerManager().resetRoomTimer();
     }
 }

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/rooms/moderation/ASSIGNRIGHTS.java

@@ -24,7 +24,13 @@ public class ASSIGNRIGHTS implements MessageEvent {
             return;
         }
 
-        Player target = PlayerManager.getInstance().getPlayerByName(reader.contents());
+        Player target = null;
+
+        if (!player.getNetwork().isFlashConnection()) {
+            target = PlayerManager.getInstance().getPlayerByName(reader.contents());
+        } else {
+            target = PlayerManager.getInstance().getPlayerById(reader.readInt());
+        }
 
         if (target == null || target.getRoomUser().getRoom() == null || target.getRoomUser().getRoom().getId() != room.getId()) {
             return;

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/rooms/moderation/BANUSER.java

@@ -17,13 +17,18 @@ import java.util.concurrent.TimeUnit;
 public class BANUSER implements MessageEvent {
     @Override
     public void handle(Player player, NettyRequest reader) throws Exception {
+        Player target = null;//PlayerManager.getInstance().getPlayerByName(playerName);
         Room room = player.getRoomUser().getRoom();
 
         if (room == null) {
             return;
         }
 
-        Player target = PlayerManager.getInstance().getPlayerByName(reader.contents());
+        if (!player.getNetwork().isFlashConnection()) {
+            target = PlayerManager.getInstance().getPlayerByName(reader.contents());
+        } else {
+            target = PlayerManager.getInstance().getPlayerById(reader.readInt());
+        }
 
         if (target == null || target.getRoomUser().getRoom() == null || target.getRoomUser().getRoom().getId() != room.getId()) {
             return;

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/rooms/moderation/KICK.java

@@ -13,13 +13,18 @@ import org.alexdev.havana.server.netty.streams.NettyRequest;
 public class KICK implements MessageEvent {
     @Override
     public void handle(Player player, NettyRequest reader) throws Exception {
+        Player target = null;//PlayerManager.getInstance().getPlayerByName(playerName);
         Room room = player.getRoomUser().getRoom();
 
         if (room == null) {
             return;
         }
 
-        Player target = PlayerManager.getInstance().getPlayerByName(reader.contents());
+        if (!player.getNetwork().isFlashConnection()) {
+            target = PlayerManager.getInstance().getPlayerByName(reader.contents());
+        } else {
+            target = PlayerManager.getInstance().getPlayerById(reader.readInt());
+        }
 
         if (target == null || target.getRoomUser().getRoom() == null || target.getRoomUser().getRoom().getId() != room.getId()) {
             return;

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/rooms/moderation/REMOVEALLRIGHTS.java

@@ -5,6 +5,7 @@ import org.alexdev.havana.game.fuserights.Fuseright;
 import org.alexdev.havana.game.player.Player;
 import org.alexdev.havana.game.room.Room;
 import org.alexdev.havana.game.room.RoomManager;
+import org.alexdev.havana.messages.flash.outgoing.rooms.FLASH_EDITDATA;
 import org.alexdev.havana.messages.types.MessageEvent;
 import org.alexdev.havana.server.netty.streams.NettyRequest;
 
@@ -30,5 +31,9 @@ public class REMOVEALLRIGHTS implements MessageEvent {
         }
 
         RoomRightsDao.deleteRoomRights(room.getData());
+
+        if (player.getNetwork().isFlashConnection()) {
+            player.send(new FLASH_EDITDATA(room));
+        }
     }
 }

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/rooms/moderation/REMOVERIGHTS.java

@@ -6,9 +6,11 @@ import org.alexdev.havana.game.fuserights.Fuseright;
 import org.alexdev.havana.game.player.Player;
 import org.alexdev.havana.game.player.PlayerManager;
 import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.flash.outgoing.rooms.FLASH_EDITDATA;
 import org.alexdev.havana.messages.types.MessageEvent;
 import org.alexdev.havana.server.netty.streams.NettyRequest;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class REMOVERIGHTS implements MessageEvent {
@@ -25,7 +27,18 @@ public class REMOVERIGHTS implements MessageEvent {
         }
 
 
-        List<Integer> targets = List.of(PlayerDao.getId(reader.contents()));
+        List<Integer> targets = null;
+
+        if (!player.getNetwork().isFlashConnection()) {
+            targets = List.of(PlayerDao.getId(reader.contents()));
+        } else {
+            targets = new ArrayList<>();// = PlayerManager.getInstance().getPlayerById(reader.readInt());
+
+            int remove = reader.readInt();
+            for (int i = 0; i < remove; i++) {
+                targets.add(reader.readInt());
+            }
+        }
 
         for (int targetId : targets) {
             if (!room.getRights().contains(targetId)) {
@@ -35,7 +48,7 @@ public class REMOVERIGHTS implements MessageEvent {
             var target = PlayerManager.getInstance().getPlayerById(targetId);
 
             if (target != null) {
-                if (target.getRoomUser().getRoom() == null || target.getRoomUser().getRoom().getId() != room.getId()) {
+                if (target == null || target.getRoomUser().getRoom() == null || target.getRoomUser().getRoom().getId() != room.getId()) {
                     continue;
                 }
 
@@ -45,5 +58,9 @@ public class REMOVERIGHTS implements MessageEvent {
             room.getRights().remove(Integer.valueOf(targetId));
             RoomRightsDao.removeRights(targetId, room.getData());
         }
+
+        if (player.getNetwork().isFlashConnection()) {
+            player.send(new FLASH_EDITDATA(room));
+        }
     }
 }

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/rooms/settings/DELETEFLAT.java

@@ -8,6 +8,7 @@ import org.alexdev.havana.game.player.Player;
 import org.alexdev.havana.game.room.Room;
 import org.alexdev.havana.game.room.RoomManager;
 import org.alexdev.havana.log.Log;
+import org.alexdev.havana.messages.flash.incoming.navigator.FLASH_USERFLATS;
 import org.alexdev.havana.messages.types.MessageEvent;
 import org.alexdev.havana.server.netty.streams.NettyRequest;
 
@@ -20,6 +21,10 @@ public class DELETEFLAT implements MessageEvent {
     public void handle(Player player, NettyRequest reader) throws Exception {
         int roomId = reader.readInt();
         delete(roomId, player.getDetails().getId());
+
+        if (player.getNetwork().isFlashConnection()) {
+            new FLASH_USERFLATS().handle(player, null);
+        }
     }
 
     public static void delete(int roomId, int userId) throws SQLException {

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/rooms/user/CHANGE_LOOKS.java

@@ -0,0 +1,45 @@
+package org.alexdev.havana.messages.incoming.rooms.user;
+
+import org.alexdev.havana.dao.mysql.PlayerDao;
+import org.alexdev.havana.game.misc.figure.FigureManager;
+import org.alexdev.havana.game.player.Player;
+import org.alexdev.havana.game.room.Room;
+import org.alexdev.havana.messages.types.MessageEvent;
+import org.alexdev.havana.server.netty.streams.NettyRequest;
+import org.alexdev.havana.util.StringUtil;
+
+public class CHANGE_LOOKS implements MessageEvent {
+    @Override
+    public void handle(Player player, NettyRequest reader) throws Exception {
+        Room room = player.getRoomUser().getRoom();
+
+        if (room == null) {
+            return;
+        }
+
+        if (!player.getNetwork().isFlashConnection()) {
+            return;
+        }
+
+        String gender = StringUtil.filterInput(reader.readString(), true);
+        String figure = StringUtil.filterInput(reader.readString(), true);
+
+        if (!gender.equals("M") && !gender.equals("F")) {
+            return;
+        }
+
+        if (!FigureManager.getInstance().validateFigure(figure, gender, player.getDetails().hasClubSubscription())) {
+            return;
+        }
+
+        player.getDetails().setFigure(figure);
+        player.getDetails().setSex(gender);
+
+        PlayerDao.saveDetails(player.getDetails().getId(),
+                player.getDetails().getFigure(),
+                player.getDetails().getPoolFigure(),
+                player.getDetails().getSex());
+
+        player.getRoomUser().refreshAppearance();
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/rooms/user/QUIT.java

@@ -15,6 +15,12 @@ public class QUIT implements MessageEvent {
         player.getRoomUser().setAuthenticateTelporterId(-1);
         player.getRoomUser().setAuthenticateId(-1);
 
-        player.getRoomUser().getRoom().getEntityManager().leaveRoom(player, false);
+        boolean hotelView = false;
+
+        if (player.getNetwork().isFlashConnection()) {
+            hotelView = true;
+        }
+
+        player.getRoomUser().getRoom().getEntityManager().leaveRoom(player, hotelView);
     }
 }

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/trade/TRADE_CONFIRM_ACCEPT.java

@@ -33,6 +33,13 @@ public class TRADE_CONFIRM_ACCEPT implements MessageEvent {
         if (player.getRoomUser().isTradeConfirmed() &&
                 player.getRoomUser().getTradePartner().getRoomUser().isTradeConfirmed()) {
 
+            /*
+            if (RoomTradeManager.isTradeBannable(player)) {
+                RoomTradeManager.close(player.getRoomUser(), true);
+                return;
+            }
+            */
+
             player.send(new TRADE_COMPLETED());
             player.getRoomUser().getTradePartner().send(new TRADE_COMPLETED());
 

Havana-Server/src/main/java/org/alexdev/havana/messages/incoming/user/GET_INFO.java

@@ -13,6 +13,14 @@ public class GET_INFO implements MessageEvent {
             return;
         }
 
+        if (player.isProcessLoginSteps()) {
+            if (player.getNetwork().isFlashConnection()) {
+                player.getBadgeManager().refreshBadges();
+                player.getAchievementManager().processAchievements(player, true);
+                player.setProcessLoginSteps(false);
+            }
+        }
+
         player.send(new USER_OBJECT(player.getDetails()));
     }
 }

Havana-Server/src/main/java/org/alexdev/havana/messages/outgoing/catalogue/CATALOGUE_PAGE.java

@@ -33,10 +33,29 @@ public class CATALOGUE_PAGE extends PlayerMessageComposer {
             response.writeString(image);
         }
 
-        response.writeInt(this.texts.size());
+        if (this.page.getLayout().equalsIgnoreCase("frontpage3") && this.getPlayer().getNetwork().isFlashConnection()) {
+            List<String> texts = new ArrayList<>(this.texts);
+            texts = texts.subList(0, texts.size() - 6);
 
-        for (String text : this.texts) {
+            texts.add("1. Always ask permission from the bill payer first.\r\n" +
-            response.writeString(text);
+                    "2. Send HABBO in a UK SMS to 78881. You'll get an SMS back with a voucher code and will be charged £3 plus your standard UK SMS rate, normally 10p.\r\n" +
+                    "3. Enter the code below to redeem 35 Credits.");
+            texts.add("Redeem a Habbo Voucher code here:");
+            texts.add("#FAF8CC");
+            texts.add("#FAF8CC");
+
+
+            response.writeInt(texts.size());
+
+            for (String text : texts) {
+                response.writeString(text);
+            }
+        } else {
+            response.writeInt(this.texts.size());
+
+            for (String text : this.texts) {
+                response.writeString(text);
+            }
         }
 
         response.writeInt(this.catalogueItems.size());

Havana-Server/src/main/java/org/alexdev/havana/messages/outgoing/effects/AVATAR_EFFECTS.java

@@ -42,7 +42,13 @@ public class AVATAR_EFFECTS extends PlayerMessageComposer {
         for (Effect effect : this.effects) {
             response.writeInt(effect.getEffectId());
             response.writeInt(effect.getTimeDuration());
-            response.writeInt((int) this.effects.stream().filter(e -> e.getEffectId() == effect.getEffectId()).count());
+
+            if (this.getPlayer().getNetwork().isFlashConnection()) {
+                response.writeBool(!effect.isActivated());
+            } else {
+                response.writeInt((int) this.effects.stream().filter(e -> e.getEffectId() == effect.getEffectId()).count());
+            }
+
             response.writeInt(effect.isActivated() ? effect.getTimeLeft() : -1);
         }
     }

Havana-Server/src/main/java/org/alexdev/havana/messages/outgoing/events/ROOMEEVENT_INFO.java

@@ -23,6 +23,14 @@ public class ROOMEEVENT_INFO extends PlayerMessageComposer {
             response.writeString(this.event.getName());
             response.writeString(this.event.getDescription());
             response.writeString(this.event.getStartedDate());
+
+            if (getPlayer().getNetwork().isFlashConnection()) {
+                response.writeInt(this.event.getTags().size());
+
+                for (String tag : this.event.getTags()) {
+                    response.writeString(tag);
+                }
+            }
         }
     }
 

Havana-Server/src/main/java/org/alexdev/havana/messages/outgoing/rooms/ROOMQUEUEDATA.java

@@ -0,0 +1,30 @@
+package org.alexdev.havana.messages.outgoing.rooms;
+
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+public class ROOMQUEUEDATA extends MessageComposer {
+    private int position;
+
+    public ROOMQUEUEDATA(int position) {
+        this.position = position;
+    }
+
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeInt(1);
+
+        response.writeString("d"); // general_loader_text /
+        response.writeInt(2); // queue_current_ / queue_other_
+
+        response.writeInt(1);
+
+        response.writeString("d"); // queue_set.d.info=There are %d% Habbos in front of you in the queue.
+        response.writeInt(this.position);
+    }
+
+    @Override
+    public short getHeader() {
+        return 259;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/outgoing/rooms/ROOM_INTEREST.java

@@ -0,0 +1,16 @@
+package org.alexdev.havana.messages.outgoing.rooms;
+
+import org.alexdev.havana.messages.types.MessageComposer;
+import org.alexdev.havana.server.netty.streams.NettyResponse;
+
+public class ROOM_INTEREST extends MessageComposer {
+    @Override
+    public void compose(NettyResponse response) {
+        response.writeString("0");
+    }
+
+    @Override
+    public short getHeader() {
+        return 258;//Outgoing.ROOM_INTEREST;
+    }
+}

Havana-Server/src/main/java/org/alexdev/havana/messages/outgoing/rooms/user/USER_STATUSES.java

@@ -88,7 +88,11 @@ public class USER_STATUSES extends PlayerMessageComposer {
 
                         if (states.getPosition().getX() == 8 &&
                                 states.getPosition().getY() == 24) {
-                            response.writeString(StringUtil.format(7.0));
+                            if (player.getNetwork().isFlashConnection()) {
+                                response.writeString(StringUtil.format(4.0));
+                            } else {
+                                response.writeString(StringUtil.format(7.0));
+                            }
                         } else {
                             response.write(status.getValue());
                         }

Havana-Server/src/main/java/org/alexdev/havana/messages/outgoing/user/badges/USERBADGE.java

@@ -17,7 +17,12 @@ public class USERBADGE extends PlayerMessageComposer {
 
     @Override
     public void compose(NettyResponse response) {
-        response.writeString(this.userId);
+        if (this.getPlayer().getNetwork().isFlashConnection()) {
+            response.writeInt(this.userId);
+        } else {
+            response.writeString(this.userId);
+        }
+
          response.writeInt(this.equippedBadges.size());
 
         for (Badge badge : this.equippedBadges) {

Havana-Server/src/main/java/org/alexdev/havana/server/netty/NettyPlayerNetwork.java

@@ -1,6 +1,8 @@
 package org.alexdev.havana.server.netty;
 
 import io.netty.channel.Channel;
+import org.alexdev.havana.Havana;
+import org.alexdev.havana.game.player.Player;
 import org.alexdev.havana.server.netty.codec.EncryptionDecoder;
 import org.alexdev.havana.server.netty.codec.EncryptionEncoder;
 import org.apache.commons.validator.routines.InetAddressValidator;
@@ -19,10 +21,12 @@ public class NettyPlayerNetwork {
     private String pToken;
     private int pTx;
     private int pRx;
+    private final boolean isFlashConnected;
 
     public NettyPlayerNetwork(Channel channel, int connectionId) {
         this.channel = channel;
         this.connectionId = connectionId;
+        this.isFlashConnected = (Integer.parseInt(channel.localAddress().toString().split(":")[1]) == Havana.getServer().getFlashPort());
     }
 
     public static String removePadding(String tBody, int i) {
@@ -159,9 +163,28 @@ public class NettyPlayerNetwork {
 
     public void registerHandler(ServerHandlerType type, Object object) {
         if (type == ServerHandlerType.RC4) {
+            Player player = this.channel.attr(Player.PLAYER_KEY).get();
+
+            if (player.getNetwork().isFlashConnection()) {
+                return;
+            }
+
             this.channel.pipeline().addBefore("networkDecoder", "encryptionDecoder", new EncryptionDecoder((BigInteger) object));
             this.channel.pipeline().addBefore("networkEncoder", "encryptionEncoder", new EncryptionEncoder((BigInteger) object));
             // this.channel.pipeline().remove("gameDecoder");
         }
     }
+
+    public boolean isBetaConnected() {
+        return false;
+    }
+
+    public boolean isFlashClient() {
+        return isFlashConnected;
+    }
+
+
+    public boolean isFlashConnection() {
+        return /*isBetaConnected || */isFlashConnected;
+    }
 }

Havana-Server/src/main/java/org/alexdev/havana/server/netty/NettyServer.java

@@ -65,14 +65,32 @@ public class NettyServer  {
      * Bind the server to its address that's been specified
      */
     public void bind() {
-        this.bootstrap.bind(new InetSocketAddress(this.getIp(), this.getPort())).addListener(objectFuture -> {
+        int[] ports = new int[] { this.port, this.getFlashPort() /*, this.port + 4*/}; // R34 client: deprecated
+
+        for (int gamePort : ports) {
+            this.bootstrap.bind(new InetSocketAddress(this.getIp(), gamePort)).addListener(objectFuture -> {
+                if (!objectFuture.isSuccess()) {
+                    Log.getErrorLogger().error("Failed to start server on address: {}:{}", this.getIp(), gamePort);
+                    Log.getErrorLogger().error("Please double check there's no programs using the same game port, and you have set the correct IP address to listen on.");
+                } else {
+                    if (gamePort == this.port + 2) {
+                        log.info("Flash game server is listening on {}:{}", this.getIp(), gamePort);
+                    /*} else if (gamePort == this.port + 4) {
+                        log.info("Flash R34 game server is listening on {}:{}", this.getIp(), gamePort);*/
+                    } else {
+                        log.info("Shockwave game server is listening on {}:{}", this.getIp(), gamePort);
+                    }
+                }
+            });
+        }
+        /*this.bootstrap.bind(new InetSocketAddress(this.getIp(), this.getPort())).addListener(objectFuture -> {
             if (!objectFuture.isSuccess()) {
-                Log.getErrorLogger().error("Failed to start server on address: {}:{}", this.getIp(), this.port);
+                Log.getErrorLogger().error("Failed to start server on address: {}:{}", this.getIp(), this.getPort());
-                Log.getErrorLogger().error("Please double check there's no programs using the same game port, and you have set the correct IP address to listen on.");
+                Log.getErrorLogger().error("Please double check there's no programs using the same gamePort, and you have set the correct IP address to listen on.", this.getIp(), this.getPort());
             } else {
                 log.info("Shockwave game server is listening on {}:{}", this.getIp(), this.getPort());
             }
-        });
+        });*/
     }
 
     public int getFlashPort() {

Havana-Server/src/main/java/org/alexdev/havana/server/netty/codec/NetworkDecoder.java

@@ -19,6 +19,22 @@ public class NetworkDecoder extends ByteToMessageDecoder {
             return;
         }
 
+        Player player = ctx.channel().attr(Player.PLAYER_KEY).get();
+
+        if (player.getNetwork().isFlashConnection()) {
+            buffer.markReaderIndex();
+
+            if (buffer.readByte() != 64) {
+                ctx.channel().writeAndFlush("<?xml version=\"1.0\"?>\r\n" +
+                        "<!DOCTYPE cross-domain-policy SYSTEM \"/xml/dtds/cross-domain-policy.dtd\">\r\n" +
+                        "<cross-domain-policy>\r\n" +
+                        "<allow-access-from domain=\"*\" to-ports=\"1-31111\" />\r\n" +
+                        "</cross-domain-policy>\0");
+            }
+
+            buffer.resetReaderIndex();
+        }
+
         buffer.markReaderIndex();
 
         int length = Base64Encoding.decode(new byte[]{buffer.readByte(), buffer.readByte(), buffer.readByte()});

Havana-Server/src/main/java/org/alexdev/havana/server/netty/codec/NetworkEncoder.java

@@ -40,9 +40,44 @@ public class NetworkEncoder extends MessageToMessageEncoder<Object> {
             NettyResponse response = new NettyResponse(msg.getHeader(), buffer);
 
             try {
+                if (msg instanceof ALERT) {
+                    ALERT alert = (ALERT)msg;
+
+                    if (player.getNetwork().isFlashConnection()) {
+                        alert.setMessage(alert.getMessage().replace("<br>", "\r"));
+                    }
+                }
+
+                // Fix "thumbs up" between Flash/Shockwave clients (ALT+7)
+                if (msg instanceof MESSENGER_MSG) {
+                    MESSENGER_MSG messengerMsg = (MESSENGER_MSG)msg;
+
+                    if (player.getNetwork().isFlashConnection()) {
+                        messengerMsg.getMessage().setMessage(messengerMsg.getMessage().getMessage().replace(Character.toString((char)149), Character.toString((char)8226)));
+                    } else {
+                        messengerMsg.getMessage().setMessage(messengerMsg.getMessage().getMessage().replace(Character.toString((char)8226), Character.toString((char)149)));
+                    }
+                }
+
+                if (msg instanceof CHAT_MESSAGE) {
+                    CHAT_MESSAGE chatMsg = (CHAT_MESSAGE)msg;
+
+                    if (player.getNetwork().isFlashConnection()) {
+                        chatMsg.setMessage(chatMsg.getMessage().replace(Character.toString((char)149), Character.toString((char)8226)));
+                    } else {
+                        chatMsg.setMessage(chatMsg.getMessage().replace(Character.toString((char)8226), Character.toString((char)149)));
+                    }
+                }
+
                 msg.compose(response);
             } catch (Exception ex) {
-                Log.getErrorLogger().error("Error occurred when composing (" + response.getHeader() + "):", ex);
+                String name = "";
+
+                if (player != null && player.isLoggedIn()) {
+                    name = player.getDetails().getName();
+                }
+
+                Log.getErrorLogger().error("Error occurred when composing (" + response.getHeader() + ") for user (" + name + "):", ex);
                 return;
             }
 

Havana-Server/src/main/java/org/alexdev/havana/server/netty/connections/ConnectionHandler.java

@@ -60,7 +60,9 @@ public class ConnectionHandler extends SimpleChannelInboundHandler<NettyRequest>
             return;
         }
 
-        player.send(new HELLO());
+        if (!player.getNetwork().isFlashConnection()) {
+            player.send(new HELLO());
+        }
 
         if (ServerConfiguration.getBoolean("log.connections")) {
             log.info("[{}] Connection from {} ", player.getNetwork().getConnectionId(), NettyPlayerNetwork.getIpAddress(ctx.channel()));

Havana-Server/src/main/java/org/alexdev/havana/util/StringUtil.java

@@ -204,6 +204,10 @@ public class StringUtil {
         newString = newString.replace("\r", "<br>");
         newString = newString.replace("\n", "<br>");
 
+        if (player.getNetwork().isFlashConnection()) {
+            newString = newString.replace("<br>", "\r");
+        }
+
         newString = newString.replace("%username%", player.getDetails().getName());
         return newString;
     }

Havana-Web/src/main/java/org/alexdev/http/Routes.java

@@ -70,11 +70,14 @@ public class Routes {
         RouteManager.addRoute("/client", ClientController::client);
         RouteManager.addRoute("/clientlog/update", ClientController::blank);
         RouteManager.addRoute("/cacheCheck", ClientController::blank);
+        RouteManager.addRoute("/shockwave_client", ClientController::shockwaveclient);
+        RouteManager.addRoute("/flash_client", ClientController::flashClient);
         //RouteManager.addRoute("/beta_client", ClientController::betaClient); // R34 client: deprecated
         RouteManager.addRoute("/client_popup/install_shockwave", ClientController::clientInstallShockwave);
         RouteManager.addRoute("/client_error", ClientController::client_error);
         RouteManager.addRoute("/client_connection_failed", ClientController::client_connection_failed);
 
+
         // Account
         RouteManager.addRoute("/account/banned", AccountController::banned);
         RouteManager.addRoute("/account/logout", AccountController::logout);

Havana-Web/src/main/java/org/alexdev/http/controllers/site/ClientController.java

@@ -30,6 +30,36 @@ public class ClientController {
             return;
         }
 
+        /*
+        if (!VotingAPI.isVoted(webConnection)) {
+            VotingAPI.redirectToClientVote(webConnection);
+            return;
+        }
+
+         */
+        int userId = webConnection.session().getInt("user.id");
+        String getRequests = webConnection.request().uri().contains("?") ? "?" + webConnection.request().uri().split("\\?")[1] : "";
+
+        /*
+        ClientPreference clientPreference = SessionDao.getClientPreference(userId);
+
+        if (clientPreference == ClientPreference.SHOCKWAVE) {
+            webConnection.redirect("/shockwave_client" + getRequests);
+        } else {
+            webConnection.redirect("/flash_client" + getRequests);
+        }*/
+
+        webConnection.redirect("/shockwave_client" + getRequests);
+    }
+
+    public static void shockwaveclient(WebConnection webConnection) throws SQLException {
+        XSSUtil.clear(webConnection);
+
+        if (!webConnection.session().getBoolean("authenticated")) {
+            webConnection.redirect("/login_popup");
+            return;
+        }
+
         webConnection.session().set("clientRequest", webConnection.request().uri());
 
         if (webConnection.session().getBoolean("clientAuthenticate")) {
@@ -111,7 +141,7 @@ public class ClientController {
         var ssoTicket = playerDetails.getSsoTicket();
 
         // Update sso ticket
-        if (GameConfiguration.getInstance().getBoolean("reset.sso.after.login") || ssoTicket == null || ssoTicket.isBlank()) {
+        if (GameConfiguration.getInstance().getBoolean("reset.sso.after.login") || ssoTicket.isBlank()) {
             ssoTicket = UUID.randomUUID().toString();
             PlayerDao.setTicket(webConnection.session().getInt("user.id"), ssoTicket);
         }
@@ -130,6 +160,99 @@ public class ClientController {
         template.render();
     }
 
+    public static void flashClient(WebConnection webConnection) throws SQLException {
+        XSSUtil.clear(webConnection);
+
+        if (!webConnection.session().getBoolean("authenticated")) {
+            webConnection.redirect("/login_popup");
+            return;
+        }
+
+        var template = webConnection.template("client_flash");
+        PlayerDetails playerDetails = (PlayerDetails) template.get("playerDetails");
+
+        webConnection.session().set("clientRequest", webConnection.request().uri());
+
+        if (webConnection.session().getBoolean("clientAuthenticate")) {
+            webConnection.redirect("/account/reauthenticate");
+            return;
+        }
+
+        boolean forwardRoom = false;
+        int forwardType = -1;
+        int forwardId = -1;
+
+        if (playerDetails == null) {
+            SessionUtil.logout(webConnection);
+            webConnection.redirect("/");
+            return;
+        }
+
+        var pair = playerDetails.isBanned();
+
+        if (pair != null) {
+            webConnection.redirect("/account/banned");
+            return;
+        }
+
+        if (webConnection.get().contains("createRoom") && StringUtils.isNumeric(webConnection.get().getString("createRoom"))) {
+            int roomType = Integer.parseInt(webConnection.get().getString("createRoom"));
+            boolean setGift = false;
+
+            if (!playerDetails.canSelectRoom()) {
+                int roomLayout = (int) PlayerStatisticsDao.getStatisticLong(playerDetails.getId(), PlayerStatistic.NEWBIE_ROOM_LAYOUT);
+
+                if (roomLayout == 0) {
+                    if (!(roomType < 0 || roomType > 5)) {
+                        setGift = true;
+                    }
+                }
+            } else {
+                setGift = RoomSelectionHandler.selectRoom(playerDetails.getId(), roomType);
+            }
+
+            if (setGift) {
+                PlayerStatisticsDao.updateStatistic(playerDetails.getId(), PlayerStatistic.NEWBIE_ROOM_LAYOUT, roomType + 1);
+                PlayerStatisticsDao.updateStatistic(playerDetails.getId(), PlayerStatistic.NEWBIE_GIFT, 1);
+                PlayerStatisticsDao.updateStatistic(playerDetails.getId(), PlayerStatistic.NEWBIE_GIFT_TIME, DateUtil.getCurrentTimeSeconds() + TimeUnit.DAYS.toSeconds(1));
+            }
+
+            playerDetails = PlayerDao.getDetails(webConnection.session().getInt("user.id"));
+            forwardRoom = true;
+
+            forwardType = 2; // Private room
+            forwardId = playerDetails.getSelectedRoomId();
+        }
+
+        if (webConnection.get().contains("forwardId")) {
+            forwardRoom = true;
+
+            try {
+                forwardId = webConnection.get().getInt("roomId");
+                forwardType = webConnection.get().getInt("forwardId");
+            } catch (Exception ex) {
+
+            }
+        }
+
+        // template.set("preferredCountry", PlayerStatisticsDao.getStatisticString(playerDetails.getId(), PlayerStatistic.HOTEL_VIEW).toLowerCase());
+        template.set("forwardRoom", forwardRoom);
+        template.set("forwardId", forwardId);
+        template.set("forwardType", forwardType);
+
+        // Update sso ticket
+        var ssoTicket = playerDetails.getSsoTicket();
+
+        // Update sso ticket
+        if (GameConfiguration.getInstance().getBoolean("reset.sso.after.login") || ssoTicket == null || ssoTicket.isBlank()) {
+            ssoTicket = UUID.randomUUID().toString();
+            PlayerDao.setTicket(webConnection.session().getInt("user.id"), ssoTicket);
+        }
+
+        template.set("ssoTicket", ssoTicket);
+        template.render();
+    }
+
     public static void clientInstallShockwave(WebConnection webConnection) {
         XSSUtil.clear(webConnection);
 
@@ -206,4 +329,104 @@ public class ClientController {
 
         template.render();
     }
+
+    public static void betaClient(WebConnection webConnection) throws SQLException {
+        XSSUtil.clear(webConnection);
+
+        if (!webConnection.session().getBoolean("authenticated")) {
+            webConnection.redirect("/login_popup");
+            return;
+        }
+
+        var template = webConnection.template("client_beta");
+        PlayerDetails playerDetails = (PlayerDetails) template.get("playerDetails");
+
+        webConnection.session().set("clientRequest", webConnection.request().uri());
+
+        if (webConnection.session().getBoolean("clientAuthenticate")) {
+            webConnection.redirect("/account/reauthenticate");
+            return;
+        }
+
+        /*
+        if (!VotingAPI.isVoted(webConnection)) {
+            VotingAPI.redirectToClientVote(webConnection);
+            return;
+        }
+        */
+
+        boolean forwardRoom = false;
+        int forwardType = -1;
+        int forwardId = -1;
+
+        if (playerDetails == null) {
+            SessionUtil.logout(webConnection);
+            webConnection.redirect("/");
+            return;
+        }
+
+        var pair = playerDetails.isBanned();
+
+        if (pair != null) {
+            webConnection.redirect("/account/banned");
+            return;
+        }
+
+        if (webConnection.get().contains("createRoom") && StringUtils.isNumeric(webConnection.get().getString("createRoom"))) {
+            int roomType = Integer.parseInt(webConnection.get().getString("createRoom"));
+            boolean setGift = false;
+
+            if (!playerDetails.canSelectRoom()) {
+                int roomLayout = (int) PlayerStatisticsDao.getStatisticLong(playerDetails.getId(), PlayerStatistic.NEWBIE_ROOM_LAYOUT);
+
+                if (roomLayout == 0) {
+                    if (!(roomType < 0 || roomType > 5)) {
+                        setGift = true;
+                    }
+                }
+            } else {
+                setGift = RoomSelectionHandler.selectRoom(playerDetails.getId(), roomType);
+            }
+
+            if (setGift) {
+                PlayerStatisticsDao.updateStatistic(playerDetails.getId(), PlayerStatistic.NEWBIE_ROOM_LAYOUT, roomType + 1);
+                PlayerStatisticsDao.updateStatistic(playerDetails.getId(), PlayerStatistic.NEWBIE_GIFT, 1);
+                PlayerStatisticsDao.updateStatistic(playerDetails.getId(), PlayerStatistic.NEWBIE_GIFT_TIME, DateUtil.getCurrentTimeSeconds() + TimeUnit.DAYS.toSeconds(1));
+            }
+
+            playerDetails = PlayerDao.getDetails(webConnection.session().getInt("user.id"));
+            forwardRoom = true;
+
+            forwardType = 2; // Private room
+            forwardId = playerDetails.getSelectedRoomId();
+        }
+
+        if (webConnection.get().contains("forwardId")) {
+            forwardRoom = true;
+
+            try {
+                forwardId = webConnection.get().getInt("roomId");
+                forwardType = webConnection.get().getInt("forwardId");
+            } catch (Exception ex) {
+
+            }
+        }
+
+        // template.set("preferredCountry", PlayerStatisticsDao.getStatisticString(playerDetails.getId(), PlayerStatistic.HOTEL_VIEW).toLowerCase());
+        template.set("forwardRoom", forwardRoom);
+        template.set("forwardId", forwardId);
+        template.set("forwardType", forwardType);
+
+        // Update sso ticket
+        var ssoTicket = playerDetails.getSsoTicket();
+
+        // Update sso ticket
+        if (GameConfiguration.getInstance().getBoolean("reset.sso.after.login") || ssoTicket.isBlank()) {
+            ssoTicket = UUID.randomUUID().toString();
+            PlayerDao.setTicket(webConnection.session().getInt("user.id"), ssoTicket);
+        }
+
+        template.set("ssoTicket", ssoTicket);
+        template.render();
+    }
 }

Havana-Web/src/main/java/org/alexdev/http/util/SessionUtil.java

@@ -1,6 +1,5 @@
 package org.alexdev.http.util;
 
-import com.goterl.lazysodium.interfaces.PwHash;
 import org.alexdev.duckhttpd.server.connection.WebConnection;
 import org.alexdev.havana.dao.mysql.PlayerDao;
 import org.alexdev.havana.game.player.PlayerDetails;

Havana-Web/src/main/java/org/alexdev/http/util/config/WebSettingsConfigWriter.java

@@ -29,6 +29,12 @@ public class WebSettingsConfigWriter implements ConfigWriter {
         config.put("loader.external.variables", "http://localhost/dcr/v31/gamedata/external_variables.txt?");
         config.put("loader.external.texts", "http://localhost/dcr/v31/gamedata/external_texts.txt?");
 
+        config.put("loader.flash.base", "http://localhost/gordon/RELEASE39-22643-22891-200911110035_07c3a2a30713fd5bea8a8caf07e33438/");
+        config.put("loader.flash.swf", "http://localhost/gordon/RELEASE39-22643-22891-200911110035_07c3a2a30713fd5bea8a8caf07e33438/Habbo.swf");
+        config.put("loader.flash.external.texts", "http://localhost/flash_gamedata/external_texts.txt");
+        config.put("loader.flash.external.variables", "http://localhost/flash_gamedata/gamedata/external_variables.txt");
+
+
         config.put("registration.disabled", "false");
         config.put("collectables.page", "51");
 

tools/migrations/update.1.2.sql

@@ -0,0 +1,56 @@
+-- Dumping structure for table havana.navigator_styles
+DROP TABLE IF EXISTS `navigator_styles`;
+CREATE TABLE IF NOT EXISTS `navigator_styles` (
+  `room_id` int(11) NOT NULL,
+  `description` text NOT NULL DEFAULT '',
+  `thumbnail_url` varchar(255) NOT NULL DEFAULT 'officialrooms_es/shoppingdeals_recroom.gif',
+  `thumbnail_layout` tinyint(1) NOT NULL DEFAULT 1,
+  PRIMARY KEY (`room_id`),
+  UNIQUE KEY `room_id` (`room_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+-- Dumping data for table havana.navigator_styles: ~40 rows (approximately)
+DELETE FROM `navigator_styles`;
+/*!40000 ALTER TABLE `navigator_styles` DISABLE KEYS */;
+INSERT INTO `navigator_styles` (`room_id`, `description`, `thumbnail_url`, `thumbnail_layout`) VALUES
+	(1, 'New? Lost? Get a warm welcome here!', 'officialrooms_defaults/hh_room_nlobby.png', 4),
+	(2, 'Perform your latest master piece, or simply catch the latest gossip.', 'officialrooms_defaults/hh_room_theater.png', 4),
+	(3, 'Books! Glorious books! Fill yourself with information and lose yourself in wonderful literary worlds.', 'officialrooms_defaults/hh_room_library.png', 4),
+	(4, 'Will you reach the final of the biggest brains in Habbo competition?', 'officialrooms_hq/hh_room_tv_studio_m6.png', 1),
+	(5, 'Now Showing: The Making of Habbo Big Brother', 'officialrooms_defaults/hh_room_cinema.png', 1),
+	(6, 'Zac Efron owns in the 17 Again basketball court – what would you do with your second shot?', 'officialrooms_defaults/hh_room_sport.png', 1),
+	(7, 'Forget Beijing, check out Habbo\'s very own Olympic Stadium!', 'officialrooms_hq/official_fball.png', 1),
+	(8, 'Beware the flying knives!', 'officialrooms_defaults/hh_room_kitchen.png', 1),
+	(9, 'Grab a stool and hear Dave and Sadie talk about the good old days...', 'officialrooms_defaults/hh_room_pub.png', 1),
+	(10, 'Relax with friends over one of Marias specialty coffees', 'officialrooms_hq/hh_room_cafe_xms08.png', 1),
+	(11, 'Join Billy for a bite to eat and some office gossip in the HABprentice', 'officialrooms_defaults/hh_room_erics.png', 1),
+	(12, 'Star Wars The Clone Wars on Blu-Ray and DVD from December 8', 'officialrooms_defaults/hh_room_space_cafe.png', 1),
+	(13, 'One of the highest points in Habbo Hotel!', 'officialrooms_defaults/hh_room_rooftop.png', 1),
+	(15, 'Pizza; food of the hungry!', 'officialrooms_defaults/hh_room_pizza.png', 1),
+	(16, 'Get food here!', 'officialrooms_defaults/hh_room_habburger.png', 1),
+	(17, 'Old, cool, Dusty and the perfect room for the biggest brains in Habbo', 'officialrooms_defaults/hh_room_dustylounge.png', 1),
+	(18, 'Try the tea in this Mongol cafe - it is to die for darlings!', 'officialrooms_defaults/hh_room_tearoom.png', 1),
+	(19, 'A set of rooms inspired by the original and legendary Mobiles Disco, the progenitor of Habbo', 'officialrooms_defaults/hh_room_old_skool.png', 1),
+	(21, 'Ghetto Fabulous', 'officialrooms_defaults/hh_room_disco.png', 1),
+	(23, 'Strut your funky stuff', 'officialrooms_defaults/hh_room_bar.png', 1),
+	(25, 'Home to the Duck Island residents.', 'officialrooms_defaults/hh_room_sunsetcafe.png', 1),
+	(27, 'Where Ideas can flow freely', 'officialrooms_defaults/hh_room_chill.png', 1),
+	(28, 'Monumental and magnificient. For Habbo Club Members only.', 'officialrooms_defaults/hh_room_clubmammoth.png', 1),
+	(29, 'Climb the rocks, chill in the shade and watch for pirate ships!', 'officialrooms_defaults/hh_room_floatinggarden.png', 1),
+	(30, 'Enjoy the great outdoors, celebrate mother nature and party!', 'officialrooms_defaults/hh_room_picnic.png', 1),
+	(31, 'Grab a sunbed and top up that tan!', 'officialrooms_defaults/hh_room_sun_terrace.png', 1),
+	(32, 'Follow the path...', 'officialrooms_defaults/hh_room_gate_park.png', 1),
+	(34, 'Follow the path...', 'officialrooms_defaults/hh_room_park.png', 1),
+	(36, 'Splish, splash and have a bash in the Habbo pool!', 'officialrooms_defaults/hh_room_pool.png', 1),
+	(39, 'The heart of Habbo Hotel', 'officialrooms_defaults/hh_room_lobby.png', 1),
+	(42, 'This was the Habbo Big Brother Lounge during series 1 (2008)', 'officialrooms_defaults/hh_room_floorlobbies.png', 1),
+	(43, 'Grab some brain juice!', 'officialrooms_defaults/hh_room_icecafe.png', 1),
+	(44, 'Learn a foreign language and win Habbo Credits in our quests!', 'officialrooms_defaults/hh_room_netcafe.png', 1),
+	(45, 'Angus, Thongs and Perfect Snogging in cinemas July 25th', 'officialrooms_defaults/hh_room_beauty_salon_general.png', 1),
+	(46, 'Popular? Win a cool band and party at your school. You soon will be!', 'officialrooms_defaults/hh_room_den.png', 1),
+	(47, 'Connecting you to the heart of Habbo Hotel', 'officialrooms_defaults/hh_room_hallway.png', 1),
+	(53, 'Taking you to the far reaches of Habbo Hotel', 'officialrooms_defaults/hh_room_hallway2.png', 1),
+	(59, 'Celebrities favourite hangout', 'officialrooms_defaults/hh_room_starlounge.png', 1),
+	(60, 'Tres chic with an eastern twist. For Habbo Club Members only.', 'officialrooms_defaults/hh_room_orient.png', 1),
+	(68, 'Even the smallest of light... shines in the darkness', 'officialrooms_defaults/hh_room_emperors.png', 1);
+/*!40000 ALTER TABLE `navigator_styles` ENABLE KEYS */;

tools/www-tpl/default-en/me.tpl

@@ -120,18 +120,17 @@ body { behavior: url({{ site.staticContentPath }}/web-gallery/js/csshover.htc);
 	{% if site.serverOnline %}
     <div class="enter-hotel-btn">
         <div class="open enter-btn">
-            <a href="{{ site.sitePath }}/client" target="client" onclick="openOrFocusHabbo(this); return false;">Enter {{ site.siteName }} Hotel<i></i></a>
+            <a href="{{ site.sitePath }}/shockwave_client" target="shockwave_client" onclick="openOrFocusHabbo(this); return false;">Enter<i></i></a>
             <b></b>
         </div>
     </div>
-    <!-- 
+
     <div class="enter-beta-btn">
         <div class="open enter-btn">
-            <a href="{{ site.sitePath }}/client" target="client" onclick="openOrFocusHabbo(this); return false;">Enter {{ site.siteName }} Hotel<i></i></a>
+            <a href="{{ site.sitePath }}/flash_client" target="flash_client" onclick="openOrFocusHabbo(this); return false;">Enter Flash {{ site.siteName }}<i></i></a>
             <b></b>
         </div>
     </div>
-    -->
 	{% else %}
 	<div class="enter-hotel-btn">
 		<div class="closed enter-btn">