Implement dorm

src/main/java/emu/nebula/server/handlers/HandlerDormAchievementRewardReceiveReq.java

@@ -0,0 +1,28 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormAchievementRewardReceive.DormAchievementRewardReceiveReq;
+
+@HandlerId(NetMsgId.dorm_achievement_reward_receive_req)
+public class HandlerDormAchievementRewardReceiveReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = DormAchievementRewardReceiveReq.parseFrom(message);
+
+        // Receive achievements
+        var rsp = session.getPlayer().getDormManager().receiveAchievements(req.getAchievementIds().toArray());
+
+        if (rsp == null) {
+            return session.encodeMsg(NetMsgId.dorm_achievement_reward_receive_failed_ack);
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_achievement_reward_receive_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormAffinityGiftSendReq.java

@@ -0,0 +1,47 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.game.inventory.ItemParamMap;
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormAffinityGiftSend.DormAffinityGiftSendReq;
+import emu.nebula.proto.DormAffinityGiftSend.DormAffinityGiftSendResp;
+
+@HandlerId(NetMsgId.dorm_affinity_gift_send_req)
+public class HandlerDormAffinityGiftSendReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = DormAffinityGiftSendReq.parseFrom(message);
+
+        var player = session.getPlayer();
+        var manager = player.getDormManager();
+
+        // Get character
+        var character = player.getCharacters().getCharacterById(req.getCharId());
+        if (character == null) {
+            return session.encodeMsg(NetMsgId.dorm_affinity_gift_send_failed_ack);
+        }
+
+        // Parse gift items
+        var items = ItemParamMap.fromTemplates(req.getItems());
+
+        // Send gifts
+        var change = manager.sendAffinityGift(character, req.getDormRoomId(), items);
+        if (change == null) {
+            return session.encodeMsg(NetMsgId.dorm_affinity_gift_send_failed_ack);
+        }
+
+        // Build response
+        var rsp = DormAffinityGiftSendResp.newInstance()
+                .setInfo(character.getAffinityProto())
+                .setChange(change.toProto())
+                .setSendGiftCnt(manager.getDailyGiftCount(character.getCharId()));
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_affinity_gift_send_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormBlocksConvertReq.java

@@ -0,0 +1,27 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.Public.UI32;
+
+@HandlerId(NetMsgId.dorm_blocks_convert_req)
+public class HandlerDormBlocksConvertReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = UI32.parseFrom(message);
+
+        // Convert blocks
+        var change = session.getPlayer().getDormManager().convertBlocks(req.getValue());
+        if (change == null) {
+            return session.encodeMsg(NetMsgId.dorm_blocks_convert_failed_ack);
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_blocks_convert_succeed_ack, change.toProto());
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormFriendLikeReq.java

@@ -0,0 +1,52 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.GameConstants;
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormFriendLike.DormFriendLikeReq;
+
+@HandlerId(NetMsgId.dorm_friend_like_req)
+public class HandlerDormFriendLikeReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = DormFriendLikeReq.parseFrom(message);
+
+        long friendId = req.getFriendId();
+
+        if (friendId <= 0 || friendId > Integer.MAX_VALUE) {
+            return session.encodeMsg(NetMsgId.dorm_friend_like_failed_ack);
+        }
+
+        int uid = (int) friendId;
+        var player = session.getPlayer();
+        var manager = player.getDormManager();
+
+        // Friends only
+        if (!player.getFriendList().getFriends().containsKey(uid)) {
+            return session.encodeMsg(NetMsgId.dorm_friend_like_failed_ack);
+        }
+
+        // Daily limit and duplicate check
+        if (manager.hasLikedFriend(uid) || manager.getLikedFriendUids().size() >= GameConstants.DORM_LIKE_LIMIT) {
+            return session.encodeMsg(NetMsgId.dorm_friend_like_failed_ack);
+        }
+
+        manager.addLikedFriend(uid);
+
+        // Increment the friend's like counter
+        var dorm = session.getPlayer().getDormManager().getFriendDorm(uid);
+
+        if (dorm != null) {
+            dorm.addLike();
+            dorm.save();
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_friend_like_succeed_ack);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormFriendListReq.java

@@ -0,0 +1,42 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormFriendList.DormFriendListResp;
+import emu.nebula.proto.PublicDorm.DormFriendDetail;
+
+@HandlerId(NetMsgId.dorm_friend_list_req)
+public class HandlerDormFriendListReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        var player = session.getPlayer();
+        var manager = player.getDormManager();
+
+        var rsp = DormFriendListResp.newInstance();
+
+        for (var friendship : player.getFriendList().getFriends().values()) {
+            int uid = friendship.getFriendUid();
+
+            var dorm = session.getPlayer().getDormManager().getFriendDorm(uid);
+
+            var detail = DormFriendDetail.newInstance()
+                    .setUid(uid)
+                    .setLikeNum(dorm == null ? 0 : dorm.getLikeNum())
+                    .setCollectionValue(dorm == null ? 0 : dorm.getCollectionValue())
+                    .setIsLike(manager.hasLikedFriend(uid));
+
+            if (dorm != null && dorm.getDormName() != null) {
+                detail.setDormName(dorm.getDormName());
+            }
+
+            rsp.addFriends(detail);
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_friend_list_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormFriendVisitReq.java

@@ -0,0 +1,70 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormFriendVisit.DormFriendVisitReq;
+import emu.nebula.proto.DormFriendVisit.DormFriendVisitResp;
+import emu.nebula.proto.PublicDorm.DormFriendInfo;
+
+@HandlerId(NetMsgId.dorm_friend_visit_req)
+public class HandlerDormFriendVisitReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = DormFriendVisitReq.parseFrom(message);
+
+        // Validate friend
+        long friendId = req.getFriendId();
+
+        if (friendId <= 0 || friendId > Integer.MAX_VALUE) {
+            return session.encodeMsg(NetMsgId.dorm_friend_visit_failed_ack);
+        }
+
+        int uid = (int) friendId;
+
+        if (!session.getPlayer().getFriendList().getFriends().containsKey(uid)) {
+            return session.encodeMsg(NetMsgId.dorm_friend_visit_failed_ack);
+        }
+
+        // Load friend dorm data
+        var dorm = session.getPlayer().getDormManager().getFriendDorm(uid);
+
+        if (dorm == null) {
+            return session.encodeMsg(NetMsgId.dorm_friend_visit_failed_ack);
+        }
+        
+        // Build response
+        var rsp = DormFriendVisitResp.newInstance();
+
+        var unlockedRoomIds = dorm.getUnlockedRoomIds();
+        var sortedRoomIds = new java.util.ArrayList<>(unlockedRoomIds);
+        sortedRoomIds.sort(Integer::compareTo);
+
+        for (int roomId : sortedRoomIds) {
+            var room = dorm.getOrCreateRoom(roomId);
+
+            if (room != null) {
+                rsp.addDormList(room.toProto());
+            }
+        }
+
+        var dormInfo = DormFriendInfo.newInstance();
+
+        if (dorm.getDormName() != null) {
+            dormInfo.setDormName(dorm.getDormName());
+        }
+
+        rsp.setDormInfo(dormInfo);
+
+        // Record the visit on the friend's dorm
+        dorm.recordVisit(session.getPlayer().getUid());
+        dorm.save();
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_friend_visit_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormFurnitureListReq.java

@@ -0,0 +1,42 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormFurnitureList.DormBagListResp;
+import emu.nebula.proto.Public.ItemTpl;
+import emu.nebula.proto.PublicDorm.DormBagInfo;
+
+@HandlerId(NetMsgId.dorm_bag_list_req)
+public class HandlerDormFurnitureListReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Get dorm manager
+        var dorm = session.getPlayer().getDormManager();
+        
+        // Build response
+        var rsp = DormBagListResp.newInstance();
+        
+        // Encode dorm furniture inventory
+        for (var entry : dorm.getFurnitureCollection().int2IntEntrySet()) {
+            if (entry.getIntValue() <= 0) {
+                continue;
+            }
+            
+            var item = ItemTpl.newInstance()
+                .setTid(entry.getIntKey())
+                .setQty(entry.getIntValue());
+            
+            var info = DormBagInfo.newInstance()
+                    .setItemTplInfo(item);
+
+            rsp.addDormBagList(info);
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_bag_list_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormFurniturePresetDeleteReq.java

@@ -0,0 +1,34 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.Public.UI32;
+
+@HandlerId(NetMsgId.dorm_furniture_preset_delete_req)
+public class HandlerDormFurniturePresetDeleteReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // The client does not send a request body for this packet in the current client version.
+        // If a body is present, treat field 1 as the preset/build id.
+        int buildId = 0;
+
+        if (message != null && message.length > 0) {
+            try {
+                buildId = UI32.parseFrom(message).getValue();
+            } catch (Exception ignored) {
+                buildId = 0;
+            }
+        }
+
+        if (buildId > 0) {
+            session.getPlayer().getDormManager().deletePreset(buildId);
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_furniture_preset_delete_succeed_ack);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormFurniturePresetListReq.java

@@ -0,0 +1,41 @@
+package emu.nebula.server.handlers;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+
+import emu.nebula.GameConstants;
+import emu.nebula.game.dorm.DormPreset;
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormFurniturePreset.DormFurniturePresetListResp;
+
+@HandlerId(NetMsgId.dorm_furniture_preset_list_req)
+public class HandlerDormFurniturePresetListReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Get player dorm
+        var dorm = session.getPlayer().getDormManager();
+        
+        // Build response
+        var rsp = DormFurniturePresetListResp.newInstance()
+                .setNum(GameConstants.DORM_DEFAULT_PRESET_NUM);
+
+        // Get preset list
+        var list = new ArrayList<>(dorm.getPresets().values());
+        
+        // Sort preset list
+        list.sort(Comparator.comparingInt(DormPreset::getBuildId));
+
+        // Encode presets to proto
+        for (var preset : list) {
+            rsp.addPresetList(preset.toProto());
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_furniture_preset_list_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormFurnitureSaveReq.java

@@ -0,0 +1,47 @@
+package emu.nebula.server.handlers;
+
+import java.util.ArrayList;
+
+import emu.nebula.game.dorm.DormFurniture;
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormFurnitureSave.DormFurnitureSaveReq;
+import emu.nebula.proto.Public.I64;
+
+@HandlerId(NetMsgId.dorm_furniture_save_req)
+public class HandlerDormFurnitureSaveReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = DormFurnitureSaveReq.parseFrom(message);
+
+        // Build furniture list
+        var furnitureList = new ArrayList<DormFurniture>();
+
+        for (var info : req.getFurniturePosInfoList()) {
+            furnitureList.add(new DormFurniture(info));
+        }
+
+        // Save room or preset
+        var createTime = session.getPlayer().getDormManager().saveFurnitureLayout(
+            req.getDormRoomId(),
+            furnitureList,
+            req.getBuildId()
+        );
+
+        if (createTime == null) {
+            return session.encodeMsg(NetMsgId.dorm_furniture_save_failed_ack);
+        }
+
+        // The client reads the preset creation time from Value
+        var rsp = I64.newInstance()
+                .setValue(createTime);
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_furniture_save_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormGetChangeDataReq.java

@@ -0,0 +1,32 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormGetChangeData.DormChangeDataResp;
+import emu.nebula.proto.PublicDorm.DormChangeDataInfo;
+
+@HandlerId(NetMsgId.dorm_get_change_data_req)
+public class HandlerDormGetChangeDataReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Get player dorm
+        var dorm = session.getPlayer().getDormManager();
+        
+        // Build response
+        var info = DormChangeDataInfo.newInstance()
+                .setDormName(dorm.getDormName())
+                .setLikeNum(dorm.getLikeNum())
+                .setDayVisitNum(dorm.getDayVisitNum())
+                .setVisitTotalNum(dorm.getVisitTotalNum());
+        
+        var rsp = DormChangeDataResp.newInstance()
+                .setDormChangeData(info);
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_get_change_data_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormInfoListReq.java

@@ -0,0 +1,20 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+
+@HandlerId(NetMsgId.dorm_info_list_req)
+public class HandlerDormInfoListReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Build response
+        var rsp = session.getPlayer().getDormManager().toProto();
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_info_list_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormInfoUpdateNameReq.java

@@ -0,0 +1,26 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.Public.StringV;
+
+@HandlerId(NetMsgId.dorm_info_update_name_req)
+public class HandlerDormInfoUpdateNameReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = StringV.parseFrom(message);
+
+        // Version = 0 means the dorm name, otherwise the room id
+        if (!session.getPlayer().getDormManager().renameRoom(req.getVersion(), req.getValue())) {
+            return session.encodeMsg(NetMsgId.dorm_info_update_name_failed_ack);
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_info_update_name_succeed_ack);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormInvitationRoleReq.java

@@ -0,0 +1,35 @@
+package emu.nebula.server.handlers;
+
+import java.util.ArrayList;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormInvitationRole.DormInvitationRoleReq;
+import emu.nebula.proto.Public;
+
+@HandlerId(NetMsgId.dorm_invitation_role_req)
+public class HandlerDormInvitationRoleReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = DormInvitationRoleReq.parseFrom(message);
+
+        // Get role ids
+        var roleIds = new ArrayList<Integer>();
+        for (var info : req.getInvitationRoleList()) {
+            roleIds.add(info.getRoleId());
+        }
+
+        // Update invitation roles
+        if (!session.getPlayer().getDormManager().updateInvitationRoles(req.getDormRoomId(), roleIds)) {
+            return session.encodeMsg(NetMsgId.dorm_invitation_role_failed_ack);
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_invitation_role_succeed_ack, Public.Nil.newInstance());
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormLayoutRewardReceiveReq.java

@@ -0,0 +1,28 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormLayoutRewardReceive.DormLayoutRewardReceiveReq;
+
+@HandlerId(NetMsgId.dorm_layout_reward_receive_req)
+public class HandlerDormLayoutRewardReceiveReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = DormLayoutRewardReceiveReq.parseFrom(message);
+
+        // Receive layout rewards
+        var change = session.getPlayer().getDormManager().receiveLayoutRewards(req.getLayoutIds().toArray());
+
+        if (change == null) {
+            return session.encodeMsg(NetMsgId.dorm_layout_reward_receive_failed_ack);
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_layout_reward_receive_succeed_ack, change.toProto());
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormLearnReq.java

@@ -0,0 +1,17 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+
+@HandlerId(NetMsgId.dorm_learn_req)
+public class HandlerDormLearnReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Dorm quests are not implemented yet, so acknowledge the request without changing state.
+        return session.encodeMsg(NetMsgId.dorm_learn_succeed_ack);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormRewardReceiveReq.java

@@ -0,0 +1,28 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormRewardReceive.DormRewardReceiveReq;
+
+@HandlerId(NetMsgId.dorm_reward_receive_req)
+public class HandlerDormRewardReceiveReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = DormRewardReceiveReq.parseFrom(message);
+
+        // Receive rewards
+        var change = session.getPlayer().getDormManager().receiveRewards(req.getRewardIds().toArray());
+
+        if (change == null) {
+            return session.encodeMsg(NetMsgId.dorm_reward_receive_failed_ack);
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_reward_receive_succeed_ack, change.toProto());
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormRoleInteractionReq.java

@@ -0,0 +1,49 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormRoleInteraction.DormRoleInteractionReq;
+import emu.nebula.proto.DormRoleInteraction.DormRoleInteractionResp;
+import emu.nebula.proto.Public;
+import emu.nebula.proto.PublicDorm.AffinityData;
+
+@HandlerId(NetMsgId.dorm_role_interaction_req)
+public class HandlerDormRoleInteractionReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = DormRoleInteractionReq.parseFrom(message);
+
+        // Interact with roles
+        var result = session.getPlayer().getDormManager().interactRoles(req.getRoleInteractions());
+        
+        if (result == null) {
+            return session.encodeMsg(NetMsgId.dorm_role_interaction_failed_ack);
+        }
+
+        // Build response
+        var rsp = DormRoleInteractionResp.newInstance()
+                .setChange(result.getChange().toProto());
+
+        for (var interaction : result.getInteractions()) {
+            int itemId = interaction.itemId();
+
+            var itemInfo = Public.ItemTpl.newInstance()
+                    .setTid(Math.max(itemId, 0))
+                    .setQty(itemId > 0 ? 1 : 0);
+
+            rsp.addInfoList(
+                    AffinityData.newInstance()
+                            .setAffinityInfo(interaction.character().getAffinityProto())
+                            .setItemInfo(itemInfo)
+            );
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_role_interaction_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormRoomBgmReq.java

@@ -0,0 +1,34 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DormRoomBgm.DormRoomBGMReq;
+
+@HandlerId(NetMsgId.dorm_room_bgm_req)
+public class HandlerDormRoomBgmReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = DormRoomBGMReq.parseFrom(message);
+
+        var manager = session.getPlayer().getDormManager();
+
+        // Validate the whole request before applying it
+        for (var bgm : req.getBGMList()) {
+            if (!manager.isRoomUnlocked(bgm.getDormRoomId()) || bgm.getDiscId() < 0) {
+                return session.encodeMsg(NetMsgId.dorm_room_bgm_failed_ack);
+            }
+        }
+
+        for (var bgm : req.getBGMList()) {
+            manager.setRoomBgm(bgm.getDormRoomId(), bgm.getDiscId());
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_room_bgm_succeed_ack);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormSetRoomSceneReq.java

@@ -0,0 +1,26 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.Public.UI32V;
+
+@HandlerId(NetMsgId.dorm_set_room_scene_req)
+public class HandlerDormSetRoomSceneReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = UI32V.parseFrom(message);
+
+        // Version = room id, Value = scene item id (0 clears the scene)
+        if (!session.getPlayer().getDormManager().setRoomScene(req.getVersion(), req.getValue())) {
+            return session.encodeMsg(NetMsgId.dorm_set_room_scene_failed_ack);
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_set_room_scene_succeed_ack);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDormUpdatePresetNameReq.java

@@ -0,0 +1,26 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.GameSession;
+import emu.nebula.net.HandlerId;
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.Public.StringV;
+
+@HandlerId(NetMsgId.dorm_update_preset_name_req)
+public class HandlerDormUpdatePresetNameReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = StringV.parseFrom(message);
+
+        // Version = preset/build id, Value = new name
+        if (!session.getPlayer().getDormManager().renamePreset(req.getVersion(), req.getValue())) {
+            return session.encodeMsg(NetMsgId.dorm_update_preset_name_failed_ack);
+        }
+
+        // Encode and send
+        return session.encodeMsg(NetMsgId.dorm_update_preset_name_succeed_ack);
+    }
+
+}