equipment switching & level up with avatar level up fix

Common/Database/Avatar.cs

@@ -74,7 +74,7 @@ namespace Common.Database
 
         public PlayerLevelData.LevelData AddExp(uint exp)
         {
-            PlayerLevelData.LevelData levelData = AvatarLevelData.GetInstance().CalculateLevel((int)(exp + Exp));
+            PlayerLevelData.LevelData levelData = AvatarLevelData.GetInstance().CalculateLevel((int)Level, (int)(exp + Exp));
             Level = (uint)levelData.Level;
             Exp = (uint)levelData.Exp;
 

Common/Database/Equipment.cs

@@ -84,6 +84,86 @@ namespace Common.Database
             return stigmata;
         }
 
+        public Resources.Proto.Material[] AddWeaponExpByConsumeItem(uint uniqueId, List<EquipmentItem> consumeItemList)
+        {
+            int expAdd = consumeItemList.Select(item =>
+            {
+                MaterialDataExcel? materialData = MaterialData.GetInstance().FromId(item.IdOrUniqueId);
+                if (materialData == null)
+                    return 0;
+
+                int MaterialIndex = MaterialList.ToList().FindIndex(mat => mat.Id == item.IdOrUniqueId);
+                MaterialList[MaterialIndex].Num -= item.Num;
+
+                return materialData.GearExpProvideBase * (int)item.Num;
+            }).Sum();
+            AddWeaponExp(uniqueId, expAdd);
+
+            return MaterialList.Where(material => consumeItemList.Select(item => item.IdOrUniqueId).ToArray().Contains(material.Id)).ToArray();
+        }
+
+        public void AddWeaponExp(uint uniqueId, int exp)
+        {
+            int weaponIndex = WeaponList.ToList().FindIndex(weapon => weapon.UniqueId == uniqueId);
+            if (weaponIndex == -1) return;
+            WeaponDataExcel? weaponData = WeaponData.GetInstance().FromId((int)WeaponList[weaponIndex].Id);
+            if (weaponData is null) return;
+
+            PlayerLevelData.LevelData levelData = EquipmentLevelData.GetInstance().CalculateLevel((int)WeaponList[weaponIndex].Level, (int)WeaponList[weaponIndex].Exp + exp, weaponData.ExpType);
+
+            if(levelData.Level > weaponData.MaxLv)
+            {
+                levelData.Level = weaponData.MaxLv;
+                EquipmentLevelDataExcel? LevelData = EquipmentLevelData.GetInstance().FromLevel(levelData.Level);
+                if (LevelData is null) return;
+
+                levelData.Exp = LevelData.Type1[weaponData.ExpType];
+            }
+
+            WeaponList[weaponIndex].Level = (uint)levelData.Level;
+            WeaponList[weaponIndex].Exp = (uint)levelData.Exp;
+        }
+
+        public Resources.Proto.Material[] AddStigmataExpByConsumeItem(uint uniqueId, List<EquipmentItem> consumeItemList)
+        {
+            int expAdd = consumeItemList.Select(item =>
+            {
+                MaterialDataExcel? materialData = MaterialData.GetInstance().FromId(item.IdOrUniqueId);
+                if (materialData == null)
+                    return 0;
+
+                int MaterialIndex = MaterialList.ToList().FindIndex(mat => mat.Id == item.IdOrUniqueId);
+                MaterialList[MaterialIndex].Num -= item.Num;
+
+                return materialData.GearExpProvideBase * (int)item.Num;
+            }).Sum();
+            AddStigmataExp(uniqueId, expAdd);
+
+            return MaterialList.Where(material => consumeItemList.Select(item => item.IdOrUniqueId).ToArray().Contains(material.Id)).ToArray();
+        }
+
+        public void AddStigmataExp(uint uniqueId, int exp)
+        {
+            int stigmataIndex = StigmataList.ToList().FindIndex(stigmata => stigmata.UniqueId == uniqueId);
+            if (stigmataIndex == -1) return;
+            StigmataDataExcel? stigmataData = StigmataData.GetInstance().FromId((int)StigmataList[stigmataIndex].Id);
+            if (stigmataData is null) return;
+
+            PlayerLevelData.LevelData levelData = EquipmentLevelData.GetInstance().CalculateLevel((int)StigmataList[stigmataIndex].Level, (int)StigmataList[stigmataIndex].Exp + exp, stigmataData.ExpType);
+
+            if (levelData.Level > stigmataData.MaxLv)
+            {
+                levelData.Level = stigmataData.MaxLv;
+                EquipmentLevelDataExcel? LevelData = EquipmentLevelData.GetInstance().FromLevel(levelData.Level);
+                if (LevelData is null) return;
+
+                levelData.Exp = LevelData.Type1[stigmataData.ExpType];
+            }
+
+            StigmataList[stigmataIndex].Level = (uint)levelData.Level;
+            StigmataList[stigmataIndex].Exp = (uint)levelData.Exp;
+        }
+
         public Resources.Proto.Material AddMaterial(int materialId, int num = 1)
         {
             int MaterialIndex = Array.FindIndex(MaterialList, material => material.Id == materialId);

Common/Utils/ExcelReader/AvatarLevelData.cs

@@ -6,12 +6,11 @@ namespace Common.Utils.ExcelReader
     {
         public override string FileName { get { return "AvatarLevelData.json"; } }
 
-        public PlayerLevelData.LevelData CalculateLevel(int exp)
+        public PlayerLevelData.LevelData CalculateLevel(int level, int exp)
         {
-            int level = 1;
             int expRemain = exp;
 
-            foreach (AvatarLevelDataExcel levelData in All)
+            foreach (AvatarLevelDataExcel levelData in All.Where(levelData => levelData.Level >= level))
             {
                 if (expRemain < 1)
                 {

Common/Utils/ExcelReader/EquipmentLevelData.cs

@@ -0,0 +1,65 @@
+using Newtonsoft.Json;
+
+namespace Common.Utils.ExcelReader
+{
+    public class EquipmentLevelData : BaseExcelReader<EquipmentLevelData, EquipmentLevelDataExcel>
+    {
+        public override string FileName { get { return "EquipmentLevelData.json"; } }
+
+        public EquipmentLevelDataExcel? FromLevel(int level)
+        {
+            return All.Where(levelData => levelData.Level == level).FirstOrDefault();
+        }
+
+        public PlayerLevelData.LevelData CalculateLevel(int level, int exp, int expType)
+        {
+            int expRemain = exp;
+
+            foreach (EquipmentLevelDataExcel levelData in All.Where(levelData => levelData.Level >= level))
+            {
+                if (expRemain < 1)
+                {
+                    break;
+                }
+                else if (expRemain >= levelData.Type1[expType])
+                {
+                    if (level == All.OrderByDescending(level => level.Level).First().Level)
+                    {
+                        expRemain = All.OrderByDescending(level => level.Level).First().Type1[expType];
+                        break;
+                    }
+
+                    level++;
+                    expRemain -= levelData.Type1[expType];
+                }
+            }
+
+            return new PlayerLevelData.LevelData(level, expRemain);
+        }
+    }
+
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+    public partial class EquipmentLevelDataExcel
+    {
+        [JsonProperty("Type1")]
+        public int[] Type1 { get; set; }
+
+        [JsonProperty("weaponUpgradeCost")]
+        public int WeaponUpgradeCost { get; set; }
+
+        [JsonProperty("weaponEvoCost")]
+        public int WeaponEvoCost { get; set; }
+
+        [JsonProperty("stigmataUpgradeCost")]
+        public int StigmataUpgradeCost { get; set; }
+
+        [JsonProperty("stigmataEvoCost")]
+        public int StigmataEvoCost { get; set; }
+
+        [JsonProperty("DataImpl")]
+        public object DataImpl { get; set; }
+
+        [JsonProperty("level")]
+        public int Level { get; set; }
+    }
+}

Common/Utils/ExcelReader/PlayerLevelData.cs

@@ -10,7 +10,7 @@ namespace Common.Utils.ExcelReader
             return All.Where(levelData => levelData.Level == level).FirstOrDefault();
         }
 
-        public readonly struct LevelData
+        public struct LevelData
         {
             public LevelData(int level, int exp)
             {
@@ -18,8 +18,8 @@ namespace Common.Utils.ExcelReader
                 Exp = exp;
             }
 
-            public int Level { get; init; }
+            public int Level { get; set; }
-            public int Exp { get; init; }
+            public int Exp { get; set; }
         }
 
         public LevelData CalculateLevel(int exp)

GameServer/Handlers/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/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/GetAvatarDataReqHandler.cs

@@ -1,5 +1,4 @@
-using Common.Database;
+using Common.Resources.Proto;
-using Common.Resources.Proto;
 
 namespace PemukulPaku.GameServer.Handlers
 {
@@ -9,7 +8,6 @@ namespace PemukulPaku.GameServer.Handlers
         public void Handle(Session session, Packet packet)
         {
             GetAvatarDataReq Packet = packet.GetDecodedBody<GetAvatarDataReq>();
-            LoginScheme LastLogin = Login.GetUserLastLogin(session.Player.User.Uid);
 
             GetAvatarDataRsp Rsp = new()
             {
@@ -18,9 +16,9 @@ namespace PemukulPaku.GameServer.Handlers
 
             if (Packet.AvatarIdLists.Contains((uint)0))
             {
-                IEnumerable<Common.Resources.Proto.Avatar> Avatars = session.Player.AvatarList.Select(avatar =>
+                IEnumerable<Avatar> Avatars = session.Player.AvatarList.Select(avatar =>
                 {
-                    Common.Resources.Proto.Avatar a = new()
+                    Avatar a = new()
                     {
                         AvatarId = avatar.AvatarId,
                         AvatarArtifact = avatar.AvatarArtifact,
@@ -50,9 +48,9 @@ namespace PemukulPaku.GameServer.Handlers
             }
             else
             {
-                IEnumerable<Common.Resources.Proto.Avatar> Avatars = session.Player.AvatarList.Where(avatar => Packet.AvatarIdLists.Contains(avatar.AvatarId)).Select(avatar =>
+                IEnumerable<Avatar> Avatars = session.Player.AvatarList.Where(avatar => Packet.AvatarIdLists.Contains(avatar.AvatarId)).Select(avatar =>
                 {
-                    Common.Resources.Proto.Avatar a = new()
+                    Avatar a = new()
                     {
                         AvatarId = avatar.AvatarId,
                         AvatarArtifact = avatar.AvatarArtifact,