Init enter game

GameServer/Server/Connection.cs

@@ -0,0 +1,189 @@
+using KianaBH.GameServer.Game.Player;
+using KianaBH.GameServer.Server.Packet;
+using KianaBH.KcpSharp;
+using KianaBH.KcpSharp.Base;
+using KianaBH.Proto;
+using KianaBH.Util;
+using KianaBH.Util.Extensions;
+using KianaBH.Util.Security;
+using Google.Protobuf;
+using Google.Protobuf.Reflection;
+using System.Buffers;
+using System.Net;
+using System.Reflection;
+using Newtonsoft.Json.Linq;
+using System.Reflection.PortableExecutable;
+using System.Net.Sockets;
+using System.Reflection.Emit;
+
+namespace KianaBH.GameServer.Server;
+
+public class Connection(KcpConversation conversation, IPEndPoint remote) : KcpConnection(conversation, remote)
+{
+    private static readonly Logger Logger = new("GameServer");
+
+    public PlayerInstance? Player { get; set; }
+
+    private static readonly HashSet<string> DummyPacketNames =
+    [
+        "AddGoodfeelReq", "ArkPlusActivityGetDataReq", "BuffAssistGetActivityReq", "BwWorldCampActivityGetDataReq",
+        "ChatworldBeastGetActivityReq", "ChatworldGetPrayInfoReq", "ClientReportReq", "GetAdventureGroupReq",
+        "GetArmadaDataReq", "GetArmadaStageScoreActivityReq", "GetAskAddFriendListReq", "GetAssistantFrozenListReq",
+        "GetAvatarMissionActivityReq", "GetBattlePassMissionPanelReq", "GetBlackListReq", "GetCardProductInfoReq",
+        "GetChapterActivityDataReq", "GetChapterCompensationInfoReq", "GetChatgroupListReq", "GetClientMailDataReq",
+        "GetConsignedOrderDataReq", "GetCurrencyExchangeInfoReq", "GetExtractReforgeActivityReq",
+        "GetFarmActivityDataReq", "GetFriendListReq", "GetFriendRemarkListReq", "GetGachaDisplayReq",
+        "GetGardenScheduleReq", "GetGobackReq", "GetGratuityActivityReq", "GetMasterPupilCardReq",
+        "GetMasterPupilDataReq", "GetMasterPupilMainDataReq", "GetMosaicActivityReq", "GetNewbieActivityReq",
+        "GetNinjaActivityReq", "GetOfflineResourceDataReq", "GetOpenworldQuestActivityReq",
+        "GetRaffleActivityReq", "GetRankScheduleDataReq", "GetRecommendFriendListReq", "GetRecommendGoodsReq",
+        "GetRoomDataReq", "GetRpgTaleReq", "GetScratchTicketReq", "GetSecurityPasswordReq", "GetShoppingMallListReq",
+        "GetStageChapterReq", "GetSupportActivityReq", "GetSurveyDataReq",
+        "GetTradingCardActivityReq", "GetTvtActivityReq", "GetWeeklyRoutineActivityReq", "GrandKeyActivateSkillReq",
+        "MassiveWarGetActivityReq", "OpenworldGetMechaTeamReq", "OpenworldHuntActivityGetDataReq",
+        "PjmsGetAchievementDataReq", "PjmsGetConditionDataReq", "PjmsGetCurWorldReq", "PjmsGetStoryDataReq",
+        "ReunionCookGetActivityReq", "SimplifiedGodWarGetActivityReq",
+        "StageInnerDataReportReq", "SusannaTrialGetActivityReq", "ThemeWantedRefreshTicketReq",
+        "UpdateMissionProgressReq", "WaveRushGetActivityReq"
+    ];
+
+    public override async void Start()
+    {
+        Logger.Info($"New connection from {RemoteEndPoint}.");
+        State = SessionStateEnum.WAITING_FOR_TOKEN;
+        await ReceiveLoop();
+    }
+
+    public override async void Stop(bool isServerStop = false)
+    {
+        //if (isServerStop) await Player!.SendPacket(new PacketPlayerKickOutScNotify(KickType.KickLoginWhiteTimeout));
+        Player?.OnLogoutAsync();
+        KcpListener.UnregisterConnection(this);
+        base.Stop(isServerStop);
+    }
+
+    protected async Task ReceiveLoop()
+    {
+        while (!CancelToken.IsCancellationRequested)
+        {
+            // WaitToReceiveAsync call completes when there is at least one message is received or the transport is closed.
+            var result = await Conversation.WaitToReceiveAsync(CancelToken.Token);
+            if (result.TransportClosed)
+            {
+                Logger.Debug("Connection was closed");
+                break;
+            }
+
+            var buffer = ArrayPool<byte>.Shared.Rent(result.BytesReceived);
+            try
+            {
+                // TryReceive should not return false here, unless the transport is closed.
+                // So we don't need to check for result.TransportClosed.
+                if (!Conversation.TryReceive(buffer, out result))
+                {
+                    Logger.Error("Failed to receive packet");
+                    break;
+                }
+
+                await ProcessMessageAsync(buffer.AsMemory(0, result.BytesReceived));
+            }
+            catch (Exception ex)
+            {
+                Logger.Error("Packet parse error", ex);
+            }
+            finally
+            {
+                ArrayPool<byte>.Shared.Return(buffer);
+            }
+        }
+
+        Stop();
+    }
+
+    // DO THE PROCESSING OF THE GAME PACKET
+    private async Task ProcessMessageAsync(Memory<byte> data)
+    {
+        var gamePacket = data.ToArray();
+
+        await using MemoryStream ms = new(gamePacket);
+        using BinaryReader br = new(ms);
+
+        // Handle
+        try
+        {
+            while (br.BaseStream.Position < br.BaseStream.Length)
+            {
+                // Length
+                if (br.BaseStream.Length - br.BaseStream.Position < 32) return;
+                // Packet sanity check
+                var headMagic = br.ReadUInt32BE();
+                if (headMagic != 0x01234567)
+                {
+                    Logger.Error($"Bad Data Package Received: got 0x{headMagic:X}, expect 0x01234567");
+                    return; // Bad packet
+                }
+
+                var packetVersion = br.ReadUInt16BE();
+                var ClientVersion = br.ReadUInt16BE();
+                var PacketId = br.ReadUInt32BE();
+                var UserId = br.ReadUInt32BE();
+                var UserIp = br.ReadUInt32BE();
+                var Sign = br.ReadUInt32BE();
+                var SignType = br.ReadUInt16BE();
+                var CmdId = br.ReadUInt16BE();
+                var HeaderLength = br.ReadUInt16BE();
+                var BodyLength = br.ReadUInt32BE();
+
+                // Data
+                var header = br.ReadBytes(HeaderLength);
+                var Body = br.ReadBytes((int)BodyLength);
+                var TailMagic = br.ReadUInt32BE();
+                LogPacket("Recv", CmdId, Body);
+                await HandlePacket(CmdId, header, Body);
+            }
+        }
+        catch (Exception e)
+        {
+            Logger.Error(e.Message, e);
+        }
+    }
+
+    private async Task HandlePacket(ushort opcode, byte[] header, byte[] payload)
+    {
+        var packetName = LogMap.GetValueOrDefault(opcode);
+        if (DummyPacketNames.Contains(packetName!))
+        {
+            await SendDummy(packetName!);
+            Logger.Info($"[Dummy] Send Dummy {packetName}");
+            return;
+        }
+
+        // Find the Handler for this opcode
+        var handler = HandlerManager.GetHandler(opcode);
+        if (handler != null)
+        {
+            // Handle
+            // Make sure session is ready for packets
+            var state = State;
+            try
+            {
+                await handler.OnHandle(this, header, payload);
+            }
+            catch (Exception e)
+            {
+                Logger.Error(e.Message, e);
+            }
+            return;
+        }
+    }
+
+    private async Task SendDummy(string packetName)
+    {
+        var respName = packetName.Replace("Req", "Rsp"); // Get the response packet name
+        if (respName == packetName) return; // do not send rsp when resp name = recv name
+        var respOpcode = LogMap.FirstOrDefault(x => x.Value == respName).Key; // Get the response opcode
+
+        // Send Rsp
+        await SendPacket(respOpcode);
+    }
+}

GameServer/Server/Listener.cs

@@ -0,0 +1,13 @@
+using KianaBH.KcpSharp;
+
+namespace KianaBH.GameServer.Server;
+
+public class Listener : KcpListener
+{
+    public static Connection? GetActiveConnection(int uid)
+    {
+        var con = Connections.Values.FirstOrDefault(c =>
+            (c as Connection)?.Player?.Uid == uid && c.State == SessionStateEnum.ACTIVE) as Connection;
+        return con;
+    }
+}

GameServer/Server/Packet/Handler.cs

@@ -0,0 +1,6 @@
+namespace KianaBH.GameServer.Server.Packet;
+
+public abstract class Handler
+{
+    public abstract Task OnHandle(Connection connection, byte[] header, byte[] data);
+}

GameServer/Server/Packet/HandlerManager.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace KianaBH.GameServer.Server.Packet;
+
+public static class HandlerManager
+{
+    public static Dictionary<int, Handler> handlers = [];
+
+    public static void Init()
+    {
+        var classes = Assembly.GetExecutingAssembly().GetTypes(); // Get all classes in the assembly
+        foreach (var cls in classes)
+        {
+            var attribute = (Opcode?)Attribute.GetCustomAttribute(cls, typeof(Opcode));
+
+            if (attribute != null) handlers.Add(attribute.CmdId, (Handler)Activator.CreateInstance(cls)!);
+        }
+    }
+
+    public static Handler? GetHandler(int cmdId)
+    {
+        try
+        {
+            return handlers[cmdId];
+        }
+        catch
+        {
+            return null;
+        }
+    }
+}

GameServer/Server/Packet/Opcode.cs

@@ -0,0 +1,7 @@
+namespace KianaBH.GameServer.Server.Packet;
+
+[AttributeUsage(AttributeTargets.Class)]
+public class Opcode(int cmdId) : Attribute
+{
+    public int CmdId = cmdId;
+}

GameServer/Server/Packet/Recv/Activity/HandlerArkPlusActivityGetDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.ArkPlusActivityGetDataReq)]
+public class HandlerArkPlusActivityGetDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketArkPlusActivityGetDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerBuffAssistGetActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.BuffAssistGetActivityReq)]
+public class HandlerBuffAssistGetActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketBuffAssistGetActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGeneralActivityGetMainInfoReq.cs

@@ -0,0 +1,14 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GeneralActivityGetMainInfoReq)]
+public class HandlerGeneralActivityGetMainInfoReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = GeneralActivityGetMainInfoReq.Parser.ParseFrom(data);
+        await connection.SendPacket(new PacketGeneralActivityGetMainInfoRsp(req.ActivityIdList));
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGeneralActivityGetScheduleReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GeneralActivityGetScheduleReq)]
+public class HandlerGeneralActivityGetScheduleReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGeneralActivityGetScheduleRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetActivityMainDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetActivityMainDataReq)]
+public class HandlerGetActivityMainDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetActivityMainDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetActivityRewardStatisticDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetActivityRewardStatisticDataReq)]
+public class HandlerGetActivityRewardStatisticDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetActivityRewardStatisticDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetBulletinActivityMissionReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetBulletinActivityMissionReq)]
+public class HandlerGetBulletinActivityMissionReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetBulletinActivityMissionRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetBulletinReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetBulletinReq)]
+public class HandlerGetBulletinReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetBulletinRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetChapterActivityDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetChapterActivityDataReq)]
+public class HandlerGetChapterActivityDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetChapterActivityDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetChapterCompensationInfoReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetChapterCompensationInfoReq)]
+public class HandlerGetChapterCompensationInfoReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetChapterCompensationInfoRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetDropLimitActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetDropLimitActivityReq)]
+public class HandlerGetDropLimitActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetDropLimitActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetExtractReforgeActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetExtractReforgeActivityReq)]
+public class HandlerGetExtractReforgeActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetExtractReforgeActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetFarmActivityDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetFarmActivityDataReq)]
+public class HandlerGetFarmActivityDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetFarmActivityDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetGardenScheduleReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetGardenScheduleReq)]
+public class HandlerGetGardenScheduleReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetGardenScheduleRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetInviteActivityInviteeDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetInviteActivityInviteeDataReq)]
+public class HandlerGetInviteActivityInviteeDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetInviteActivityInviteeDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetInviteActivityInviterDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetInviteActivityInviterDataReq)]
+public class HandlerGetInviteActivityInviterDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetInviteActivityInviterDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetLoginActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetLoginActivityReq)]
+public class HandlerGetLoginActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetLoginActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetMosaicActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetMosaicActivityReq)]
+public class HandlerGetMosaicActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetMosaicActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetNewbieActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetNewbieActivityReq)]
+public class HandlerGetNewbieActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetNewbieActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetNinjaActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetNinjaActivityReq)]
+public class HandlerGetNinjaActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetNinjaActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Activity/HandlerGetThemeWantedReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Activity;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Activity;
+
+[Opcode(CmdIds.GetThemeWantedReq)]
+public class HandlerGetThemeWantedReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetThemeWantedRsp());
+    }
+}

GameServer/Server/Packet/Recv/Adventure/HandlerGetAdventureGroupReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Adventure;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Adventure;
+
+[Opcode(CmdIds.GetAdventureGroupReq)]
+public class HandlerGetAdventureGroupReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetAdventureGroupRsp());
+    }
+}

GameServer/Server/Packet/Recv/Adventure/HandlerGetAdventureStorySweepInfoReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Adventure;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Adventure;
+
+[Opcode(CmdIds.GetAdventureStorySweepInfoReq)]
+public class HandlerGetAdventureStorySweepInfoReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetAdventureStorySweepInfoRsp());
+    }
+}

GameServer/Server/Packet/Recv/Adventure/HandlerGetConsignedOrderDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Adventure;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Adventure;
+
+[Opcode(CmdIds.GetConsignedOrderDataReq)]
+public class HandlerGetConsignedOrderDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetConsignedOrderDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Armada/HandlerGetArmadaActivityListReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Armada;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Armada;
+
+[Opcode(CmdIds.GetArmadaActivityListReq)]
+public class HandlerGetArmadaActivityListReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetArmadaActivityListRsp());
+    }
+}

GameServer/Server/Packet/Recv/Armada/HandlerGetArmadaDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Armada;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Armada;
+
+[Opcode(CmdIds.GetArmadaDataReq)]
+public class HandlerGetArmadaDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetArmadaDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Armada/HandlerGetArmadaStageScoreActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Armada;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Armada;
+
+[Opcode(CmdIds.GetArmadaStageScoreActivityReq)]
+public class HandlerGetArmadaStageScoreActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetArmadaStageScoreActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Auth/HandlerGetAuthkeyReq.cs

@@ -0,0 +1,14 @@
+using KianaBH.GameServer.Server.Packet.Send.Auth;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Auth;
+
+[Opcode(CmdIds.GetAuthkeyReq)]
+public class HandlerGetAuthkeyReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = GetAuthkeyReq.Parser.ParseFrom(data);
+        await connection.SendPacket(new PacketGetAuthkeyRsp(req.AuthAppid));
+    }
+}

GameServer/Server/Packet/Recv/Avatar/HandlerAddCustomAvatarTeamReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Avatar;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Avatar;
+
+[Opcode(CmdIds.AddCustomAvatarTeamReq)]
+public class HandlerAddCustomAvatarTeamReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketAddCustomAvatarTeamRsp());
+    }
+}

GameServer/Server/Packet/Recv/Avatar/HandlerAvatarSubSkillLevelUpReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Avatar;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Avatar;
+
+[Opcode(CmdIds.AvatarSubSkillLevelUpReq)]
+public class HandlerAvatarSubSkillLevelUpReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketAvatarSubSkillLevelUpRsp());
+    }
+}

GameServer/Server/Packet/Recv/Avatar/HandlerDelCustomAvatarTeamReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Avatar;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Avatar;
+
+[Opcode(CmdIds.DelCustomAvatarTeamReq)]
+public class HandlerDelCustomAvatarTeamReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketDelCustomAvatarTeamRsp());
+    }
+}

GameServer/Server/Packet/Recv/Avatar/HandlerDressEquipmentReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Avatar;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Avatar;
+
+[Opcode(CmdIds.DressEquipmentReq)]
+public class HandlerDressEquipmentReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketDressEquipmentRsp());
+    }
+}

GameServer/Server/Packet/Recv/Avatar/HandlerGetAvatarDataReq.cs

@@ -0,0 +1,25 @@
+using KianaBH.Database.Avatar;
+using KianaBH.GameServer.Game.Player;
+using KianaBH.GameServer.Server.Packet.Send.Avatar;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Avatar;
+
+[Opcode(CmdIds.GetAvatarDataReq)]
+public class HandlerGetAvatarDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = GetAvatarDataReq.Parser.ParseFrom(data);
+        var player = connection.Player!;
+        var avatars = req.AvatarIdList.Any(id => id != 0)
+            ? req.AvatarIdList
+                .Select(id => player.AvatarManager!.GetAvatar(id))
+                .Where(avatar => avatar != null)
+                .ToList()!
+            : player.AvatarManager?.AvatarData?.Avatars?.ToList();
+
+        bool isAll = !req.AvatarIdList.Any(id => id != 0);
+        await connection.SendPacket(new PacketGetAvatarDataRsp(avatars!, isAll));
+    }
+}

GameServer/Server/Packet/Recv/Avatar/HandlerGetAvatarMissionActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Avatar;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Avatar;
+
+[Opcode(CmdIds.GetAvatarMissionActivityReq)]
+public class HandlerGetAvatarMissionActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetAvatarMissionActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Avatar/HandlerGetAvatarRollDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Avatar;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Avatar;
+
+[Opcode(CmdIds.GetAvatarRollDataReq)]
+public class HandlerGetAvatarRollDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetAvatarRollDataRsp(connection.Player!));
+    }
+}

GameServer/Server/Packet/Recv/Avatar/HandlerGetAvatarTeamDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Avatar;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Avatar;
+
+[Opcode(CmdIds.GetAvatarTeamDataReq)]
+public class HandlerGetAvatarTeamDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetAvatarTeamDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Avatar/HandlerUpdateCustomAvatarTeamReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Avatar;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Avatar;
+
+[Opcode(CmdIds.UpdateCustomAvatarTeamReq)]
+public class HandlerUpdateCustomAvatarTeamReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketUpdateCustomAvatarTeamRsp());
+    }
+}

GameServer/Server/Packet/Recv/Battle/HandlerGetBuffEffectReq.cs

@@ -0,0 +1,14 @@
+using KianaBH.GameServer.Server.Packet.Send.Battle;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Battle;
+
+[Opcode(CmdIds.GetBuffEffectReq)]
+public class HandlerGetBuffEffectReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = GetBuffEffectReq.Parser.ParseFrom(data);
+        await connection.SendPacket(new PacketGetBuffEffectRsp(req.EffectIdList));
+    }
+}

GameServer/Server/Packet/Recv/BattlePass/HandlerGetBattlePassMissionPanelReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.BattlePass;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.BattlePass;
+
+[Opcode(CmdIds.GetBattlePassMissionPanelReq)]
+public class HandlerGetBattlePassMissionPanelReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetBattlePassMissionPanelRsp());
+    }
+}

GameServer/Server/Packet/Recv/Challenge/HandlerGetChallengeStepCompensationInfoReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Challenge;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Challenge;
+
+[Opcode(CmdIds.GetChallengeStepCompensationInfoReq)]
+public class HandlerGetChallengeStepCompensationInfoReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetChallengeStepCompensationInfoRsp());
+    }
+}

GameServer/Server/Packet/Recv/Chapter/HandlerChapterArkGetDataReq.cs

@@ -0,0 +1,14 @@
+using KianaBH.GameServer.Server.Packet.Send.Chapter;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Chapter;
+
+[Opcode(CmdIds.ChapterArkGetDataReq)]
+public class HandlerChapterArkGetDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = ChapterArkGetDataReq.Parser.ParseFrom(data);
+        await connection.SendPacket(new PacketChapterArkGetDataRsp(req.ChapterId));
+    }
+}

GameServer/Server/Packet/Recv/Chapter/HandlerChapterBwWorldGetDataReq.cs

@@ -0,0 +1,14 @@
+using KianaBH.GameServer.Server.Packet.Send.Chapter;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Chapter;
+
+[Opcode(CmdIds.ChapterBwWorldGetDataReq)]
+public class HandlerChapterBwWorldGetDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = ChapterBwWorldGetDataReq.Parser.ParseFrom(data);
+        await connection.SendPacket(new PacketChapterBwWorldGetDataRsp(req.ChapterId));
+    }
+}

GameServer/Server/Packet/Recv/Chapter/HandlerChapterGroupGetDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Chapter;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Chapter;
+
+[Opcode(CmdIds.ChapterGroupGetDataReq)]
+public class HandlerChapterGroupGetDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketChapterGroupGetDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Chapter/HandlerChapterKnightRichManGetDataReq.cs

@@ -0,0 +1,14 @@
+using KianaBH.GameServer.Server.Packet.Send.Chapter;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Chapter;
+
+[Opcode(CmdIds.ChapterKnightRichManGetDataReq)]
+public class HandlerChapterKnightRichManGetDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = ChapterKnightRichManGetDataReq.Parser.ParseFrom(data);
+        await connection.SendPacket(new PacketChapterKnightRichManGetDataRsp(req.RichManId));
+    }
+}

GameServer/Server/Packet/Recv/Chapter/HandlerGetEliteChapterCompensationInfoReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Chapter;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Chapter;
+
+[Opcode(CmdIds.GetEliteChapterCompensationInfoReq)]
+public class HandlerGetEliteChapterCompensationInfoReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetEliteChapterCompensationInfoRsp());
+    }
+}

GameServer/Server/Packet/Recv/Chat/HandlerChatworldBeastGetActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Chat;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Chat;
+
+[Opcode(CmdIds.ChatworldBeastGetActivityReq)]
+public class HandlerChatworldBeastGetActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketChatworldBeastGetActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Chat/HandlerChatworldGetActivityScheduleReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Chat;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Chat;
+
+[Opcode(CmdIds.ChatworldGetActivityScheduleReq)]
+public class HandlerChatworldGetActivityScheduleReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketChatworldGetActivityScheduleRsp());
+    }
+}

GameServer/Server/Packet/Recv/Chat/HandlerChatworldGetPrayInfoReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Chat;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Chat;
+
+[Opcode(CmdIds.ChatworldGetPrayInfoReq)]
+public class HandlerChatworldGetPrayInfoReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketChatworldGetPrayInfoRsp());
+    }
+}

GameServer/Server/Packet/Recv/Chat/HandlerEnterWorldChatroomReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Chat;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Chat;
+
+[Opcode(CmdIds.EnterWorldChatroomReq)]
+public class HandlerEnterWorldChatroomReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketEnterWorldChatroomRsp());
+    }
+}

GameServer/Server/Packet/Recv/Chat/HandlerGetChatgroupListReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Chat;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Chat;
+
+[Opcode(CmdIds.GetChatgroupListReq)]
+public class HandlerGetChatgroupListReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetChatgroupListRsp());
+    }
+}

GameServer/Server/Packet/Recv/Client/HandlerClientReportReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Client;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Client;
+
+[Opcode(CmdIds.ClientReportReq)]
+public class HandlerClientReportReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketClientReportRsp());
+    }
+}

GameServer/Server/Packet/Recv/Client/HandlerGetClientDataReq.cs

@@ -0,0 +1,15 @@
+using KianaBH.GameServer.Server.Packet.Send.Client;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Client;
+
+[Opcode(CmdIds.GetClientDataReq)]
+public class HandlerGetClientDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = GetClientDataReq.Parser.ParseFrom(data);
+
+        await connection.SendPacket(new PacketGetClientDataRsp(req.Id,req.Type, connection.Player!));
+    }
+}

GameServer/Server/Packet/Recv/Client/HandlerGetClientMailDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Client;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Client;
+
+[Opcode(CmdIds.GetClientMailDataReq)]
+public class HandlerGetClientMailDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetClientMailDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Client/HandlerGetClientSettingReq.cs

@@ -0,0 +1,14 @@
+using KianaBH.GameServer.Server.Packet.Send.Client;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Client;
+
+[Opcode(CmdIds.GetClientSettingReq)]
+public class HandlerGetClientSettingReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = GetClientSettingReq.Parser.ParseFrom(data);
+        await connection.SendPacket(new PacketGetClientSettingRsp(req.ClientSettingType));
+    }
+}

GameServer/Server/Packet/Recv/Client/HandlerKeepAliveNotify.cs

@@ -0,0 +1,13 @@
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Client;
+
+[Opcode(CmdIds.KeepAliveNotify)]
+public class HandlerKeepAliveNotify : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.Player!.OnHeartBeat();
+        await connection.SendPacket(CmdIds.KeepAliveNotify);
+    }
+}

GameServer/Server/Packet/Recv/Client/HandlerReportClientDataVersionReq.cs

@@ -0,0 +1,14 @@
+using KianaBH.GameServer.Server.Packet.Send.Client;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Client;
+
+[Opcode(CmdIds.ReportClientDataVersionReq)]
+public class HandlerReportClientDataVersionReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = ReportClientDataVersionReq.Parser.ParseFrom(data);
+        await connection.SendPacket(new PacketReportClientDataVersionRsp(req.Version));
+    }
+}

GameServer/Server/Packet/Recv/Client/HandlerSetClientDataReq.cs

@@ -0,0 +1,27 @@
+using KianaBH.GameServer.Game.Player;
+using KianaBH.GameServer.Server.Packet.Send.Client;
+using KianaBH.Proto;
+using KianaBH.Database.Client;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Client;
+
+[Opcode(CmdIds.SetClientDataReq)]
+public class HandlerSetClientDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = SetClientDataReq.Parser.ParseFrom(data);
+        PlayerInstance player = connection.Player!;
+        var clientData = player.ClientData!.Clients.FirstOrDefault(c => c.Id == req.ClientData.Id && c.Type == req.ClientData.Type);
+        if (clientData == null)
+        {
+            player.ClientData.Clients.Add(new ClientDBData
+            {
+                Id = req.ClientData.Id,
+                Type = req.ClientData.Type,
+                Data = req.ClientData.Data.ToByteArray(),
+            });
+        }
+        await connection.SendPacket(new PacketSetClientDataRsp(req.ClientData.Id,req.ClientData.Type));
+    }
+}

GameServer/Server/Packet/Recv/Collection/HandlerGetCollectionListReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Collection;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Collection;
+
+[Opcode(CmdIds.GetCollectionListReq)]
+public class HandlerGetCollectionListReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetCollectionListRsp());
+    }
+}

GameServer/Server/Packet/Recv/DLC/HandlerGetDLCAvatarReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.DLC;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.DLC;
+
+[Opcode(CmdIds.GetDLCAvatarReq)]
+public class HandlerGetDLCAvatarReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetDLCAvatarRsp());
+    }
+}

GameServer/Server/Packet/Recv/DLC/HandlerGetDLCReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.DLC;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.DLC;
+
+[Opcode(CmdIds.GetDLCReq)]
+public class HandlerGetDLCReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetDLCRsp());
+    }
+}

GameServer/Server/Packet/Recv/DLC/HandlerGetDLCTowerReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.DLC;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.DLC;
+
+[Opcode(CmdIds.GetDLCTowerReq)]
+public class HandlerGetDLCTowerReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetDLCTowerRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dorm/HandlerGetDormDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dorm;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dorm;
+
+[Opcode(CmdIds.GetDormDataReq)]
+public class HandlerGetDormDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetDormDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetPlotListReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetPlotListReq)]
+public class HandlerGetPlotListReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetPlotListRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetPrivilegeInfoReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetPrivilegeInfoReq)]
+public class HandlerGetPrivilegeInfoReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetPrivilegeInfoRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetProductListReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetProductListReq)]
+public class HandlerGetProductListReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetProductListRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetProductRecommendListReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetProductRecommendListReq)]
+public class HandlerGetProductRecommendListReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetProductRecommendListRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetRaffleActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetRaffleActivityReq)]
+public class HandlerGetRaffleActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetRaffleActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetRankScheduleDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetRankScheduleDataReq)]
+public class HandlerGetRankScheduleDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetRankScheduleDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetRecommendFriendListReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetRecommendFriendListReq)]
+public class HandlerGetRecommendFriendListReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetRecommendFriendListRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetRecommendGoodsReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetRecommendGoodsReq)]
+public class HandlerGetRecommendGoodsReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetRecommendGoodsRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetRewardLineActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetRewardLineActivityReq)]
+public class HandlerGetRewardLineActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetRewardLineActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetRoomDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetRoomDataReq)]
+public class HandlerGetRoomDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetRoomDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetRpgTaleReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetRpgTaleReq)]
+public class HandlerGetRpgTaleReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetRpgTaleRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetScratchTicketReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetScratchTicketReq)]
+public class HandlerGetScratchTicketReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetScratchTicketRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetSecurityPasswordReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetSecurityPasswordReq)]
+public class HandlerGetSecurityPasswordReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetSecurityPasswordRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetShopListReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetShopListReq)]
+public class HandlerGetShopListReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetShopListRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetShoppingMallListReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetShoppingMallListReq)]
+public class HandlerGetShoppingMallListReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetShoppingMallListRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetSupportActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetSupportActivityReq)]
+public class HandlerGetSupportActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetSupportActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetSurveyDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetSurveyDataReq)]
+public class HandlerGetSurveyDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetSurveyDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetTowerRaidActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetTowerRaidActivityReq)]
+public class HandlerGetTowerRaidActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetTowerRaidActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetTradingCardActivityReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetTradingCardActivityReq)]
+public class HandlerGetTradingCardActivityReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetTradingCardActivityRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetTrialAvatarReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetTrialAvatarReq)]
+public class HandlerGetTrialAvatarReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetTrialAvatarRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetVipRewardDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetVipRewardDataReq)]
+public class HandlerGetVipRewardDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetVipRewardDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Dummy/HandlerGetVirtualAvatarGroupDetailReq.cs

@@ -0,0 +1,14 @@
+using KianaBH.GameServer.Server.Packet.Send.Dummy;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Dummy;
+
+[Opcode(CmdIds.GetVirtualAvatarGroupDetailReq)]
+public class HandlerGetVirtualAvatarGroupDetailReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = GetVirtualAvatarGroupDetailReq.Parser.ParseFrom(data);
+        await connection.SendPacket(new PacketGetVirtualAvatarGroupDetailRsp(req.GroupId));
+    }
+}

GameServer/Server/Packet/Recv/Elf/HandlerGetElfDataReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Elf;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Elf;
+
+[Opcode(CmdIds.GetElfDataReq)]
+public class HandlerGetElfDataReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetElfDataRsp());
+    }
+}

GameServer/Server/Packet/Recv/Endless/HandlerGetEndlessStatusReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Endless;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Endless;
+
+[Opcode(CmdIds.GetEndlessStatusReq)]
+public class HandlerGetEndlessStatusReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetEndlessStatusRsp());
+    }
+}

GameServer/Server/Packet/Recv/Event/HandlerGetGalInteractTriggerEventReq.cs

@@ -0,0 +1,14 @@
+using KianaBH.GameServer.Server.Packet.Send.Event;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Event;
+
+[Opcode(CmdIds.GetGalInteractTriggerEventReq)]
+public class HandlerGetGalInteractTriggerEventReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = GetGalInteractTriggerEventReq.Parser.ParseFrom(data);
+        await connection.SendPacket(new PacketGetGalInteractTriggerEventRsp(req.AvatarId));
+    }
+}

GameServer/Server/Packet/Recv/ExBoss/HandlerExBossStageBeginReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.ExBoss;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.ExBoss;
+
+[Opcode(CmdIds.ExBossStageBeginReq)]
+public class HandlerExBossStageBeginReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketExBossStageBeginRsp());
+    }
+}

GameServer/Server/Packet/Recv/ExBoss/HandlerExBossStageEndReq.cs

@@ -0,0 +1,14 @@
+using KianaBH.GameServer.Server.Packet.Send.ExBoss;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.ExBoss;
+
+[Opcode(CmdIds.ExBossStageEndReq)]
+public class HandlerExBossStageEndReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        var req = ExBossStageEndReq.Parser.ParseFrom(data);
+        await connection.SendPacket(new PacketExBossStageEndRsp(req.BossId,req.EndStatus));
+    }
+}

GameServer/Server/Packet/Recv/ExBoss/HandlerGetExBossInfoReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.ExBoss;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.ExBoss;
+
+[Opcode(CmdIds.GetExBossInfoReq)]
+public class HandlerGetExBossInfoReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetExBossInfoRsp());
+    }
+}

GameServer/Server/Packet/Recv/ExBoss/HandlerGetExBossRankReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.ExBoss;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.ExBoss;
+
+[Opcode(CmdIds.GetExBossRankReq)]
+public class HandlerGetExBossRankReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetExBossRankRsp(connection.Player!));
+    }
+}

GameServer/Server/Packet/Recv/ExBoss/HandlerGetExBossScheduleReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.ExBoss;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.ExBoss;
+
+[Opcode(CmdIds.GetExBossScheduleReq)]
+public class HandlerGetExBossScheduleReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetExBossScheduleRsp());
+    }
+}

GameServer/Server/Packet/Recv/Exchange/HandlerGetCurrencyExchangeInfoReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Exchange;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Exchange;
+
+[Opcode(CmdIds.GetCurrencyExchangeInfoReq)]
+public class HandlerGetCurrencyExchangeInfoReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetCurrencyExchangeInfoRsp());
+    }
+}

GameServer/Server/Packet/Recv/Friend/HandlerGetAskAddFriendListReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Friend;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Friend;
+
+[Opcode(CmdIds.GetAskAddFriendListReq)]
+public class HandlerGetAskAddFriendListReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetAskAddFriendListRsp());
+    }
+}

GameServer/Server/Packet/Recv/Friend/HandlerGetFriendListReq.cs

@@ -0,0 +1,13 @@
+using KianaBH.GameServer.Server.Packet.Send.Friend;
+using KianaBH.Proto;
+
+namespace KianaBH.GameServer.Server.Packet.Recv.Friend;
+
+[Opcode(CmdIds.GetFriendListReq)]
+public class HandlerGetFriendListReq : Handler
+{
+    public override async Task OnHandle(Connection connection, byte[] header, byte[] data)
+    {
+        await connection.SendPacket(new PacketGetFriendListRsp());
+    }
+}