초기커밋

GameServer/MessageQueue/PacketHandler/AckReservationCancelToServerMQPacketHandler.cs

@@ -0,0 +1,27 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2GS_ACK_RESERVATION_CANCEL_TO_SERVER), typeof(AckReservationEnterToServerMQPacketHandler), typeof(RabbitMQ4Game))]
+public class AckReservationCancelToServerMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        NullReferenceCheckHelper.throwIfNull(msg, () => $"msg is null !!!");
+
+        await GameServerApp.getServerLogic().getReservationManager().ackCancelProcess(msg.AckReservationCancelToServer.RequestUserGuid);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/AckReservationEnterToServerMQPacketHandler.cs

@@ -0,0 +1,27 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2GS_ACK_RESERVATION_ENTER_TO_SERVER), typeof(AckReservationEnterToServerMQPacketHandler), typeof(RabbitMQ4Game))]
+public class AckReservationEnterToServerMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        NullReferenceCheckHelper.throwIfNull(msg, () => $"msg is null !!!");
+
+        await GameServerApp.getServerLogic().getReservationManager().ackProcess(msg.AckReservationEnterToServer);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/ChatMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.Chat), typeof(ChatMQPacketHandler), typeof(RabbitMQ4Game))]
+public class ChatMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        await Task.CompletedTask;
+
+        var msg = recvMessage as ServerMessage;
+        NullReferenceCheckHelper.throwIfNull(msg, () => $"msg is null !!!");
+
+        ChatNotifyHelper.send_S2C_NTF_MQ_CHAT(msg.Chat);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/ExchangeMannequinDisplayItemMQPacketHandler.cs

@@ -0,0 +1,35 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("allgameserver", typeof(ServerMessage.Types.ExchangeMannequinDisplayItemNoti), typeof(ExchangeMannequinDisplayItemMQPacketHandler), typeof(RabbitMQ4Game))]
+public class ExchangeMannequinDisplayItemMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+
+        var msg = recvMessage as ServerMessage;
+        NullReferenceCheckHelper.throwIfNull(msg, () => $"msg is null !!!");
+
+        MapManager.Instance.ExchangeMannequinDisplayItem(msg.ExchangeMannequinDisplayItemNoti.AnchorGuid, msg.ExchangeMannequinDisplayItemNoti.DisplayItemIds.ToList());
+        GameServerApp.getServerLogic().getMap().PropModifyNoti(msg.ExchangeMannequinDisplayItemNoti.AnchorGuid);
+
+        await Task.CompletedTask;
+
+        return result;
+    }
+
+    
+}

GameServer/MessageQueue/PacketHandler/FriendRequestMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.FriendRequestNoti), typeof(FriendRequestMQPacketHandler), typeof(RabbitMQ4Game))]
+public class FriendRequestMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        await Task.CompletedTask;
+
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+        
+        var handler = new NotifyFriendRequestHandler();
+        handler.send_GS2C_NTF_FRIEND_REQUEST(msg.FriendRequestNoti);
+        
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfAddBuildingProfitHistoryMQPacketHandler.cs

@@ -0,0 +1,72 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("allgameserver", typeof(ServerMessage.Types.GS2GS_NTF_ADD_BUILDING_PROFIT_HISTORY), typeof(NtfAddBuildingProfitHistoryMQPacketHandler), typeof(RabbitMQ4Game))]
+internal class NtfAddBuildingProfitHistoryMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+        var err_msg = string.Empty;
+
+        var server_logic = GameServerApp.getServerLogic();
+        ArgumentNullException.ThrowIfNull(server_logic, $"server_logic is null !!!");
+
+        var message = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(message, $"message is null !!!");
+
+        var ntf_add_building_profit_history = message.NtfAddBuildingProfitHistory;
+        ArgumentNullException.ThrowIfNull(ntf_add_building_profit_history, $"ntf_add_building_profit_history is null !!!");
+
+        if (ntf_add_building_profit_history.ExceptServerName == server_logic.getServerName())
+            return result;
+
+        Log.getLogger().info($"MQ - NtfAddBuildingProfitHistory");
+
+        if (!server_logic.getBuildingManager().tryGetBuilding(ntf_add_building_profit_history.BuildingMetaId, out var building))
+        {
+            err_msg = $"Failed to tryGetBuilding() !!! : buildingMetaId:{ntf_add_building_profit_history.BuildingMetaId}";
+            result.setFail(ServerErrorCode.BuildingNotFound, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            return result;
+        }
+
+        var profits = new Dictionary<CurrencyType, double>();
+        foreach(var (key, value) in ntf_add_building_profit_history.FloorProfit.Profits)
+        {
+            var currency_type = (CurrencyType)key;
+
+            profits[currency_type] = value.Amount;
+        }
+
+        var building_profit_history_agent_action = building.getEntityAction<BuildingProfitHistoryAgentAction>();
+        NullReferenceCheckHelper.throwIfNull(building_profit_history_agent_action, () => $"building_profit_history_agent_action is null !!!");
+
+        (result, var building_profit_history, _) = await BuildingProfitHistoryHelper.tryMakeBuildingProfitHistory(building, ntf_add_building_profit_history.BuildingMetaId, ntf_add_building_profit_history.Floor, ntf_add_building_profit_history.ProfitTime.ToDateTime(), ntf_add_building_profit_history.ProfitHistoryType, profits);
+        if (result.isFail())
+        {
+            err_msg = $"Failed to tryMakeBuildingProfitHistory() !!! : {result.toBasicString()}";
+            Log.getLogger().error(err_msg);
+
+            return result;
+        }
+        NullReferenceCheckHelper.throwIfNull(building_profit_history, () => $"building_profit_history is null !!!");
+
+        // Memory
+        building_profit_history_agent_action.addBuildingProfitHistory(building_profit_history);
+
+        return result;
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfAddBuildingRentalHistoryMQPacketHandler.cs

@@ -0,0 +1,64 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("allgameserver", typeof(ServerMessage.Types.GS2GS_NTF_ADD_BUILDING_RENTAL_HISTORY), typeof(NtfAddBuildingRentalHistoryMQPacketHandler), typeof(RabbitMQ4Game))]
+internal class NtfAddBuildingRentalHistoryMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+        var err_msg = string.Empty;
+
+        var server_logic = GameServerApp.getServerLogic();
+        ArgumentNullException.ThrowIfNull(server_logic, $"server_logic is null !!!");
+
+        var message = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(message, $"message is null !!!");
+
+        var ntf_add_building_rental_history = message. NtfAddBuildingRentalHistory;
+        ArgumentNullException.ThrowIfNull(ntf_add_building_rental_history, $"ntf_add_building_rental_history is null !!!");
+
+        if (ntf_add_building_rental_history.ExceptServerName == server_logic.getServerName())
+            return result;
+
+        Log.getLogger().info($"MQ - NtfAddBuildingRentalHistory");
+
+        if (!server_logic.getBuildingManager().tryGetBuilding(ntf_add_building_rental_history.BuildingMetaId, out var building))
+        {
+            err_msg = $"Failed to tryGetBuilding() !!! : buildingMetaId:{ntf_add_building_rental_history.BuildingMetaId}";
+            result.setFail(ServerErrorCode.BuildingNotFound, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            return result;
+        }
+
+        var building_rental_history_agent_action = building.getEntityAction<BuildingRentalHistoryAgentAction>();
+        NullReferenceCheckHelper.throwIfNull(building_rental_history_agent_action, () => $"building_rental_history_agent_action is null !!!");
+
+        (result, var building_rental_history, _) = await BuildingRentalHistoryHelper.tryMakeBuildingRentalHistory(building, ntf_add_building_rental_history.BuildingMetaId, ntf_add_building_rental_history.Floor, ntf_add_building_rental_history.RenteeUserGuid, ntf_add_building_rental_history.RentalTime.ToDateTime(), ntf_add_building_rental_history.RentalPeriod);
+        if (result.isFail())
+        {
+            err_msg = $"Failed to tryMakeBuildingRentalHistory() !!! : {result.toBasicString()}";
+            Log.getLogger().error(err_msg);
+
+            return result;
+        }
+        NullReferenceCheckHelper.throwIfNull(building_rental_history, () => $"building_rental_history is null !!!");
+
+        // Memory
+        building_rental_history_agent_action.addBuildingRentalHistory(building_rental_history);
+
+        return result;
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfBanPartyMQPacketHandler.cs

@@ -0,0 +1,30 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.BanPartyNoti), typeof(NtfBanPartyMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfBanPartyMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleBanPartyNoti");
+
+        var handler = new NotifyBanPartyMemberHandler();
+        await handler.recvBanPartyMember(msg.BanPartyNoti);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfBeaconCompactSyncMQPacketHandler.cs

@@ -0,0 +1,72 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2MQS_NTF_BEACON_COMPACT_SYNC), typeof(NtfBeaconCompactSyncMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfBeaconCompactSyncMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg, $"msg is null !!!");
+
+        var ntf_msg_beacon_compact_sync = msg.NtfBeaconCompactSync;
+        ArgumentNullException.ThrowIfNull(ntf_msg_beacon_compact_sync, $"ntf_msg_beacon_compact_sync is null !!!");
+
+        var server_logic = GameServerApp.getServerLogic();
+        var player_manager = server_logic.getPlayerManager();
+        ArgumentNullException.ThrowIfNull(server_logic, $"server_logic is null !!!");
+        ArgumentNullException.ThrowIfNull(player_manager, $"player_manager is null !!!");
+
+        var user_guid = ntf_msg_beacon_compact_sync.UserGuid;
+        if (player_manager.tryGetUserByPrimaryKey(user_guid, out var found_user) == false)
+        {
+            var err_msg = $"Failed to tryGetUserByPrimaryKey() !!!, Not found Player !!! : UserGuid:{user_guid}";
+            result.setFail(ServerErrorCode.UserNotLogin, err_msg);
+            Log.getLogger().info(result.toBasicString());
+
+            return result;
+        }
+
+        var player_action = found_user.getEntityAction<PlayerAction>();
+        ArgumentNullException.ThrowIfNull(player_action, $"player_action is null !!! - {found_user.toBasicString()}");
+
+        var ugc_npc_compact = ntf_msg_beacon_compact_sync.UgcNpcCompact;
+        ArgumentNullException.ThrowIfNull(ugc_npc_compact, $"ugc_npc_compact is null !!! - {found_user.toBasicString()}");
+
+        var had_ugc_npcs = player_action.getHadUgcNpcs();
+        ArgumentNullException.ThrowIfNull(had_ugc_npcs, $"had_ugc_npcs is null !!! - {found_user.toBasicString()}");
+
+        var ugc_npc_meta_guid = ugc_npc_compact.UgcNpcMetaGuid;
+        if (false == had_ugc_npcs.TryGetValue(ugc_npc_meta_guid, out var found_ugc_npc))
+        {
+            var err_msg = $"Not found UgcNpc !!! : ugcNpcMetaGuid:{ugc_npc_meta_guid} - {found_user.toBasicString()}";
+            result.setFail(ServerErrorCode.UgcNpcNotFound, err_msg);
+            Log.getLogger().info(result.toBasicString());
+
+            return result;
+        }
+
+        var ugc_npc_action = found_ugc_npc.getEntityAction<UgcNpcAction>();
+        ArgumentNullException.ThrowIfNull(ugc_npc_action, $"ugc_npc_action is null !!! - {found_user.toBasicString()}");
+
+        ugc_npc_action.updateUgcNpcCompact(ntf_msg_beacon_compact_sync);
+
+        UgcNpcNotifyHelper.send_GS2C_NTF_BEACON_COMPACT_UPDATE(found_user, found_ugc_npc, ugc_npc_compact);
+
+        return await Task.FromResult(result);
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfBeaconShopUpdateItemMQPacketHandler.cs

@@ -0,0 +1,69 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+using static ClientToGameMessage.Types;
+using BEACON_GUID = System.String;
+using USER_GUID = System.String;
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("allgameserver", typeof(ServerMessage.Types.GS2GS_NTF_UPDATE_BEACON_SHOP_ITEM), typeof(NtfBeaconShopUpdateItemMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfBeaconShopUpdateItemMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        BEACON_GUID beacon_guid = msg.NtfUpdateBeaconShopItem.TargetBeaconGuid;
+        USER_GUID beacon_owner_guid = msg.NtfUpdateBeaconShopItem.TargetUserGuid;
+
+        var server_logic = GameServerApp.getServerLogic();
+        ArgumentNullException.ThrowIfNull(server_logic);
+
+        (result, var found_ugc_npc, var ugc_npc_owner) = await NpcHelper.findUgcNpc(beacon_guid, beacon_owner_guid);
+        if (found_ugc_npc == null)
+        {
+            return result;
+        }
+
+        var ugc_npc_beacon_shop_action = found_ugc_npc.getEntityAction<UgcNpcBeaconShopAction>();
+        ugc_npc_beacon_shop_action.setUpdateBeaconShopItem();
+
+        var packet = BeaconShopNotifyHelper.makeAckBeaconShopRefreshPacket(beacon_guid);
+
+        if (server_logic.getServerType().toServerType() == ServerType.Channel)
+        {
+            var receivers = server_logic.getPlayerManager().getUsers();
+            foreach (var receiver in receivers)
+            {
+                receiver.Value.send_S2C_NTF_BEACON_SHOP_REFRESH(beacon_guid);
+            }
+        }
+        else if(server_logic.getServerType().toServerType() == ServerType.Indun)
+        {
+            foreach (var each in InstanceRoomManager.Instance.getInstanceRooms())
+            {
+                var room_key = each.Key;
+                var instance_room = each.Value;
+
+                found_ugc_npc = instance_room.getMap().findUgcNpc(beacon_guid);
+                if (null != found_ugc_npc)
+                {
+                    instance_room.Broadcast(packet);
+                }
+            }
+        }
+        
+        return result;
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfBeaconShopUpdateSoldRecordMQPacketHandler.cs

@@ -0,0 +1,45 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2GS_NTF_UPDATE_SOLD_RECORD), typeof(NtfBeaconShopUpdateSoldRecordMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfBeaconShopUpdateSoldRecordMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        await Task.CompletedTask;
+
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        var server_logic = GameServerApp.getServerLogic();
+        var player_manager = server_logic.getPlayerManager();
+        ArgumentNullException.ThrowIfNull(server_logic);
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        var result = new Result();
+        if (player_manager.tryGetUserByPrimaryKey(msg.NtfUpdateSoldRecord.TargetUserGuid, out var found_user) == false)
+        { 
+            var err_msg = $"Failed to tryGetUserByPrimaryKey() !!!, Not found : TargetUserGuid:{msg.NtfUpdateSoldRecord.TargetUserGuid}";
+            result.setFail(ServerErrorCode.UserNotLogin, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+
+        var found_user_beacon_shop_action = found_user.getEntityAction<BeaconShopAction>();
+        found_user_beacon_shop_action.setUpdateSoldRecord();
+
+        return result;
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfCancelFriendRequestMQPacketHandler.cs

@@ -0,0 +1,30 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.CancelFriendRequestNoti), typeof(NtfCancelFriendRequestMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfCancelFriendRequestMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+
+        var handler = new NotifyFriendRequestCancelHandler();
+        handler.send_GS2C_NTF_FRIEND_REQUEST_CANCEL(msg.CancelFriendRequestNoti);
+
+
+        return await Task.FromResult(new Result());
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfCancelSummonPartyMemberMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.CancelSummonPartyMemberNoti), typeof(NtfCancelSummonPartyMemberMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfCancelSummonPartyMemberMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleCancelSummonPartyMemberNoti");
+
+        var handler = new NotifyCancelSummonHandler();
+        await handler.recvCancelSummonHandler(msg.CancelSummonPartyMemberNoti);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfChangeCaliumStorageInfoMQPacketHandler.cs

@@ -0,0 +1,34 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("allgameserver", typeof(ServerMessage.Types.GS2GS_NTF_CHANGE_CALIUM_STORAGE_INFO), typeof(NtfChangeCaliumStorageInfoMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfChangeCaliumStorageInfoMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var server_logic = GameServerApp.getServerLogic();
+        var rabbitMq = server_logic.getRabbitMqConnector() as RabbitMqConnector;
+        NullReferenceCheckHelper.throwIfNull(rabbitMq, () => "rabbitMq is null !!!");
+        
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        var calium_storage_entity = server_logic.findGlobalEntity<CaliumStorageEntity>();
+        NullReferenceCheckHelper.throwIfNull(calium_storage_entity, () => "calium_storage_entity is null !!!");
+
+        var calium_storage_action = calium_storage_entity.getEntityAction<CaliumStorageAction>();
+        NullReferenceCheckHelper.throwIfNull(calium_storage_action, () => $"calium_storage_action is null !!! - {calium_storage_entity.toBasicString()}");
+
+        return await calium_storage_action.loadStorageAttribute();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfChangePartyLeaderMQPacketHandler.cs

@@ -0,0 +1,27 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.ChangePartyLeaderNoti), typeof(NtfChangePartyLeaderMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfChangePartyLeaderMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleChangePartyLeaderNoti");
+        var handler = new NotifyChangePartyLeaderGuidHandler();
+        await handler.recvChangePartyLeaderGuid(msg.ChangePartyLeaderNoti);
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfChangePartyServerNameMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.ChangePartyServerNameNoti), typeof(NtfChangePartyServerNameMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfChangePartyServerNameMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleAddPartyServerNameNoti");
+
+        var notify_handler = new NotifyChangePartyServerHandler();
+        await notify_handler.recvChangePartyServer(msg.ChangePartyServerNameNoti);
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfClearPartySummonMQPacketHandler.cs

@@ -0,0 +1,28 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2GS_NTF_CLEAR_PARTY_SUMMON), typeof(NtfClearPartySummonMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfClearPartySummonMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleReplySummonPartyMemberNoti");
+        var handler = new NotifyClearPartySummonHandler();
+        await handler.recvClearPartySummon(msg.NtfClearPartySummon);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfCraftHelpMQPacketHandler.cs

@@ -0,0 +1,39 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2GS_NTF_CRAFT_HELP), typeof(NtfCraftHelpMQPacketHandler), typeof(RabbitMQ4Game))]
+internal class NtfCraftHelpMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+
+        var server_logic = GameServerApp.getServerLogic();
+        var player_manager = server_logic.getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        if (player_manager.tryGetUserByPrimaryKey(msg.NtfCraftHelp.OwnerGuid, out var player) == true)
+        {
+            var craft_action = player.getEntityAction<CraftAction>();
+            ArgumentNullException.ThrowIfNull(craft_action);
+            craft_action.setUpdateCraft(true);
+            CraftNotifyHelper.send_S2C_NTF_CRAFT_HELPED(player, msg.NtfCraftHelp.OwnerHelpedCount, msg.NtfCraftHelp.HelpUserName);
+        }
+        InstanceRoomManager.Instance.ExchangeCraft(msg.NtfCraftHelp.RoomId, msg.NtfCraftHelp.AnchorGuid, msg.NtfCraftHelp.CraftFinishTime);
+
+        return await Task.FromResult(new Result());
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfDeletePartyInviteSendMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2GS_NTF_DELETE_PARTY_INVITE_SEND), typeof(NtfDeletePartyInviteSendMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfDeletePartyInviteSendMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleDeletePartyInviteSendNoti");
+        var handler = new NotifyDeletePartyInviteSendHandler();
+        await handler.recvDeletePartyInviteSend(msg.NtfDeletePartyInviteSend);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfDestroyPartyMQPacketHandler.cs

@@ -0,0 +1,28 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2C_NTF_DESTROY_PARTY), typeof(NtfDestroyPartyMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfDestroyPartyMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"NtfDestroyPartyMQPacketHandler");
+        var handler = new NotifyDestroyPartyHandler();
+        await handler.recvDestroyParty(msg.NtfDestroyParty);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfExchangeMyhomeMQPacketHandler.cs

@@ -0,0 +1,28 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2GS_NTF_EXCHANGE_MYHOME), typeof(NtfExchangeMyhomeMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfExchangeMyhomeMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+
+        Log.getLogger().info($"handleNtfExchangeMyhome");
+        await InstanceRoomManager.Instance.ExchangeMyHome(msg.NtfExchangeMyhome.RoomId, msg.NtfExchangeMyhome.MyhomeGuid, msg.NtfExchangeMyhome.MyhomeInfo);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfExchangePartyMemberMarkMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.ExchangePartyMemberMarkNoti), typeof(NtfExchangePartyMemberMarkMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfExchangePartyMemberMarkMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleExchangePartyMemberMarkNoti");
+        var handler = new NotifyChangePartyMemberMarker();
+        await handler.recvChangePartyMemberMarkerHandler(msg.ExchangePartyMemberMarkNoti);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfExchangePartyNameMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.ExchangePartyNameNoti), typeof(NtfExchangePartyNameMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfExchangePartyNameMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleExchangePartyNameNoti");
+        var handler = new NotifyChangePartyNameHandler();
+        await handler.recvChangePartyNameHandler(msg.ExchangePartyNameNoti);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfFarmingEndMQPacketHandler.cs

@@ -0,0 +1,80 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2MQS_NTF_FARMING_END), typeof(NtfFarmingEndMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfFarmingEndMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg, $"msg is null !!!");
+
+        var ntf_msg_farming_end = msg.NtfFarmingEnd;
+        ArgumentNullException.ThrowIfNull(ntf_msg_farming_end, $"ntf_msg_farming_end is null !!!");
+
+        var server_logic = GameServerApp.getServerLogic();
+        var player_manager = server_logic.getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager, $"player_manager is null !!!");
+
+        if (player_manager.tryGetUserByPrimaryKey(ntf_msg_farming_end.UserGuid, out var found_user) == false)
+        {
+            var err_msg = $"Failed to tryGetUserByPrimaryKey() !!!, Not found Player !!! : UserGuid:{msg.ReceiveMailNoti.AccountGuid}";
+            result.setFail(ServerErrorCode.UserNotLogin, err_msg);
+            Log.getLogger().info(result.toBasicString());
+
+            return result;
+        }
+
+        var player_action = found_user.getEntityAction<PlayerAction>();
+        ArgumentNullException.ThrowIfNull(player_action, $"player_action is null !!! - {found_user.toBasicString()}");
+
+        var farming_summary = ntf_msg_farming_end.FarmingSummary;
+        ArgumentNullException.ThrowIfNull(farming_summary, $"farming_summary is null !!! - {found_user.toBasicString()}");
+
+        if (FarmingSummonedEntityType.Beacon == farming_summary.FarmingSummonType)
+        {
+            var had_ugc_npcs = player_action.getHadUgcNpcs();
+            ArgumentNullException.ThrowIfNull(had_ugc_npcs, $"had_ugc_npcs is null !!! - {found_user.toBasicString()}");
+
+            if (false == had_ugc_npcs.TryGetValue(farming_summary.FarmingEntityGuid, out var found_ugc_npc))
+            {
+                var err_msg = $"Not found UgcNpc !!! : ugcNpcMetaGuid:{farming_summary.FarmingEntityGuid} - {found_user.toBasicString()}";
+                result.setFail(ServerErrorCode.UgcNpcNotFound, err_msg);
+                Log.getLogger().info(result.toBasicString());
+
+                return result;
+            }
+
+            Log.getLogger().info($"UgcNpc reset of State !!! in onProcessPacket() by GS2MQS_NTF_FARMING_END : {found_ugc_npc.toStateString()} - {found_ugc_npc.toBasicString()}");
+
+            var farming_action = found_ugc_npc.getEntityAction<FarmingAction>();
+            ArgumentNullException.ThrowIfNull(farming_action, $"farming_action is null !!! - {found_user.toBasicString()}");
+
+            result = await farming_action.resetFarmingState(ntf_msg_farming_end.IsApplyDb == BoolType.True);
+            if(result.isFail())
+            {
+                var err_msg = $"Failed to resetFarmingState() !!! : {result.toBasicString()} - {found_user.toBasicString()}";
+                Log.getLogger().error(err_msg);
+
+                return result;
+            }
+        }
+
+        FarmingNotifyHelper.send_GS2C_NTF_FARMING_END(found_user, farming_summary);
+
+        return result;
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfFriendAcceptMQPacketHandler.cs

@@ -0,0 +1,55 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.FriendAcceptNoti), typeof(NtfFriendAcceptMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfFriendAcceptMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+
+        var result = new Result();
+        var player_manager = GameServerApp.getServerLogic().getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        if (false == player_manager.tryGetUserByPrimaryKey(msg.FriendAcceptNoti.ReceiverGuid, out var player))
+        {
+            var err_msg = $"{msg.FriendAcceptNoti.ReceiverGuid} user not exist this Server";
+
+            result.setFail(ServerErrorCode.UserNotLogin, err_msg);
+            Log.getLogger().warn(result.toBasicString());
+            return result;
+        }
+        var friend_agent_action = player.getEntityAction<FriendAgentAction>();
+        ArgumentNullException.ThrowIfNull(friend_agent_action, $"friend_agent_action is null !!!");
+        //신규 친구에 대한 로드
+        await friend_agent_action.loadFriends();
+
+        var handler = new NotifyReplyFriendRequestHandler();
+        handler.send_GS2C_NTF_FRIEND_ACCEPT(player, msg.FriendAcceptNoti);
+
+        if (msg.FriendAcceptNoti.AcceptOrRefuse == 1)
+        {
+            //수락인 경우 퀘스트 체크
+            QuestManager.It.QuestCheck(player, new QuestFriend(EQuestEventTargetType.FRIEND, EQuestEventNameType.ADDED)).Wait();
+
+            //수락인 경우 상대방에게 내 stateNoti
+            await player.send_GS2CS_NTF_STATE_TO_FRIEND(msg.FriendAcceptNoti.SenderGuid);
+        }
+
+        return result;
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfFriendDeleteMQPacketHandler.cs

@@ -0,0 +1,45 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.FriendDeleteNoti), typeof(NtfFriendDeleteMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfFriendDeleteMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+
+        //유저 데이터에서 삭제 처리
+        var player_manager = GameServerApp.getServerLogic().getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        var result = new Result();
+        if (false == player_manager.tryGetUserByPrimaryKey(msg.FriendDeleteNoti.ReceiverGuid, out var player))
+        {
+            var err_msg = $"{msg.FriendDeleteNoti.ReceiverGuid} user not exist this Server";
+            result.setFail(ServerErrorCode.UserNotLogin, err_msg);
+            Log.getLogger().warn(result.toBasicString());
+            return result;
+        }
+        var friend_agent_action = player.getEntityAction<FriendAgentAction>();
+        //친구 메모리에서 삭제
+        friend_agent_action.deleteFriend(msg.FriendDeleteNoti.SenderGuid);
+
+        var handler = new NotifyFriendDeleteHandler();
+        handler.send_GS2C_NTF_FRIEND_DELETE(msg.FriendDeleteNoti);
+
+        return await Task.FromResult(result);
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfFriendLeavingHomeMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2C_NTF_FRIEND_LEAVING_HOME), typeof(NtfFriendLeavingHomeMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfFriendLeavingHomeMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        var handler = new NotifyFriendLeavingHomeHandler();
+        handler.send_GS2C_NTF_FRIEND_LEAVING_HOME(msg.NtfFriendLeavingHome);
+
+        return await Task.FromResult(new Result());
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfInvitePartyMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.InvitePartyNoti), typeof(NtfInvitePartyMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfInvitePartyMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleInvitePartyNoti");
+
+        var handler = new NotifyInvitePartySendHandler();
+        await handler.recvInvitePartySend(msg.InvitePartyNoti);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfInvitePartyRecvResultMQPacketHandler.cs

@@ -0,0 +1,25 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2C_NTF_PARTY_INVITE_RESULT), typeof(NtfInvitePartyRecvResultMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfInvitePartyRecvResultMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+        var handler = new NotifyInvitePartyRecvResultHandler();
+        await handler.recvInvitePartyRecvResult(msg.NtfInvitePartyRecvResult);
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfJoinPartyMemberMQPacketHandler.cs

@@ -0,0 +1,42 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+using Newtonsoft.Json;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.JoinPartyMemberNoti), typeof(NtfJoinPartyMemberMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfJoinPartyMemberMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleJoinPartyMemberNoti");
+
+        var result = new Result();
+        var joinMemberInfo = JsonConvert.DeserializeObject<PartyMemberInfo>(msg.JoinPartyMemberNoti.JoinPartyMemberInfo);
+        if (joinMemberInfo == null)
+        {
+            var err_msg = $"joinMemberInfo is null";
+
+            result.setFail(ServerErrorCode.JoiningPartyMemberInfoIsNull, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+            
+
+        var handler = new NotifyJoinPartyMemberHandler();
+        await handler.recvJoinPartyMember(msg.JoinPartyMemberNoti);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfLandAuctionHighestBidderChangeMQPacketHandler.cs

@@ -0,0 +1,73 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+
+using META_ID = System.UInt32;
+
+
+[PacketHandler("allgameserver", typeof(ServerMessage.Types.GS2GS_NTF_LAND_AUCTION_HIGHEST_BIDDER_CHANGE), typeof(NtfLandAuctionHighestBidderChangeMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfLandAuctionHighestBidderChangeMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg, $"msg is null !!!");
+
+        var ntf_land_auction_highest_bidder_change = msg.NtfLandAuctionHighestBidderChange;
+        ArgumentNullException.ThrowIfNull(ntf_land_auction_highest_bidder_change, $"ntf_land_auction_highest_bidder_change is null !!!");
+
+        var server_logic = GameServerApp.getServerLogic();
+        var player_manager = server_logic.getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager, $"player_manager is null !!!");
+
+        var receiver_user_guid = ntf_land_auction_highest_bidder_change.ReceiverUserGuid;
+        if (player_manager.tryGetUserByPrimaryKey(receiver_user_guid, out var found_user) == false)
+        {
+            var err_msg = $"Failed to tryGetUserByPrimaryKey() !!!, Not found Player !!! : UserGuid:{receiver_user_guid}";
+            result.setFail(ServerErrorCode.UserNotLogin, err_msg);
+            Log.getLogger().info(result.toBasicString());
+
+            return result;
+        }
+
+        var has_received_refund_mail = ntf_land_auction_highest_bidder_change.HasReceivedRefundMail;
+
+        var land_meta_id = (META_ID)ntf_land_auction_highest_bidder_change.LandMetaId;
+        var bid_currency_type = ntf_land_auction_highest_bidder_change.CurrencyType;
+        var highest_bid_price = ntf_land_auction_highest_bidder_change.HighestBidPrice;
+        var highest_bid_user_guid = ntf_land_auction_highest_bidder_change.HighestBidUserGuid;
+        var highest_bid_user_nickname = ntf_land_auction_highest_bidder_change.HighestBidUserNickname;
+
+        if (false == LandAuctionNotifyHelper.send_GS2C_NTF_LAND_AUCTION_HIGHEST_BIDDER_CHANGE( found_user
+                                                                                             , land_meta_id
+                                                                                             , bid_currency_type, highest_bid_price
+                                                                                             , highest_bid_user_guid, highest_bid_user_nickname ) )
+        {
+            var err_msg = $"Failed to send_GS2C_NTF_LAND_AUCTION_HIGHEST_BIDDER_CHANGE() !!! : LandMetaId:{land_meta_id} - {found_user.toBasicString()}";
+            Log.getLogger().error(err_msg);
+        }
+
+        if ( BoolType.True == has_received_refund_mail )
+        {
+            var mail_action = found_user.getEntityAction<MailAction>();
+            NullReferenceCheckHelper.throwIfNull(mail_action, () => $"mail_action is null !!!");
+
+            mail_action.NewReceivedMail();
+        }
+
+        return await Task.FromResult(result);
+    }
+}
+

GameServer/MessageQueue/PacketHandler/NtfLandAuctionReservationMQPacketHandler.cs

@@ -0,0 +1,58 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+using META_ID = System.UInt32;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("allgameserver", typeof(ServerMessage.Types.GS2GS_NTF_LAND_AUCTION_RESERVATION), typeof(NtfLandAuctionReservationMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfLandAuctionReservationMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+        var err_msg = string.Empty;
+
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg, $"msg is null !!!");
+
+        var ntf_land_auction_reservation = msg.NtfLandAuctionReservation;
+        ArgumentNullException.ThrowIfNull(ntf_land_auction_reservation, $"ntf_land_auction_reservation is null !!!");
+
+        var server_logic = GameServerApp.getServerLogic();
+        var requestor_id = server_logic.getServerName();
+
+        if (server_logic.getServerType().toServerType() != ServerType.Channel)
+        {
+            err_msg = $"Invalid ServerType.Channel !!! : ServerType.Channel == {server_logic.getServerType().toServerType()} - {server_logic.toBasicString()}";
+            Log.getLogger().debug(err_msg);
+            return result;
+        }
+
+        var call_tid = System.Guid.NewGuid().ToString("N");
+
+        var to_add_activitings = ntf_land_auction_reservation.ToAddActivitings;
+        NullReferenceCheckHelper.throwIfNull(to_add_activitings, () => $"to_add_activitings is null !!!");
+
+        result = await LandAuctionManager.It.tryActivitingLandAuctions(requestor_id, to_add_activitings.Select(x => (META_ID)x).ToList(), call_tid);
+        if(result.isFail())
+        {
+            err_msg = $"Failed to tryActivitingLandAuctions() !!! : {result.toBasicString()} - {server_logic.toBasicString()}";
+            Log.getLogger().debug(err_msg);
+            return result;
+        }
+
+        return result;
+    }
+}
+

GameServer/MessageQueue/PacketHandler/NtfLandAuctionWinningBidMQPacketHandler.cs

@@ -0,0 +1,131 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+using META_ID = System.UInt32;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("allgameserver", typeof(ServerMessage.Types.GS2GS_NTF_LAND_AUCTION_WINNING_BID), typeof(NtfLandAuctionWinningBidMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfLandAuctionWinningBidMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+        var err_msg = string.Empty;
+
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg, $"msg is null !!!");
+
+        var ntf_land_auction_wiinning_bid = msg.NtfLandAuctionWinningBid;
+        ArgumentNullException.ThrowIfNull(ntf_land_auction_wiinning_bid, $"ntf_land_auction_wiinning_bid is null !!!");
+
+        var server_logic = GameServerApp.getServerLogic();
+        var db_connector = server_logic.getDynamoDbClient();
+
+        var player_manager = server_logic.getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager, $"player_manager is null !!!");
+
+        var wining_user_guid = ntf_land_auction_wiinning_bid.WinningUserGuid;
+        var winning_user_nickname = ntf_land_auction_wiinning_bid.WinningUserNickname;
+        var land_meta_id = ntf_land_auction_wiinning_bid.LandMetaId;
+        var buidling_meta_ids = ntf_land_auction_wiinning_bid.BuildingMetaIds;
+        var is_new_recv_mail = ntf_land_auction_wiinning_bid.IsNewRecvMail;
+
+        if (player_manager.tryGetUserByPrimaryKey(wining_user_guid, out var found_user) == true)
+        {
+            // 1. 낙찰된 랜드 정보 읽기
+            {
+                (result, var make_primary_key) = await DynamoDBDocBaseHelper.makePrimaryKey<OwnedLandDoc>(wining_user_guid, land_meta_id.ToString());
+                if (result.isFail())
+                {
+                    err_msg = $"Failed to makePrimaryKey<OwnedLandDoc>() !!! : {result.toBasicString()} - landMetaId:{land_meta_id}";
+                    Log.getLogger().error(err_msg);
+                    return result;
+                }
+                NullReferenceCheckHelper.throwIfNull(make_primary_key, () => $"make_primary_key is null !!!");
+                var query_config = db_connector.makeQueryConfigForReadByPKSK(make_primary_key.PK, make_primary_key.SK);
+                (result, var read_doc) = await db_connector.simpleQueryDocTypeWithQueryOperationConfig<OwnedLandDoc>(query_config);
+                if (result.isFail())
+                {
+                    err_msg = $"Failed to simpleQueryDocTypeWithQueryOperationConfig<OwnedLandDoc>() !!! : {result.toBasicString()} - {found_user.toBasicString()}";
+                    Log.getLogger().error(err_msg);
+                    return result;
+                }
+                NullReferenceCheckHelper.throwIfNull(read_doc, () => $"read_doc is null !!! - {found_user.toBasicString()}");
+
+                var owned_land_agent_action = found_user.getEntityAction<OwnedLandAgentAction>();
+                NullReferenceCheckHelper.throwIfNull(owned_land_agent_action, () => $"owned_land_agent_action is null !!! - {found_user.toBasicString()}");
+
+                result = await owned_land_agent_action.tryAddOwnedLandFromDoc(read_doc);
+                if (result.isFail())
+                {
+                    err_msg = $"Failed to tryAddOwnedLandFromDoc() !!! : {result.toBasicString()} - {found_user.toBasicString()}";
+                    Log.getLogger().error(err_msg);
+                    return result;
+                }
+            }
+
+            // 2. 랜드와 연결된 빌딩 정보 읽기
+            {
+                foreach(var building_meta_id in buidling_meta_ids)
+                {
+                    (result, var make_primary_key) = await DynamoDBDocBaseHelper.makePrimaryKey<OwnedBuildingDoc>(wining_user_guid, building_meta_id.ToString());
+                    if (result.isFail())
+                    {
+                        err_msg = $"Failed to makePrimaryKey<OwnedBuildingDoc>() !!! : {result.toBasicString()} - landMetaId:{building_meta_id}";
+                        Log.getLogger().error(err_msg);
+                        return result;
+                    }
+                    NullReferenceCheckHelper.throwIfNull(make_primary_key, () => $"make_primary_key is null !!!");
+                    var query_config = db_connector.makeQueryConfigForReadByPKSK(make_primary_key.PK, make_primary_key.SK);
+                    (result, var read_doc) = await db_connector.simpleQueryDocTypeWithQueryOperationConfig<OwnedBuildingDoc>(query_config);
+                    if (result.isFail())
+                    {
+                        err_msg = $"Failed to simpleQueryDocTypeWithQueryOperationConfig<OwnedBuildingDoc>() !!! : {result.toBasicString()} - {found_user.toBasicString()}";
+                        Log.getLogger().error(err_msg);
+                        return result;
+                    }
+                    NullReferenceCheckHelper.throwIfNull(read_doc, () => $"read_doc is null !!! - {found_user.toBasicString()}");
+
+                    var owned_building_agent_action = found_user.getEntityAction<OwnedBuildingAgentAction>();
+                    NullReferenceCheckHelper.throwIfNull(owned_building_agent_action, () => $"owned_building_agent_action is null !!!");
+
+                    result = await owned_building_agent_action.tryAddOwnedBuildingFromDoc(read_doc);
+                    if (result.isFail())
+                    {
+                        err_msg = $"Failed to tryAddOwnedBuildingFromDoc() !!! : {result.toBasicString()} - {found_user.toBasicString()}";
+                        Log.getLogger().error(err_msg);
+                        return result;
+                    }
+                }              
+            }
+
+            found_user.send_S2C_NTF_OWNED_LAND_INFOS();
+            found_user.send_S2C_NTF_OWNED_BUILDING_INFOS();
+
+            if(BoolType.True == is_new_recv_mail)
+            {
+                var found_user_mail_action = found_user.getEntityAction<MailAction>();
+                NullReferenceCheckHelper.throwIfNull(found_user_mail_action, () => $"found_user_mail_action is null !!!");
+
+                found_user_mail_action.NewReceivedMail();
+            }
+        }
+
+        LandAuctionNotifyHelper.broadcast_GS2C_NTF_LAND_AUCTION_WINNING_BID(winning_user_nickname, (META_ID)land_meta_id);
+
+        return await Task.FromResult(result);
+    }
+}
+

GameServer/MessageQueue/PacketHandler/NtfLeavePartyMemberMQPacketHandler.cs

@@ -0,0 +1,30 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.LeavePartyMemberNoti), typeof(NtfLeavePartyMemberMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfLeavePartyMemberMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleLeavePartyMemberNoti");
+
+        var handler = new NotifyLeavePartyMemberHandler();
+        await handler.recvLeavePartyMember(msg.LeavePartyMemberNoti);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfLoginToFriendMQPacketHandler.cs

@@ -0,0 +1,47 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.LoginNotiToFriend), typeof(NtfLoginToFriendMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfLoginToFriendMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+
+        var handler = new NotifyFriendLoginHandler();
+
+        var player_manager = GameServerApp.getServerLogic().getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        var result = new Result();
+        if (false == player_manager.tryGetUserByPrimaryKey(msg.LoginNotiToFriend.BaseInfo.ReceiverGuid, out var player))
+        {
+            var err_msg = $"{msg.LoginNotiToFriend.BaseInfo.SenderGuid} user not exist this Server";
+            result.setFail(ServerErrorCode.UserNotLogin, err_msg);
+
+            Log.getLogger().warn(result.toBasicString());
+            return result;
+        }
+
+        handler.send_GS2C_NTF_LOGIN_TO_FRIEND(player, msg.LoginNotiToFriend);
+
+        //상대방에게 내 상태 정보 알려주기
+        await player.send_GS2CS_NTF_STATE_TO_FRIEND(msg.LoginNotiToFriend.BaseInfo.SenderGuid);
+
+        return result;
+    }
+
+}

GameServer/MessageQueue/PacketHandler/NtfLogoutToFriendMQPacketHandler.cs

@@ -0,0 +1,30 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.LogoutNotiToFriend), typeof(NtfLogoutToFriendMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfLogoutToFriendMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+
+        var handler = new NotifyFriendLogoutHandler();
+        handler.send_GS2C_NTF_FRIEND_LOGOUT(msg.LogoutNotiToFriend);
+
+        return await Task.FromResult(new Result());
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfMailSendPacketHandler.cs

@@ -0,0 +1,32 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.MOS2GS_NTF_MAIL_SEND), typeof(NtfMailSendPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfMailSendPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+
+        //var handler = new NotifyFriendLogoutHandler();
+        //handler.send_GS2C_NTF_FRIEND_LOGOUT(msg.LogoutNotiToFriend);
+        var handler = new RabbitMailSendHandler();
+        await handler.MOS2GS_mailSend(msg.NtfMailSend);
+
+        return new();
+    }
+}   

GameServer/MessageQueue/PacketHandler/NtfModifyBuildingInfoMQPacketHandler.cs

@@ -0,0 +1,68 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("allgameserver", typeof(ServerMessage.Types.GS2GS_NTF_MODIFY_BUILDING_INFO), typeof(NtfModifyBuildingInfoMQPacketHandler), typeof(RabbitMQ4Game))]
+internal class NtfModifyBuildingInfoMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+        var err_msg = string.Empty;
+
+        var server_logic = GameServerApp.getServerLogic();
+
+        var message = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(message, $"message is null !!!");
+
+        var ntf_modify_building_info = message.NtfModifyBuildingInfo;
+        if (ntf_modify_building_info.ExceptServerName == server_logic.getServerName())
+            return result;
+
+        Log.getLogger().info($"MQ - NtfModifyBuildingInfos");
+
+        var building_infos = ntf_modify_building_info.BuildingInfos.ToList();
+
+        foreach ( var building_info in building_infos )
+        {
+            if (!MapManager.Instance.GetBuildingMapTree(building_info.BuildingMetaId, out var building_map_tree))
+            {
+                err_msg = $"Failed to GetLandMapTree() !!! : LandMetaId:{building_info.BuildingMetaId}";
+                result.setFail(ServerErrorCode.BuildingMapTreeDataNotFound, err_msg);
+                Log.getLogger().error(result.toBasicString());
+
+                continue;
+            }
+
+            var building_manager = server_logic.getBuildingManager();
+            if (!building_manager.tryGetBuilding(building_info.BuildingMetaId, out var building))
+            {
+                err_msg = $"Failed to tryGetBuilding() !!! : buildingMetaId:{building_info.BuildingMetaId}";
+                result.setFail(ServerErrorCode.BuildingNotFound, err_msg);
+                Log.getLogger().error(result.toBasicString());
+
+                continue;
+            }
+
+            var building_action = building.getEntityAction<BuildingAction>();
+            ArgumentNullReferenceCheckHelper.throwIfNull(building_action, () => $"building_action is null !!!");
+
+            // 빌딩 정보 수정
+            building_action.modifyBuildingInfo(building_info);
+        }
+
+        BuildingNotifyHelper.broadcast_S2C_NTF_BUILDING_INFOS(building_infos);
+
+        return await Task.FromResult(result);
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfModifyBuildingProfitMQPacketHandler.cs

@@ -0,0 +1,81 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("allgameserver", typeof(ServerMessage.Types.GS2GS_NTF_MODIFY_BUILDING_PROFIT), typeof(NtfModifyBuildingProfitMQPacketHandler), typeof(RabbitMQ4Game))]
+internal class NtfModifyBuildingProfitMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+        var err_msg = string.Empty;
+
+        var server_logic = GameServerApp.getServerLogic();
+
+        var message = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(message, $"message is null !!!");
+
+        var ntf_modify_building_profit = message.NtfModifyBuildingProfit;
+        if (ntf_modify_building_profit.ExceptServerName == server_logic.getServerName())
+            return result;
+
+        Log.getLogger().info($"NtfModifyBuildingProfit");
+
+        var building_manager = server_logic.getBuildingManager();
+        if (!building_manager.tryGetBuilding(ntf_modify_building_profit.BuildingMetaId, out var building))
+        {
+            err_msg = $"Failed to tryGetBuilding() !!! : buildingMetaId:{ntf_modify_building_profit.BuildingMetaId}";
+            result.setFail(ServerErrorCode.BuildingNotFound, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            return result;
+        }
+
+        var building_profit_agent_action = building.getEntityAction<BuildingProfitAgentAction>();
+        NullReferenceCheckHelper.throwIfNull(building_profit_agent_action, () => $"building_profit_agent_action is null !!!");
+
+        using (building_profit_agent_action.getAsyncLock().Lock())
+        {
+            foreach (var (floor, floor_profit_info) in ntf_modify_building_profit.FloorProfits)
+            {
+                if (!building_profit_agent_action.tryGetBuildingProfit(floor, out var building_profit))
+                {
+                    var currency_type = (CurrencyType)floor_profit_info.Profits.First().Key;
+
+                    (result, building_profit, _) = await BuildingProfitHelper.tryMakeBuildingProfit(building, ntf_modify_building_profit.BuildingMetaId, floor, currency_type, 0);
+                    if (result.isFail())
+                    {
+                        err_msg = $"Failed to tryMakeBuildingProfit() !!! : {result.toBasicString()}";
+                        Log.getLogger().error(err_msg);
+
+                        return result;
+                    }
+                    NullReferenceCheckHelper.throwIfNull(building_profit, () => $"building_profit is null !!!");
+
+                    building_profit_agent_action.addBuildingProfit(floor, building_profit);
+                }
+
+                var building_profit_action = building_profit.getEntityAction<BuildingProfitAction>();
+                NullReferenceCheckHelper.throwIfNull(building_profit_action, () => $"building_profit_action is null !!!");
+
+                foreach (var (currency_type, money) in floor_profit_info.Profits)
+                {
+                    building_profit_action.modifyProfit((CurrencyType)currency_type, money.Amount);
+                }
+            }
+        }
+
+        await Task.CompletedTask;
+
+        return result;
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfModifyFloorLinkedInfosMQPacketHandler.cs

@@ -0,0 +1,53 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("allgameserver", typeof(ServerMessage.Types.GS2GS_NTF_MODIFY_FLOOR_LINKED_INFOS), typeof(NtfModifyFloorLinkedInfosMQPacketHandler), typeof(RabbitMQ4Game))]
+internal class NtfModifyFloorLinkedInfosMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+        var err_msg = string.Empty;
+
+        var server_logic = GameServerApp.getServerLogic();
+        ArgumentNullException.ThrowIfNull(server_logic, $"server_logic is null !!!");
+
+        var message = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(message, $"message is null !!!");
+
+        var ntf_modify_floor_linked_infos = message.NtfModifyFloorLinkedInfos;
+        if (ntf_modify_floor_linked_infos.ExceptServerName == server_logic.getServerName())
+            return result;
+
+        Log.getLogger().info($"MQ - NtfModifyFloorLinkedInfos");
+
+        foreach (var modify_floor_linked_info in ntf_modify_floor_linked_infos.ModifyFloorLinkedInfos)
+        {
+            result = MapManager.Instance.modifyFloorLinkedInfo(modify_floor_linked_info);
+            if (result.isFail())
+            {
+                err_msg = $"Failed to modifyFloorLinkedInfo() !!! : {result.toBasicString()}";
+                Log.getLogger().error(err_msg);
+
+                continue;
+            }
+        }
+
+        var modify_floor_linked_infos = ntf_modify_floor_linked_infos.ModifyFloorLinkedInfos.ToList();
+
+        MapNotifyHelper.broadcast_S2C_NTF_MODIFY_FLOOR_LINKED_INFOS(modify_floor_linked_infos);
+
+        return await Task.FromResult(result);
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfModifyLandInfoMQPacketHandler.cs

@@ -0,0 +1,68 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("allgameserver", typeof(ServerMessage.Types.GS2GS_NTF_MODIFY_LAND_INFO), typeof(NtfModifyLandInfoMQPacketHandler), typeof(RabbitMQ4Game))]
+internal class NtfModifyLandInfoMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+        var err_msg = string.Empty;
+
+        var server_logic = GameServerApp.getServerLogic();
+
+        var message = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(message, $"message is null !!!");
+
+        var ntf_modify_land_info = message.NtfModifyLandInfo;
+        if (ntf_modify_land_info.ExceptServerName == server_logic.getServerName())
+            return result;
+
+        Log.getLogger().info($"MQ - NtfModifyLandInfos");
+
+        var land_infos = ntf_modify_land_info.LandInfos.ToList();
+
+        foreach (var land_info in land_infos)
+        {
+            if (!MapManager.Instance.GetLandMapTree(land_info.LandMetaId, out var land_map_tree))
+            {
+                err_msg = $"Failed to GetLandMapTree() !!! : LandMetaId:{land_info.LandMetaId}";
+                result.setFail(ServerErrorCode.LandMapTreeDataNotFound, err_msg);
+                Log.getLogger().error(result.toBasicString());
+
+                return result;
+            }
+
+            var land_manager = server_logic.getLandManager();
+            if (!land_manager.tryGetLand(land_info.LandMetaId, out var land))
+            {
+                err_msg = $"Failed to tryGetLand() !!! : landMetaId:{land_info.LandMetaId}";
+                result.setFail(ServerErrorCode.LandNotFound, err_msg);
+                Log.getLogger().error(result.toBasicString());
+
+                return result;
+            }
+
+            var land_action = land.getEntityAction<LandAction>();
+            ArgumentNullReferenceCheckHelper.throwIfNull(land_action, () => $"land_action is null !!!");
+
+            // 랜드 정보 수정
+            land_action.modifyLandInfo(land_info);
+        }
+        
+        LandNotifyHelper.broadcast_S2C_NTF_LAND_INFOS(land_infos);
+
+        return await Task.FromResult(result);
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfMyhomeHostEnterEditRoomMQPacketHandler.cs

@@ -0,0 +1,28 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2GS_NTF_MYHOME_HOST_ENTER_EDIT_ROOM), typeof(NtfMyhomeHostEnterEditRoomMQPacketHandler), typeof(RabbitMQ4Game))]
+internal class NtfMyhomeHostEnterEditRoomMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"handleNtfMyhomeHostEnterEditRoom");
+        InstanceRoomManager.Instance.MyhomeHostEnterEditRoom(msg.NtfMyhomeHostEnterEditRoom.RoomId, msg.NtfMyhomeHostEnterEditRoom.ExceptUserGuid);
+
+        return await Task.FromResult(new Result());
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfNoticeChatMQPacketHandler.cs

@@ -0,0 +1,30 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.NoticeChatNoti), typeof(NtfNoticeChatMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfNoticeChatMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        var server_logic = GameServerApp.getServerLogic();
+        ArgumentNullException.ThrowIfNull(server_logic);
+        await server_logic.getNoticeChatManager().LoadDB();
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfOperationSystemNoticeChatSend.cs

@@ -0,0 +1,34 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.MOS2GS_NTF_NOTICE_CHAT), typeof(NtfOperationSystemNoticeChatSend), typeof(RabbitMQ4Game))]
+public class NtfOperationSystemNoticeChatSend : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        await Task.CompletedTask;
+
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        var server_logic = GameServerApp.getServerLogic();
+        var rabbit_notice_chat_handler = new RabbitNoticeChatHandler();
+        rabbit_notice_chat_handler.MOS2GS_noticeChatSend(msg.NtfOperationSystemNoticeChat);
+        //await server_logic.getNoticeChatManager().LoadDB();
+
+        
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfPartyChatMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2C_NTF_PARTY_CHAT), typeof(NtfPartyChatMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfPartyChatMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info("HandlePartyChatNoti");
+
+        var handler = new NotifyPartyChatHandler();
+        await handler.recvPartyChat(msg.NtfPartyChat);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfPartyInfoMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2C_NTF_PARTY_INFO), typeof(NtfPartyInfoMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfPartyInfoMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleSendPartyInfoNoti");
+
+        var handler = new NotifySendPartyInfoHandler();
+        await handler.recvSendPartyInfo(msg.NtfPartyInfo);
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfPartyInstanceInfoMQPacketHandler.cs

@@ -0,0 +1,30 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.PartyInstanceInfoNoti), typeof(NtfPartyInstanceInfoMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfPartyInstanceInfoMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandlePartyInstanceInfoNoti");
+
+        var handler = new NotifyPartyInstanceHandler();
+        await handler.recvPartyInstance(msg.PartyInstanceInfoNoti);
+
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfPartyMemberLocationMQPacketHandler.cs

@@ -0,0 +1,32 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.PartyMemberLocationNoti), typeof(NtfPartyMemberLocationMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfPartyMemberLocationMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+
+        Log.getLogger().info($"HandlePartyMemberLocationNoti");
+
+        var handler = new NotifyPartyMemberLocationHandler();
+        await handler.recvPartyMemberLocationHandler(msg.PartyMemberLocationNoti);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfPartyVoteMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.PartyVoteNoti), typeof(NtfPartyVoteMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfPartyVoteMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandlePartyVoteNoti");
+        var handler = new NotifyStartPartyVoteHandler();
+        await handler.recvStartPartyVote(msg.PartyVoteNoti);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfPartyVoteResultMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.PartyVoteResultNoti), typeof(NtfPartyVoteResultMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfPartyVoteResultMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandlePartyVoteResultNoti");
+
+        var handler = new NotifyPartyVoteResultHandler();
+        await handler.recvPartyVoteResult(msg.PartyVoteResultNoti);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfReceiveInviteMyHomeMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.ReceiveInviteMyHomeNoti), typeof(NtfReceiveInviteMyHomeMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfReceiveInviteMyHomeMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        var handler = new NotifyReceiveInviteMyHomeHandler();
+        handler.send_GS2C_NTF_RECEIVE_INVITE_MYHOME(msg.ReceiveInviteMyHomeNoti);
+
+        return await Task.FromResult(new Result());
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfReceiveMailMQPacketHandler.cs

@@ -0,0 +1,50 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+using GameServer;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.ReceiveMailNoti), typeof(NtfReceiveMailMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfReceiveMailMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        var server_logic = GameServerApp.getServerLogic();
+        var player_manager = server_logic.getPlayerManager();
+        ArgumentNullException.ThrowIfNull(server_logic);
+        ArgumentNullException.ThrowIfNull(player_manager);
+
+        var result = new Result();
+        if (player_manager.tryGetUserByPrimaryKey(msg.ReceiveMailNoti.AccountGuid, out var found_user) == false)
+        { 
+            var err_msg = $"Failed to tryGetUserByPrimaryKey() !!!, Not found : AccountGuid:{msg.ReceiveMailNoti.AccountGuid}";
+            result.setFail(ServerErrorCode.UserNotLogin, err_msg);
+            Log.getLogger().error(result.toBasicString());
+            return result;
+        }
+
+        var mail_action = found_user.getEntityAction<MailAction>();
+        NullReferenceCheckHelper.throwIfNull(mail_action, () => "mail_action is null !!!");
+
+        mail_action.NewReceivedMail();
+
+        await QuestManager.It.QuestCheck(found_user, new QuestMail(EQuestEventTargetType.MAIL, EQuestEventNameType.RECEIVED, ""));
+
+        return result;
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfRentFloorMQPacketHandler.cs

@@ -0,0 +1,74 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("allgameserver", typeof(ServerMessage.Types.GS2GS_NTF_RENT_FLOOR), typeof(NtfRentFloorMQPacketHandler), typeof(RabbitMQ4Game))]
+internal class NtfRentFloorMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var result = new Result();
+        var err_msg = string.Empty;
+
+        var server_logic = GameServerApp.getServerLogic();
+        ArgumentNullException.ThrowIfNull(server_logic, $"server_logic is null !!!");
+
+        var message = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(message, $"message is null !!!");
+
+        var ntf_rent_floor = message.NtfRentFloor;
+        if (ntf_rent_floor.ExceptServerName == server_logic.getServerName())
+            return result;
+
+        Log.getLogger().info($"MQ - NtfRentFloor");
+
+        if (!MapManager.Instance.GetBuildingMapTree(ntf_rent_floor.RentFloorRequestInfo.BuildingId, out var building_map_tree))
+        {
+            err_msg = $"Failed to GetBuildingMapTree() !!! : BuildingMetaId:{ntf_rent_floor.RentFloorRequestInfo.BuildingId}";
+            result.setFail(ServerErrorCode.BuildingMapTreeDataNotFound, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            return result;
+        }
+
+        if (!server_logic.getBuildingManager().tryGetBuilding(ntf_rent_floor.RentFloorRequestInfo.BuildingId, out var building))
+        {
+            err_msg = $"Failed to tryGetBuilding() !!! : buildingMetaId:{ntf_rent_floor.RentFloorRequestInfo.BuildingId}";
+            result.setFail(ServerErrorCode.BuildingNotFound, err_msg);
+            Log.getLogger().error(result.toBasicString());
+
+            return result;
+        }
+
+        var building_floor_agent_action = building.getEntityAction<BuildingFloorAgentAction>();
+        NullReferenceCheckHelper.throwIfNull(building_floor_agent_action, () => $"building_floor_agent_action is null !!!");
+
+        (result, var building_floor, _) = await BuildingFloorHelper.tryMakeBuildingFloor(building, ntf_rent_floor.RentFloorRequestInfo);
+        if (result.isFail())
+        {
+            err_msg = $"Failed to tryMakeBuildingFloor() !!! : {result.toBasicString()}";
+            Log.getLogger().error(err_msg);
+
+            return result;
+        }
+        NullReferenceCheckHelper.throwIfNull(building_floor, () => $"building_floor is null !!!");
+
+        var room_map_tree = MapHelper.makeRoomMapTree(building_map_tree, ntf_rent_floor.InstanceMetaId, ntf_rent_floor.RentFloorRequestInfo, []);
+
+        // Memory
+        MapManager.Instance.addRoomMaptree(building_map_tree, ntf_rent_floor.RentFloorRequestInfo.Floor, room_map_tree);
+        building_floor_agent_action.addBuildingFloor(ntf_rent_floor.RentFloorRequestInfo.Floor, building_floor);
+
+        return result;
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfReplyInviteMyhomeMQPacketHandler.cs

@@ -0,0 +1,30 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.ReplyInviteMyhomeNoti), typeof(NtfReplyInviteMyhomeMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfReplyInviteMyhomeMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        var handler = new NotifyReplyInviteFriendHandler();
+        handler.send_GS2C_NTF_REPLY_INVITE_MYHOME(msg.ReplyInviteMyhomeNoti);
+        return await Task.FromResult(new Result());
+    }
+
+}

GameServer/MessageQueue/PacketHandler/NtfReplyInvitePartyMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.ReplyInvitePartyNoti), typeof(NtfReplyInvitePartyMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfReplyInvitePartyMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleInvitePartyResultNoti");
+
+        var notify_invite_party_reply_handler = new NotifyInvitePartyReplyHandler();
+        await notify_invite_party_reply_handler.recvInvitePartyReply(msg.ReplyInvitePartyNoti);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfReplyPartyVoteMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.ReplyPartyVoteNoti), typeof(NtfReplyPartyVoteMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfReplyPartyVoteMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleReplyPartyVoteNoti");
+
+        var handler = new NotifyReplyPartyVoteHandler();
+        await handler.recvReplyPartyVote(msg.ReplyPartyVoteNoti);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfReplySummonPartyMemberMQPacketHandler.cs

@@ -0,0 +1,31 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.ReplySummonPartyMemberNoti), typeof(NtfReplySummonPartyMemberMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfReplySummonPartyMemberMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleReplySummonPartyMemberNoti");
+        var handler = new NotifyReplySummonPartyMemberHandler();
+        await handler.recvReplySummonPartyMember(msg.ReplySummonPartyMemberNoti);
+
+        return new();
+    }
+
+}

GameServer/MessageQueue/PacketHandler/NtfReturnUserLogoutMQPacketHandler.cs

@@ -0,0 +1,27 @@
+using Google.Protobuf;
+using Nettention.Proud;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+
+
+using GameServer;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2GS_NTF_RETURN_USER_LOGOUT), typeof(NtfReturnUserLogoutMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfReturnUserLogoutMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        await GameServerApp.getServerLogic().getReturnManager().replyReturnUserLogout(msg.NtfReturnUserLogout);
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfStateToFriendMQPacketHandler.cs

@@ -0,0 +1,30 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.StateNotiToFriend), typeof(NtfStateToFriendMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfStateToFriendMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        var handler = new NotifyFriendStateHandler();
+        handler.send_GS2C_NTF_FRIEND_STATE(msg.StateNotiToFriend);
+
+        return await Task.FromResult(new Result());
+    }
+
+}

GameServer/MessageQueue/PacketHandler/NtfSummonPartyMemberMQPacketHandler.cs

@@ -0,0 +1,31 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.SummonPartyMemberNoti), typeof(NtfSummonPartyMemberMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfSummonPartyMemberMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+
+        Log.getLogger().info($"HandleSummonPartyMemberNoti");
+
+        var handler = new NotifySummonPartyMemberHandler();
+        await handler.recvSummonPartyMember(msg.SummonPartyMemberNoti);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfSystemMailMQPacketHandler.cs

@@ -0,0 +1,27 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.SystemMailNoti), typeof(NtfSystemMailMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfSystemMailMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        var server_logic = GameServerApp.getServerLogic();
+        //await server_logic.getSystemMailManager().LoadDB();
+
+        return await Task.FromResult(new Result());
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfUgcNpcRankRefreshMQPacketHandler.cs

@@ -0,0 +1,29 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2GS_NTF_UGC_NPC_RANK_REFRESH), typeof(NtfUgcNpcRankRefreshMQPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfUgcNpcRankRefreshMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"HandleUgcNpcRankRefreshNoti");
+        var handler = new NotifyUgcNpcRankRefreshHandler();
+        await handler.recvUgcNpcRankRefresh(msg.NtfUgcNpcRankRefresh);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/NtfUserKickPacketHandler.cs

@@ -0,0 +1,38 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.MOS2GS_NTF_USER_KICK), typeof(NtfUserKickPacketHandler), typeof(RabbitMQ4Game))]
+public class NtfUserKickPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"NtfUserKickPacketHandler");
+        var user_guid = msg.NtfUserKick.UserGuid;
+        var kick_reason_msg = msg.NtfUserKick.KickReasonMsg;
+        var logout_reason_type = msg.NtfUserKick.LogoutReasonType;
+        
+        var server_logic = GameServerApp.getServerLogic();
+        ArgumentNullException.ThrowIfNull(server_logic);
+        var player_manager = server_logic.getPlayerManager();
+        ArgumentNullException.ThrowIfNull(player_manager);
+        
+        await player_manager.kickUserByUserGuid(user_guid, logout_reason_type, kick_reason_msg);
+        
+        
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/ReqChangeServerConfigMQPacketHandler.cs

@@ -0,0 +1,33 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.ChangeServerConfigReq), typeof(ReqChangeServerConfigMQPacketHandler), typeof(RabbitMQ4Game))]
+public class ReqChangeServerConfigMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        await Task.CompletedTask;
+
+        var msg = recvMessage as ServerMessage;
+        NullReferenceCheckHelper.throwIfNull(msg, () => $"msg is null !!!");
+
+        Log.getLogger().info($"HandleChangeServerConfigReq");
+
+        var server_logic = GameServerApp.getServerLogic();
+        var proud_net_listener = server_logic.getProudNetListener();
+        proud_net_listener.changeMaxConnectionCount(msg.ChangeServerConfigReq.MaxUser);
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/ReqCreateCaliumContentStorageMQPacketHandler.cs

@@ -0,0 +1,39 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.OS2GS_REQ_CREATE_CALIUM_CONTENT_STORAGE), typeof(ReqCreateCaliumContentStorageMQPacketHandler), typeof(RabbitMQ4Game))]
+public class ReqCreateCaliumContentStorageMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var server_logic = GameServerApp.getServerLogic();
+        var rabbitMq = server_logic.getRabbitMqConnector() as RabbitMqConnector;
+        NullReferenceCheckHelper.throwIfNull(rabbitMq, () => "rabbitMq is null !!!");
+        
+        var msg = recvMessage as ServerMessage;
+        ArgumentNullException.ThrowIfNull(msg);
+
+        Log.getLogger().info($"ReqCreateCaliumContentStorageMQPacketHandler");
+        var handler = new ReqCreateCaliumContentStorageHandler();
+        var result = await handler.createCaliumContentStorage(msg.ReqCreateContentStorage.ContentId, msg.ReqCreateContentStorage.Calium);
+
+        var response = new ServerMessage();
+        response.AckCreateContentStorage = new();
+        response.AckCreateContentStorage.Result = result;
+        
+        rabbitMq.SendMessage(msg.ReqCreateContentStorage.RequestServerName, response);
+        
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/ReqKickMQPacketHandler.cs

@@ -0,0 +1,45 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.KickReq), typeof(ReqKickMQPacketHandler), typeof(RabbitMQ4Game))]
+public class ReqKickMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        NullReferenceCheckHelper.throwIfNull(msg, () => $"msg is null !!!");
+
+        ServerMessage message = new ServerMessage();
+        message.KickRes = new ServerMessage.Types.KickRes();
+        message.KickRes.ReqId = msg.KickReq.ReqId;
+
+        var server_logic = GameServerApp.getServerLogic();
+
+        if (await server_logic.getPlayerManager().kickUserByUserGuid(msg.KickReq.Name) == true)
+        {
+            message.KickRes.ErrCode = ServerErrorCode.Success;
+        }
+        else
+        {
+            message.KickRes.ErrCode = ServerErrorCode.KickFail;
+        }
+
+        var owner = session as RabbitMQ4Game;
+        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");
+
+        owner.SendMessage(msg.MessageSender, message);
+
+
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/ReqReservationCancelToServerMQPacketHandler.cs

@@ -0,0 +1,42 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+
+namespace GameServer.PacketHandler;
+
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2GS_REQ_RESERVATION_CANCEL_TO_SERVER), typeof(ReqReservationCancelToServerMQPacketHandler), typeof(RabbitMQ4Game))]
+public class ReqReservationCancelToServerMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        NullReferenceCheckHelper.throwIfNull(msg, () => $"msg is null !!!");
+
+        var message = msg.ReqReservationCancelToServer;
+        NullReferenceCheckHelper.throwIfNull(message, () => $"message is null !!!");
+
+        // 1. cancel 처리
+        await GameServerApp.getServerLogic().getReservationManager().cancelProcess(message);
+
+        // 2. ack 전송
+        var send = new ServerMessage();
+        send.AckReservationCancelToServer = new ServerMessage.Types.GS2GS_ACK_RESERVATION_CANCEL_TO_SERVER();
+        send.AckReservationCancelToServer.RequestUserGuid = message.RequestUserGuid;
+        
+        var rabbit_mq = GameServerApp.getServerLogic().getRabbitMqConnector() as RabbitMqConnector;
+        NullReferenceCheckHelper.throwIfNull(rabbit_mq, () => $"rabbit_mq is null !!!");
+
+        rabbit_mq.SendMessage(message.RequestServerName, send);
+        
+        return new();
+    }
+}

GameServer/MessageQueue/PacketHandler/ReqReservationEnterToServerMQPacketHandler.cs

@@ -0,0 +1,28 @@
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+
+using ServerCore;
+using ServerBase;
+using ServerCommon;
+using ServerCommon.BusinessLogDomain;
+using MetaAssets;
+
+
+namespace GameServer.PacketHandler;
+
+[PacketHandler("", typeof(ServerMessage.Types.GS2GS_REQ_RESERVATION_ENTER_TO_SERVER), typeof(ReqReservationEnterToServerMQPacketHandler), typeof(RabbitMQ4Game))]
+public class ReqReservationEnterToServerMQPacketHandler : PacketRecvHandler
+{
+    public override async Task<Result> onProcessPacket(ISession session, IMessage recvMessage)
+    {
+        var msg = recvMessage as ServerMessage;
+        NullReferenceCheckHelper.throwIfNull(msg, () => $"msg is null !!!");
+
+        await GameServerApp.getServerLogic().getReservationManager().reqProcess(msg.ReqReservationEnterToServer);
+
+        return new();
+    }
+}
+
+