handlers folder re-strucutring

GameServer/Handlers/One/AddAvatarExpByMaterialReqHandler.cs

@@ -0,0 +1,41 @@
+using Common.Database;
+using Common.Resources.Proto;
+using Common.Utils.ExcelReader;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.AddAvatarExpByMaterialReq)]
+    internal class AddAvatarExpByMaterialReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            AddAvatarExpByMaterialReq Data = packet.GetDecodedBody<AddAvatarExpByMaterialReq>();
+            MaterialDataExcel? materialData = MaterialData.GetInstance().FromId(Data.MaterialId);
+            AvatarScheme? avatar = session.Player.AvatarList.FirstOrDefault(avatar => avatar.AvatarId == Data.AvatarId);
+
+            AddAvatarExpByMaterialRsp Rsp = new() { retcode = AddAvatarExpByMaterialRsp.Retcode.Succ };
+
+            if (avatar is not null && materialData is not null)
+            {
+                session.Player.Equipment.AddMaterial(materialData.Id, -(int)Data.MaterialNum);
+                GetEquipmentDataRsp EquipmentRsp = new()
+                {
+                    retcode = GetEquipmentDataRsp.Retcode.Succ,
+                    VitalityValue = 0,
+                    IsAll = true
+                };
+                EquipmentRsp.MaterialLists.Add(session.Player.Equipment.MaterialList.First(mat => mat.Id == materialData.Id));
+
+                avatar.AddExp((uint)materialData.CharacterExpProvide * Data.MaterialNum);
+
+                session.Send(Packet.FromProto(EquipmentRsp, CmdId.GetEquipmentDataRsp));
+                session.ProcessPacket(Packet.FromProto(new GetAvatarDataReq() { AvatarIdLists = new uint[] { avatar.AvatarId } }, CmdId.GetAvatarDataReq));
+            }
+            else
+            {
+                Rsp.retcode = AddAvatarExpByMaterialRsp.Retcode.AvatarNotExist;
+            }
+            session.Send(Packet.FromProto(Rsp, CmdId.AddAvatarExpByMaterialRsp));
+        }
+    }
+}

GameServer/Handlers/One/AddGoodfeelReqHandler.cs

@@ -0,0 +1,24 @@
+using Common.Database;
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.AddGoodfeelReq)]
+    internal class AddGoodfeelReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            AddGoodfeelReq Data = packet.GetDecodedBody<AddGoodfeelReq>();
+            AvatarScheme? avatar = session.Player.AvatarList.Where(avatar => avatar.AvatarId == Data.AvatarId).FirstOrDefault();
+
+            if(avatar != null)
+            {
+                avatar.TodayHasAddGoodfeel += (uint)Data.AddGoodfeel;
+                avatar.TouchGoodfeel += (uint)Data.AddGoodfeel;
+
+                session.ProcessPacket(Packet.FromProto(new GetAvatarDataReq() { AvatarIdLists = new uint[] { avatar.AvatarId } }, CmdId.GetAvatarDataReq));
+            }
+            session.Send(Packet.FromProto(new AddGoodfeelRsp() { retcode = AddGoodfeelRsp.Retcode.Succ }, CmdId.AddGoodfeelRsp));
+        }
+    }
+}

GameServer/Handlers/One/AvatarStarUpReqHandler.cs

@@ -0,0 +1,29 @@
+using Common.Database;
+using Common.Resources.Proto;
+using Common.Utils.ExcelReader;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.AvatarStarUpReq)]
+    internal class AvatarStarUpReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            AvatarStarUpReq Data = packet.GetDecodedBody<AvatarStarUpReq>();
+            AvatarStarUpRsp Rsp = new() { retcode = AvatarStarUpRsp.Retcode.Succ };
+            AvatarScheme? avatar = session.Player.AvatarList.FirstOrDefault(x => x.AvatarId == Data.AvatarId);
+
+            if (avatar is not null)
+            {
+                avatar.StarUp();
+                session.ProcessPacket(Packet.FromProto(new GetAvatarDataReq() { AvatarIdLists = new uint[] { avatar.AvatarId } }, CmdId.GetAvatarDataReq));
+            }
+            else
+            {
+                Rsp.retcode = AvatarStarUpRsp.Retcode.AvatarNotExist;
+            }
+
+            session.Send(Packet.FromProto(Rsp, CmdId.AvatarStarUpRsp));
+        }
+    }
+}

GameServer/Handlers/One/AvatarSubSkillLevelUpReqHandler.cs

@@ -0,0 +1,28 @@
+using Common.Database;
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.AvatarSubSkillLevelUpReq)]
+    internal class AvatarSubSkillLevelUpReqHandler : IPacketHandler
+    {
+        // TODO: Find out how to calculate cost with itemType 0
+        public void Handle(Session session, Packet packet)
+        {
+            AvatarSubSkillLevelUpReq Data = packet.GetDecodedBody<AvatarSubSkillLevelUpReq>();
+            AvatarScheme? avatar = session.Player.AvatarList.FirstOrDefault(avatar => avatar.AvatarId == Data.AvatarId);
+            AvatarSubSkillLevelUpRsp Rsp = new() { retcode = AvatarSubSkillLevelUpRsp.Retcode.Succ };
+
+            if (avatar is not null)
+            {
+                avatar.LevelUpSkill(Data.SubSkillId, Data.IsLevelUpAll);
+                session.ProcessPacket(Packet.FromProto(new GetAvatarDataReq() { AvatarIdLists = new uint[] { avatar.AvatarId } }, CmdId.GetAvatarDataReq));
+            }
+            else
+            {
+                Rsp.retcode = AvatarSubSkillLevelUpRsp.Retcode.AvatarNotExist;
+            }
+            session.Send(Packet.FromProto(Rsp, CmdId.AvatarSubSkillLevelUpRsp));
+        }
+    }
+}

GameServer/Handlers/One/DressEquipmentReqHandler.cs

@@ -0,0 +1,45 @@
+using Common.Database;
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.DressEquipmentReq)]
+    internal class DressEquipmentReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            DressEquipmentReq Data = packet.GetDecodedBody<DressEquipmentReq>();
+            DressEquipmentRsp Rsp = new() { retcode = DressEquipmentRsp.Retcode.Succ };
+
+            AvatarScheme? avatar = session.Player.AvatarList.FirstOrDefault(avatar => avatar.AvatarId == Data.AvatarId);
+            if (avatar == null) 
+            {
+                Rsp.retcode = DressEquipmentRsp.Retcode.AvatarNotExist;
+            }
+            else
+            {
+                switch (Data.Slot)
+                {
+                    case EquipmentSlot.EquipmentSlotWeapon1:
+                        avatar.WeaponUniqueId = Data.UniqueId;
+                        break;
+                    case EquipmentSlot.EquipmentSlotStigmata1:
+                        avatar.StigmataUniqueId1 = Data.UniqueId;
+                        break;
+                    case EquipmentSlot.EquipmentSlotStigmata2:
+                        avatar.StigmataUniqueId2 = Data.UniqueId;
+                        break;
+                    case EquipmentSlot.EquipmentSlotStigmata3:
+                        avatar.StigmataUniqueId3 = Data.UniqueId;
+                        break;
+                    default:
+                        Rsp.retcode = DressEquipmentRsp.Retcode.EquipmentSlotError;
+                        break;
+                }
+                session.ProcessPacket(Packet.FromProto(new GetAvatarDataReq() { AvatarIdLists = new uint[] { avatar.AvatarId } }, CmdId.GetAvatarDataReq));
+            }
+
+            session.Send(Packet.FromProto(Rsp, CmdId.DressEquipmentRsp));
+        }
+    }
+}

GameServer/Handlers/One/EquipmentPowerUpReqHandler.cs

@@ -0,0 +1,35 @@
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.EquipmentPowerUpReq)]
+    internal class EquipmentPowerUpReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            EquipmentPowerUpReq Data = packet.GetDecodedBody<EquipmentPowerUpReq>();
+            EquipmentPowerUpRsp Rsp = new() { retcode = EquipmentPowerUpRsp.Retcode.Succ, MainItem = Data.MainItem, BoostRate = 100 };
+
+            GetEquipmentDataRsp EquipmentDataRsp = new() { retcode = GetEquipmentDataRsp.Retcode.Succ, VitalityValue = 5900 };
+            switch (Data.MainItem.Type)
+            {
+                case EquipmentType.EquipmentWeapon:
+                    Material[] WeaponUpConsumeItems = session.Player.Equipment.AddWeaponExpByConsumeItem(Data.MainItem.IdOrUniqueId, Data.ConsumeItemList.ItemLists);
+
+                    EquipmentDataRsp.MaterialLists.AddRange(WeaponUpConsumeItems);
+                    EquipmentDataRsp.WeaponLists.Add(session.Player.Equipment.WeaponList.FirstOrDefault(weapon => weapon.UniqueId == Data.MainItem.IdOrUniqueId));
+                    break;
+                case EquipmentType.EquipmentStigmata:
+                    Material[] StigmataUpConsumeItems = session.Player.Equipment.AddStigmataExpByConsumeItem(Data.MainItem.IdOrUniqueId, Data.ConsumeItemList.ItemLists);
+
+                    EquipmentDataRsp.MaterialLists.AddRange(StigmataUpConsumeItems);
+                    EquipmentDataRsp.StigmataLists.Add(session.Player.Equipment.StigmataList.FirstOrDefault(stigmata => stigmata.UniqueId == Data.MainItem.IdOrUniqueId));
+                    break;
+                default:
+                    Rsp.retcode = EquipmentPowerUpRsp.Retcode.MainItemNotExist;
+                    break;
+            }
+            session.Send(Packet.FromProto(EquipmentDataRsp, CmdId.GetEquipmentDataRsp), Packet.FromProto(Rsp, CmdId.EquipmentPowerUpRsp));
+        }
+    }
+}

GameServer/Handlers/One/GetAvatarDataReqHandler.cs

@@ -0,0 +1,96 @@
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.GetAvatarDataReq)]
+    internal class GetAvatarDataReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            GetAvatarDataReq Packet = packet.GetDecodedBody<GetAvatarDataReq>();
+
+            GetAvatarDataRsp Rsp = new()
+            {
+                retcode = GetAvatarDataRsp.Retcode.Succ
+            };
+
+            if (Packet.AvatarIdLists.Contains((uint)0))
+            {
+                IEnumerable<Avatar> Avatars = session.Player.AvatarList.Select(avatar =>
+                {
+                    Avatar a = new()
+                    {
+                        AvatarId = avatar.AvatarId,
+                        AvatarArtifact = avatar.AvatarArtifact,
+                        DressId = avatar.DressId,
+                        DressLists = avatar.DressLists,
+                        Level = avatar.Level,
+                        Exp = avatar.Exp,
+                        Fragment = avatar.Fragment,
+                        Mode = avatar.Mode,
+                        StageGoodfeel = avatar.StageGoodfeel,
+                        Star = avatar.Star,
+                        StigmataUniqueId1 = avatar.StigmataUniqueId1,
+                        StigmataUniqueId2 = avatar.StigmataUniqueId2,
+                        StigmataUniqueId3 = avatar.StigmataUniqueId3,
+                        SubStar = avatar.SubStar,
+                        TodayHasAddGoodfeel = avatar.TodayHasAddGoodfeel,
+                        TouchGoodfeel = avatar.TouchGoodfeel,
+                        WeaponUniqueId = avatar.WeaponUniqueId
+                    };
+                    a.SkillLists.AddRange(avatar.SkillLists.Select(skill =>
+                    {
+                        AvatarSkill avatarSkill = new() { SkillId = skill.SkillId };
+                        avatarSkill.SubSkillLists.AddRange(skill.SubSkillLists);
+                        return avatarSkill;
+                    }));
+
+                    return a;
+                });
+
+                Rsp.IsAll = true;
+                Rsp.AvatarLists.AddRange(Avatars);
+            }
+            else
+            {
+                IEnumerable<Avatar> Avatars = session.Player.AvatarList.Where(avatar => Packet.AvatarIdLists.Contains(avatar.AvatarId)).Select(avatar =>
+                {
+                    Avatar a = new()
+                    {
+                        AvatarId = avatar.AvatarId,
+                        AvatarArtifact = avatar.AvatarArtifact,
+                        DressId = avatar.DressId,
+                        DressLists = avatar.DressLists,
+                        Level = avatar.Level,
+                        Exp = avatar.Exp,
+                        Fragment = avatar.Fragment,
+                        Mode = avatar.Mode,
+                        StageGoodfeel = avatar.StageGoodfeel,
+                        Star = avatar.Star,
+                        StigmataUniqueId1 = avatar.StigmataUniqueId1,
+                        StigmataUniqueId2 = avatar.StigmataUniqueId2,
+                        StigmataUniqueId3 = avatar.StigmataUniqueId3,
+                        SubStar = avatar.SubStar,
+                        TodayHasAddGoodfeel = avatar.TodayHasAddGoodfeel,
+                        TouchGoodfeel = avatar.TouchGoodfeel,
+                        WeaponUniqueId = avatar.WeaponUniqueId
+                    };
+                    a.SkillLists.AddRange(avatar.SkillLists.Select(skill =>
+                    {
+                        AvatarSkill avatarSkill = new() { SkillId = skill.SkillId };
+                        avatarSkill.SubSkillLists.AddRange(skill.SubSkillLists);
+                        return avatarSkill;
+                    }));
+
+                    return a;
+                });
+
+                Rsp.AvatarLists.AddRange(Avatars);
+
+                Rsp.IsAll = false;
+            }
+
+            session.Send(GameServer.Packet.FromProto(Rsp, CmdId.GetAvatarDataRsp));
+        }
+    }
+}

GameServer/Handlers/One/GetAvatarTeamDataReqHandler.cs

@@ -0,0 +1,21 @@
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.GetAvatarTeamDataReq)]
+    internal class GetAvatarTeamDataReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            GetAvatarTeamDataRsp Rsp = new()
+            {
+                retcode = GetAvatarTeamDataRsp.Retcode.Succ
+            };
+
+            Rsp.AvatarTeamLists.AddRange(session.Player.User.AvatarTeamList);
+            Rsp.CustomAvatarTeamLists.AddRange(session.Player.User.CustomAvatarTeamList);
+
+            session.Send(Packet.FromProto(Rsp, CmdId.GetAvatarTeamDataRsp));
+        }
+    }
+}

GameServer/Handlers/One/GetBulletinReqHandler.cs

@@ -0,0 +1,13 @@
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.GetBulletinReq)]
+    internal class GetBulletinReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            session.Send(Packet.FromProto(new GetBulletinRsp() { retcode = GetBulletinRsp.Retcode.Succ, IsAll = true }, CmdId.GetBulletinRsp));
+        }
+    }
+}

GameServer/Handlers/One/GetEquipmentDataReqHandler.cs

@@ -0,0 +1,29 @@
+using Common.Database;
+using Common.Resources.Proto;
+using MongoDB.Driver;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.GetEquipmentDataReq)]
+    internal class GetEquipmentDataReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            EquipmentScheme Equipment = session.Player.Equipment;
+
+            GetEquipmentDataRsp Rsp = new()
+            {
+                retcode = GetEquipmentDataRsp.Retcode.Succ,
+                VitalityValue = 0,
+                IsAll = true
+            };
+
+            Rsp.MaterialLists.AddRange(Equipment.MaterialList.ToList());
+            Rsp.MechaLists.AddRange(Equipment.MechaList.ToList());
+            Rsp.StigmataLists.AddRange(Equipment.StigmataList.ToList());
+            Rsp.WeaponLists.AddRange(Equipment.WeaponList.ToList());
+
+            session.Send(Packet.FromProto(Rsp, CmdId.GetEquipmentDataRsp));
+        }
+    }
+}

GameServer/Handlers/One/GetGobackReqHandler.cs

@@ -0,0 +1,13 @@
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.GetGobackReq)]
+    internal class GetGobackReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            session.Send(Packet.FromProto(new GetGobackRsp() { retcode = GetGobackRsp.Retcode.Succ }, CmdId.GetGobackRsp));
+        }
+    }
+}

GameServer/Handlers/One/GetMainDataReqHandler.cs

@@ -0,0 +1,63 @@
+using Common.Database;
+using Common.Resources.Proto;
+using Common.Utils.ExcelReader;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.GetMainDataReq)]
+    internal class GetMainDataReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            UserScheme User = session.Player.User;
+
+            PlayerLevelData.LevelData levelData = PlayerLevelData.GetInstance().CalculateLevel(User.Exp);
+
+            GetMainDataRsp Rsp = new()
+            {
+                retcode = GetMainDataRsp.Retcode.Succ,
+                AssistantAvatarId = (uint)User.AssistantAvatarId,
+                Birthday = (uint)User.BirthDate,
+                Nickname = User.Nick,
+                Level = (uint)levelData.Level,
+                Exp = (uint)levelData.Exp,
+                FreeHcoin = (uint)User.Hcoin,
+                Hcoin = (uint)User.Hcoin,
+                CustomHeadId = 161001,
+                Scoin = session.Player.Equipment.MaterialList.Where(mat => mat.Id == 100).FirstOrDefault()?.Num ?? 0,
+                IsAll = true,
+                RegisterTime = User.GetCreationTime(),
+                PayHcoin = 0,
+                WarshipAvatar = User.WarshipAvatar,
+                SelfDesc = User.SelfDesc,
+                UseFrameId = 200001,
+                OnPhonePendantId = 350005,
+                Stamina = (uint)User.Stamina,
+                StaminaRecoverConfigTime = 360,
+                StaminaRecoverLeftTime = 0,
+                EquipmentSizeLimit = 1000,
+                OpenPanelActivityLists = new uint[] { 2 },
+                ChatworldActivityInfo = new()
+                {
+                    IsHasNpcRedEnvelope = false,
+                    TreasureScheduleId = 0
+                },
+                IsAllowCostSeniorEquipOnCurDevice = true,
+                TypeLists = new uint[] { 2, 3, 4, 5, 6, 7, 8, 9, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 38, 39 },
+                LevelLockId = 1,
+                Mcoin = 0,
+                MonthRechargePrice = 0,
+                WarshipTheme = new ()
+                {
+                    WarshipId = (uint)User.WarshipId
+                },
+                TotalLoginDays = 1,
+                NextEvaluateTime = 0,
+                OnMedalId = 0,
+                TodayRechargePrice = 0,
+            };
+
+            session.Send(Packet.FromProto(Rsp, CmdId.GetMainDataRsp));
+        }
+    }
+}

GameServer/Handlers/One/GetMissionDataReqHandler.cs

@@ -0,0 +1,33 @@
+using Common.Resources.Proto;
+using Common.Utils.ExcelReader;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.GetMissionDataReq)]
+    internal class GetMissionDataReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            GetMissionDataRsp Rsp = new()
+            {
+                retcode = GetMissionDataRsp.Retcode.Succ,
+                IsAll = true
+            };
+
+            MissionDataExcel[] missionDatas = MissionData.GetInstance().All;
+
+            Rsp.MissionLists.AddRange(missionDatas.Select(mission => new Mission()
+            {
+                MissionId = (uint)mission.Id,
+                Status = MissionStatus.MissionFinish,
+                Priority = (uint)mission.Priority,
+                Progress = (uint)mission.TotalProgress,
+                BeginTime = session.Player.User.GetCreationTime(),
+                EndTime = 2073239999,
+                CycleId = 1
+            }));
+
+            session.Send(Packet.FromProto(Rsp, CmdId.GetMissionDataRsp));
+        }
+    }
+}

GameServer/Handlers/One/GetPlayerTokenReqHandler.cs

@@ -0,0 +1,50 @@
+using Common.Resources.Proto;
+using Common.Database;
+using Common;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.GetPlayerTokenReq)]
+    internal class GetPlayerTokenReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet _packet)
+        {
+            GetPlayerTokenReq Packet = _packet.GetDecodedBody<GetPlayerTokenReq>();
+            GetPlayerTokenRsp Rsp = new () { };
+            UserScheme? CurrentUser = User.FromToken(Packet.AccountToken);
+
+            if (CurrentUser is null || CurrentUser.Uid != uint.Parse(Packet.AccountUid))
+            {
+                Rsp.retcode = GetPlayerTokenRsp.Retcode.AccountVerifyError;
+                Rsp.Msg = "Account verification failed, please re-login!";
+            }
+            else
+            {
+                session.Player = new Game.Player(CurrentUser);
+
+                if(session.Player.User.IsFirstLogin)
+                {
+                    AvatarScheme avatar = Common.Database.Avatar.Create(101, session.Player.User.Uid, session.Player.Equipment);
+                    session.Player.AvatarList = session.Player.AvatarList.Append(avatar).ToArray();
+                    if ((int)Global.config.VerboseLevel > 0)
+                        session.c.Log($"Automatically created avatar with id: {avatar.AvatarId}");
+                }
+
+                Rsp = new()
+                {
+                    retcode = GetPlayerTokenRsp.Retcode.Succ,
+                    Uid = CurrentUser.Uid,
+                    Token = CurrentUser.Token,
+                    AccountType = Packet.AccountType,
+                    AccountUid = Packet.AccountUid,
+                    UserType = 4,
+                    HoyolabAccountUid = Packet.AccountUid,
+                    FightserverIp = 186782306,
+                    FightserverPort = 2096693423
+                };
+            }
+
+            session.Send(GameServer.Packet.FromProto(Rsp, CmdId.GetPlayerTokenRsp));
+        }
+    }
+}

GameServer/Handlers/One/GetStageDataReqHandler.cs

@@ -0,0 +1,28 @@
+using Common.Resources.Proto;
+using Common.Utils.ExcelReader;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.GetStageDataReq)]
+    internal class GetStageDataReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            GetStageDataRsp Rsp = new()
+            {
+                retcode = GetStageDataRsp.Retcode.Succ,
+                IsAll = true,
+            };
+
+            Rsp.StageLists.AddRange(StageData.GetInstance().All.Select(stage => new Stage()
+            {
+                Id = (uint)stage.LevelId,
+                IsDone = true,
+                Progress = (uint)stage.MaxProgress,
+                EnterTimes = 1
+            }));
+
+            session.Send(Packet.FromProto(Rsp, CmdId.GetStageDataRsp));
+        }
+    }
+}

GameServer/Handlers/One/NicknameModifyReqHandler.cs

@@ -0,0 +1,18 @@
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.NicknameModifyReq)]
+    internal class NicknameModifyReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            NicknameModifyReq Data = packet.GetDecodedBody<NicknameModifyReq>();
+
+            session.Player.User.Nick = Data.Nickname;
+
+            GetMainDataRsp MainDataRsp = new() { retcode = GetMainDataRsp.Retcode.Succ, Nickname = session.Player.User.Nick };
+            session.Send(Packet.FromProto(MainDataRsp, CmdId.GetMainDataRsp), Packet.FromProto(new NicknameModifyRsp() { retcode = NicknameModifyRsp.Retcode.Succ }, CmdId.NicknameModifyRsp));
+        }
+    }
+}

GameServer/Handlers/One/PlayerLoginReqHandler.cs

@@ -0,0 +1,39 @@
+using Common;
+using Common.Database;
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.PlayerLoginReq)]
+    internal class PlayerLoginReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            UserScheme User = session.Player.User;
+
+            if(Login.UserLogin(User.Uid))
+            {
+                session.Player.ResetAvatarsTodayGoodfeel();
+            }
+
+            PlayerLoginRsp Rsp = new()
+            {
+                retcode = PlayerLoginRsp.Retcode.Succ,
+                IsFirstLogin = User.IsFirstLogin,
+                RegionName = Global.config.Gameserver.RegionName,
+                CgType = User.IsFirstLogin ? CGType.CgStart : CGType.CgSevenChapter,
+                RegionId = 248,
+                LoginSessionToken = 1,
+                PsychoKey = 0
+            };
+
+            session.Send(Packet.FromProto(Rsp, CmdId.PlayerLoginRsp), Packet.FromProto(new GetMpDataRsp()
+            {
+                retcode = GetMpDataRsp.Retcode.Succ,
+                DataType = MpDataType.MpDataPunishTime,
+                op_type = GetMpDataRsp.OpType.UpdateData,
+                PunishEndTime = 0
+            }, CmdId.GetMpDataRsp));
+        }
+    }
+}

GameServer/Handlers/One/ReportBirthdayReqHandler.cs

@@ -0,0 +1,22 @@
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.ReportBirthdayReq)]
+    internal class ReportBirthdayReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            ReportBirthdayReq Data = packet.GetDecodedBody<ReportBirthdayReq>();
+            session.Player.User.BirthDate = (int)Data.Birthday;
+            GetMainDataRsp mainDataRsp = new()
+            {
+                retcode = GetMainDataRsp.Retcode.Succ,
+                Birthday = Data.Birthday
+            };
+            ReportBirthdayRsp Rsp = new() { retcode = ReportBirthdayRsp.Retcode.Succ };
+
+            session.Send(Packet.FromProto(mainDataRsp, CmdId.GetMainDataRsp), Packet.FromProto(Rsp, CmdId.ReportBirthdayRsp));
+        }
+    }
+}

GameServer/Handlers/One/SetDressReqHandler.cs

@@ -0,0 +1,34 @@
+using Common.Database;
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.SetDressReq)]
+    internal class SetDressReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            SetDressReq Data = packet.GetDecodedBody<SetDressReq>();
+            SetDressRsp Rsp = new() { retcode = SetDressRsp.Retcode.Succ };
+            AvatarScheme? avatar = session.Player.AvatarList.Where(x => x.AvatarId == Data.AvatarId).FirstOrDefault();
+            if (avatar is not null)
+            {
+                if (avatar.DressLists.Contains(Data.DressId))
+                {
+                    avatar.SetDress(Data.DressId);
+                    session.ProcessPacket(Packet.FromProto(new GetAvatarDataReq() { AvatarIdLists = new uint[] { avatar.AvatarId } }, CmdId.GetAvatarDataReq));
+                }
+                else
+                {
+                    Rsp.retcode = SetDressRsp.Retcode.DressNotExist;
+                }
+            }
+            else
+            {
+                Rsp.retcode = SetDressRsp.Retcode.AvatarNotExist;
+            }
+
+            session.Send(Packet.FromProto(Rsp, CmdId.SetDressRsp));
+        }
+    }
+}

GameServer/Handlers/One/SetSelfDescReqHandler.cs

@@ -0,0 +1,22 @@
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.SetSelfDescReq)]
+    internal class SetSelfDescReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            SetSelfDescReq Data = packet.GetDecodedBody<SetSelfDescReq>();
+            session.Player.User.SelfDesc = Data.SelfDesc;
+            GetMainDataRsp mainDataRsp = new()
+            {
+                retcode = GetMainDataRsp.Retcode.Succ,
+                SelfDesc = Data.SelfDesc
+            };
+            SetSelfDescRsp Rsp = new() { retcode = SetSelfDescRsp.Retcode.Succ };
+
+            session.Send(Packet.FromProto(mainDataRsp, CmdId.GetMainDataRsp), Packet.FromProto(Rsp, CmdId.SetSelfDescRsp));
+        }
+    }
+}

GameServer/Handlers/One/StageBeginReqHandler.cs

@@ -0,0 +1,23 @@
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.StageBeginReq)]
+    internal class StageBeginReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            StageBeginReq Data = packet.GetDecodedBody<StageBeginReq>();
+
+            StageBeginRsp Rsp = new()
+            {
+                retcode = StageBeginRsp.Retcode.Succ,
+                StageId = Data.StageId,
+                Progress = 0,
+                IsCollectCheatData = false
+            };
+
+            session.Send(Packet.FromProto(Rsp, CmdId.StageBeginRsp));
+        }
+    }
+}

GameServer/Handlers/One/StageEndReqHandler.cs

@@ -0,0 +1,65 @@
+using Common.Database;
+using Common.Resources.Proto;
+using Common.Utils.ExcelReader;
+using ProtoBuf;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.StageEndReq)]
+    internal class StageEndReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            StageEndReq Data = packet.GetDecodedBody<StageEndReq>();
+            StageEndReqBody DecodedBody = Serializer.Deserialize<StageEndReqBody>(Data.Body.AsSpan());
+            StageDataExcel? StageData = Common.Utils.ExcelReader.StageData.GetInstance().FromId((int)DecodedBody.StageId);
+
+            if(StageData == null)
+            {
+                session.c.Error("StageData Excel Is Bad Please Fix");
+                session.Send(Packet.FromProto(new StageEndRsp() { retcode = StageEndRsp.Retcode.StageError }, CmdId.StageEndRsp));
+                return;
+            }
+            else if(StageData.LevelId == 10101)
+            {
+                session.Player.User.IsFirstLogin = false;
+            }
+
+            StageEndRsp Rsp = new()
+            {
+                retcode = StageEndRsp.Retcode.Succ,
+                StageId = DecodedBody.StageId,
+                EndStatus = DecodedBody.EndStatus
+            };
+
+            if(DecodedBody.EndStatus == StageEndStatus.StageWin)
+            {
+                EquipmentScheme Equipment = session.Player.Equipment;
+
+                foreach (DropItem DropItem in DecodedBody.DropItemLists)
+                {
+                    Equipment.AddMaterial((int)DropItem.ItemId, (int)DropItem.Num);
+                }
+
+                if(DecodedBody.ChallengeIndexLists is not null)
+                {
+                    session.Player.User.Hcoin += DecodedBody.ChallengeIndexLists.Length * 5;
+                    Rsp.ChallengeLists.AddRange(DecodedBody.ChallengeIndexLists.Select(challengeIndex => new StageChallengeData() { ChallengeIndex = challengeIndex, Reward = new() { Hcoin = 5 } }));
+                }
+
+                session.Player.User.AddExp(100);
+
+                session.ProcessPacket(Packet.FromProto(new GetMainDataReq() { }, CmdId.GetMainDataReq));
+                session.ProcessPacket(Packet.FromProto(new GetEquipmentDataReq() { }, CmdId.GetEquipmentDataReq));
+                session.ProcessPacket(Packet.FromProto(new GetWorldMapDataReq() { }, CmdId.GetWorldMapDataReq));
+                session.ProcessPacket(Packet.FromProto(new GetStageDataReq() { }, CmdId.GetStageDataReq));
+
+                Rsp.PlayerExpReward = 100;
+                Rsp.AvatarExpReward = DecodedBody.AvatarExpReward;
+                Rsp.ScoinReward = DecodedBody.ScoinReward;
+            }
+
+            session.Send(Packet.FromProto(Rsp, CmdId.StageEndRsp));
+        }
+    }
+}

GameServer/Handlers/One/StageInnerDataReportReqHandler.cs

@@ -0,0 +1,13 @@
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.StageInnerDataReportReq)]
+    internal class StageInnerDataReportReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            session.Send(Packet.FromProto(new StageInnerDataReportRsp() { retcode = StageInnerDataReportRsp.Retcode.Succ }, CmdId.StageInnerDataReportRsp));
+        }
+    }
+}

GameServer/Handlers/One/UpdateAssistantAvatarIdReqHandler.cs

@@ -0,0 +1,19 @@
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.UpdateAssistantAvatarIdReq)]
+    public class UpdateAssistantAvatarIdReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            UpdateAssistantAvatarIdReq Data = packet.GetDecodedBody<UpdateAssistantAvatarIdReq>();
+            session.Player.User.AssistantAvatarId = (int)Data.AvatarId;
+
+            UpdateAssistantAvatarIdRsp Rsp = new() { retcode = UpdateAssistantAvatarIdRsp.Retcode.Succ };
+            GetMainDataRsp MainDataRsp = new() { retcode = GetMainDataRsp.Retcode.Succ, AssistantAvatarId = (uint)session.Player.User.AssistantAvatarId };
+
+            session.Send(Packet.FromProto(MainDataRsp, CmdId.GetMainDataRsp), Packet.FromProto(Rsp, CmdId.UpdateAssistantAvatarIdRsp));
+        }
+    }
+}

GameServer/Handlers/One/UpdateAvatarTeamNotifyHandler.cs

@@ -0,0 +1,23 @@
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.UpdateAvatarTeamNotify)]
+    internal class UpdateAvatarTeamNotifyHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            UpdateAvatarTeamNotify Data = packet.GetDecodedBody<UpdateAvatarTeamNotify>();
+
+            AvatarTeam? avatarTeam = session.Player.User.AvatarTeamList.FirstOrDefault(team => team.StageType == Data.Team.StageType);
+            if(avatarTeam is not null)
+            {
+                avatarTeam.AvatarIdLists = Data.Team.AvatarIdLists;
+            }
+            else
+            {
+                session.Player.User.AvatarTeamList.Add(Data.Team);
+            }
+        }
+    }
+}

GameServer/Handlers/One/UpdateCustomAvatarTeamReqHandler.cs

@@ -0,0 +1,32 @@
+using Common.Database;
+using Common.Resources.Proto;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.UpdateCustomAvatarTeamReq)]
+    internal class UpdateCustomAvatarTeamReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            UpdateCustomAvatarTeamReq Data = packet.GetDecodedBody<UpdateCustomAvatarTeamReq>();
+            UpdateCustomAvatarTeamRsp Rsp = new() { retcode = UpdateCustomAvatarTeamRsp.Retcode.Succ };
+
+            CustomAvatarTeam? customAvatarTeam = session.Player.User.CustomAvatarTeamList.FirstOrDefault(x => x.TeamId == Data.Team.TeamId);
+            if (customAvatarTeam is not null) 
+            {
+                customAvatarTeam.AvatarIdLists = Data.Team.AvatarIdLists;
+                customAvatarTeam.ElfIdLists = Data.Team.ElfIdLists;
+                customAvatarTeam.Name = Data.Team.Name;
+            }
+            else
+            {
+                session.Player.User.CustomAvatarTeamList.Add(Data.Team);
+            }
+
+            GetAvatarTeamDataRsp avatarTeamDataRsp = new() { retcode = GetAvatarTeamDataRsp.Retcode.Succ };
+            avatarTeamDataRsp.CustomAvatarTeamLists.Add(Data.Team);
+
+            session.Send(Packet.FromProto(avatarTeamDataRsp, CmdId.GetAvatarTeamDataRsp), Packet.FromProto(Rsp, CmdId.UpdateCustomAvatarTeamRsp));
+        }
+    }
+}

GameServer/Handlers/One/UseMaterialReqHandler.cs

@@ -0,0 +1,87 @@
+using Common.Database;
+using Common.Resources.Proto;
+using Common.Utils.ExcelReader;
+
+namespace PemukulPaku.GameServer.Handlers
+{
+    [PacketCmdId(CmdId.UseMaterialReq)]
+    internal class UseMaterialReqHandler : IPacketHandler
+    {
+        public void Handle(Session session, Packet packet)
+        {
+            UseMaterialReq Data = packet.GetDecodedBody<UseMaterialReq>();
+            MaterialDataExcel? materialData = MaterialData.GetInstance().FromId(Data.MaterialId);
+            MaterialUseDataExcel? useData = MaterialUseData.GetInstance().FromId(materialData?.UseId ?? 0);
+            UseMaterialRsp Rsp = new() { retcode = UseMaterialRsp.Retcode.ConsumeItemNotExist };
+
+            Common.Resources.Proto.Material costMaterial = session.Player.Equipment.AddMaterial((int)Data.MaterialId, -(int)Data.Num);
+            GetEquipmentDataRsp equipmentRsp = new() { retcode = GetEquipmentDataRsp.Retcode.Succ, VitalityValue = 5900 };
+            equipmentRsp.MaterialLists.Add(costMaterial);
+
+            if (useData is not null)
+            {
+                ParameterData parameterData = GetParameterData(useData, (int)Data.Parameter);
+                RewardDataExcel? rewardData = Common.Utils.ExcelReader.RewardData.GetInstance().FromId(parameterData.RewardId);
+                Rsp.retcode = UseMaterialRsp.Retcode.Succ;
+
+                Common.Resources.Proto.RewardData reward = new() { };
+                
+                switch(useData.UseType)
+                {
+                    case (int)MaterialUseType.MaterialUseAvatarFragmentTransform:
+                        AvatarDataExcel? avatarData = AvatarData.GetInstance().All.FirstOrDefault(x => x.AvatarFragmentId == parameterData.RewardId);
+                        if (avatarData is not null)
+                        {
+                            reward.ItemLists.Add(new()
+                            {
+                                Id = (uint)parameterData.RewardId,
+                                Num = (uint)parameterData.Num * Data.Num
+                            });
+                            AvatarScheme? avatar = session.Player.AvatarList.FirstOrDefault(avatar => avatar.AvatarId == avatarData.AvatarId);
+                            avatar?.AddFragment((uint)parameterData.Num * Data.Num);
+                            session.ProcessPacket(Packet.FromProto(new GetAvatarDataReq() { AvatarIdLists = new uint[] { (uint)avatarData.AvatarId } }, CmdId.GetAvatarDataReq));
+                        }
+                        break;
+                    default:
+                        Rsp.retcode = UseMaterialRsp.Retcode.FeatureClosed;
+                        break;
+                }
+
+                Rsp.GiftRewardLists.Add(reward);
+            }
+
+            session.Send(Packet.FromProto(equipmentRsp, CmdId.GetEquipmentDataRsp), Packet.FromProto(Rsp, CmdId.UseMaterialRsp));
+        }
+
+        private static ParameterData GetParameterData(MaterialUseDataExcel useData, int clientPara)
+        {
+            int Num = 1;
+            if (clientPara == 0)
+            {
+                if(useData.ParaStr[0].Contains(":"))
+                {
+                    Num = int.Parse(useData.ParaStr[0].Split(":")[1]);
+                    clientPara = int.Parse(useData.ParaStr[0].Split(":")[0]);
+                }
+                else
+                {
+                    clientPara = int.Parse(useData.ParaStr[0]);
+                }
+            }
+
+            return new ParameterData(clientPara, Num);
+        }
+
+        private struct ParameterData
+        {
+            public ParameterData(int rewardId, int num)
+            {
+                Num = num;
+                RewardId = rewardId;
+            }
+
+            public int RewardId { get; set; }
+            public int Num { get; set; }
+        }
+    }
+}