use fragment material and avatar star up also prevent capt. exp overflow

this took wayyyyyyyyyy longer than it shoud be

Common/Database/Avatar.cs

@@ -90,6 +90,20 @@ namespace Common.Database
             return levelData;
         }
 
+        public void StarUp()
+        {
+            AvatarDataExcel? avatarData = AvatarData.GetInstance().FromId((int)AvatarId);
+            if (avatarData is not null)
+            {
+                AvatarStarType.StarInfo nextStarInfo = AvatarStarType.GetInstance().GetNextStar(avatarData.AvatarType, avatarData.AvatarStarUpType, new((int)Star, (int)SubStar));
+                SubStar = (uint)nextStarInfo.SubStar;
+                Star = (uint)nextStarInfo.Star;
+                Fragment -= (uint)nextStarInfo.Cost;
+            }
+        }
+
+        public void AddFragment(uint num) { Fragment += num; }
+
         public void LevelUpSkill(uint subSkillId, bool isLevelUpAll = false)
         {
             AvatarSubSkillDataExcel? subSkillData = AvatarSubSkillData.GetInstance().FromId((int)subSkillId);

Common/Database/User.cs

@@ -1,6 +1,7 @@
 using MongoDB.Bson;
 using Common.Resources.Proto;
 using MongoDB.Driver;
+using Common.Utils.ExcelReader;
 
 namespace Common.Database
 {
@@ -79,10 +80,20 @@ namespace Common.Database
         {
             User.collection.ReplaceOne(Builders<UserScheme>.Filter.Eq(user => user.Id, Id), this);
         }
+        
         public uint GetCreationTime()
         {
             return (uint)((DateTimeOffset)Id.CreationTime).ToUnixTimeSeconds();
         }
+        
+        public void AddExp(int exp)
+        {
+            Exp += exp;
+            if (Exp > PlayerLevelData.GetInstance().GetMaxPossibleExp())
+            {
+                Exp = PlayerLevelData.GetInstance().GetMaxPossibleExp();
+            }
+        }
     }        
 #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
     

Common/Utils/ExcelReader/AvatarStarType.cs

@@ -0,0 +1,62 @@
+using Newtonsoft.Json;
+
+namespace Common.Utils.ExcelReader
+{
+    public class AvatarStarType : BaseExcelReader<AvatarStarType, AvatarStarTypeExcel>
+    {
+        public override string FileName { get { return "AvatarStarType.json"; } }
+
+        public StarInfo GetNextStar(int avatarType, int starUpType, StarInfo currentStarInfo)
+        {
+            AvatarStarTypeExcel? currStarTypeExcel = All.FirstOrDefault(x => x.AvatarType == avatarType && x.AvatarStarUpType == starUpType && x.Star == currentStarInfo.Star && x.SubStar == currentStarInfo.SubStar);
+            if (currStarTypeExcel is not null)
+                currentStarInfo.Cost = currStarTypeExcel.Upgrade;
+
+            AvatarStarTypeExcel? starTypeExcel = All.FirstOrDefault(x => x.AvatarType == avatarType && x.AvatarStarUpType == starUpType && x.Star == ((currentStarInfo.SubStar == 3 || currentStarInfo.Star < 3) ? currentStarInfo.Star + 1 : currentStarInfo.Star) && x.SubStar == ((currentStarInfo.SubStar < 3 && currentStarInfo.Star >= 3) ? currentStarInfo.SubStar + 1 : 0));
+            if (starTypeExcel is not null)
+            {
+                currentStarInfo.SubStar = starTypeExcel.SubStar;
+                currentStarInfo.Star = starTypeExcel.Star;
+            }
+            return currentStarInfo;
+        }
+
+        public struct StarInfo
+        {
+            public StarInfo(int star, int subStar)
+            {
+                Star = star;
+                SubStar = subStar;
+            }
+
+            public int Star { get; set; }
+            public int SubStar { get; set; }
+            public int Cost { get; set; } = 0;
+        }
+    }
+
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+    public partial class AvatarStarTypeExcel
+    {
+        [JsonProperty("upgrade")]
+        public int Upgrade { get; set; }
+
+        [JsonProperty("IconPath")]
+        public string IconPath { get; set; }
+
+        [JsonProperty("DataImpl")]
+        public object DataImpl { get; set; }
+
+        [JsonProperty("Star")]
+        public int Star { get; set; }
+
+        [JsonProperty("SubStar")]
+        public int SubStar { get; set; }
+
+        [JsonProperty("avatarType")]
+        public int AvatarType { get; set; }
+
+        [JsonProperty("avatarStarUpType")]
+        public int AvatarStarUpType { get; set; }
+    }
+}

Common/Utils/ExcelReader/MaterialUseData.cs

@@ -0,0 +1,51 @@
+using Newtonsoft.Json;
+
+namespace Common.Utils.ExcelReader
+{
+    public class MaterialUseData : BaseExcelReader<MaterialUseData, MaterialUseDataExcel>
+    {
+        public override string FileName { get { return "MaterialUseData.json"; } }
+
+        public MaterialUseDataExcel? FromId(int id)
+        {
+            return All.Where(x => x.UseId == id).FirstOrDefault();
+        }
+    }
+
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+    public partial class MaterialUseDataExcel
+    {
+        [JsonProperty("useType")]
+        public int UseType { get; set; }
+
+        [JsonProperty("MultiUse")]
+        public int MultiUse { get; set; }
+
+        [JsonProperty("MaterialUseConfirmType")]
+        public int MaterialUseConfirmType { get; set; }
+
+        [JsonProperty("paraStr")]
+        public string[] ParaStr { get; set; }
+
+        [JsonProperty("useTip")]
+        public HashName UseTip { get; set; }
+
+        [JsonProperty("useMin")]
+        public int UseMin { get; set; }
+
+        [JsonProperty("useMax")]
+        public int UseMax { get; set; }
+
+        [JsonProperty("AdditionDesc")]
+        public string AdditionDesc { get; set; }
+
+        [JsonProperty("EventID")]
+        public int EventId { get; set; }
+
+        [JsonProperty("DataImpl")]
+        public object DataImpl { get; set; }
+
+        [JsonProperty("useID")]
+        public int UseId { get; set; }
+    }
+}

Common/Utils/ExcelReader/PlayerLevelData.cs

@@ -84,6 +84,11 @@ namespace Common.Utils.ExcelReader
 
             return new LevelData(level, exp);
         }
+
+        public int GetMaxPossibleExp()
+        {
+            return All.Select(x => x.Exp).Sum() - 1;
+        }
     }
 
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.

Common/Utils/ExcelReader/RewardData.cs

@@ -0,0 +1,93 @@
+using Newtonsoft.Json;
+
+namespace Common.Utils.ExcelReader
+{
+    public class RewardData : BaseExcelReader<RewardData, RewardDataExcel>
+    {
+        public override string FileName { get { return "RewardData.json"; } }
+
+        public RewardDataExcel? FromId(int id)
+        {
+            return All.Where(x => x.RewardId == id).FirstOrDefault();
+        }
+    }
+
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+    public partial class RewardDataExcel
+    {
+        [JsonProperty("RewardExp")]
+        public int RewardExp { get; set; }
+
+        [JsonProperty("RewardHCoin")]
+        public int RewardHCoin { get; set; }
+
+        [JsonProperty("RewardStamina")]
+        public int RewardStamina { get; set; }
+
+        [JsonProperty("RewardFriendPoint")]
+        public int RewardFriendPoint { get; set; }
+
+        [JsonProperty("RewardDutyPoint")]
+        public int RewardDutyPoint { get; set; }
+
+        [JsonProperty("RewardItem1ID")]
+        public int RewardItem1Id { get; set; }
+
+        [JsonProperty("RewardItem1Level")]
+        public int RewardItem1Level { get; set; }
+
+        [JsonProperty("RewardItem1Num")]
+        public int RewardItem1Num { get; set; }
+
+        [JsonProperty("RewardItem2ID")]
+        public int RewardItem2Id { get; set; }
+
+        [JsonProperty("RewardItem2Level")]
+        public int RewardItem2Level { get; set; }
+
+        [JsonProperty("RewardItem2Num")]
+        public int RewardItem2Num { get; set; }
+
+        [JsonProperty("RewardItem3ID")]
+        public int RewardItem3Id { get; set; }
+
+        [JsonProperty("RewardItem3Level")]
+        public int RewardItem3Level { get; set; }
+
+        [JsonProperty("RewardItem3Num")]
+        public int RewardItem3Num { get; set; }
+
+        [JsonProperty("RewardItem4ID")]
+        public int RewardItem4Id { get; set; }
+
+        [JsonProperty("RewardItem4Level")]
+        public int RewardItem4Level { get; set; }
+
+        [JsonProperty("RewardItem4Num")]
+        public int RewardItem4Num { get; set; }
+
+        [JsonProperty("RewardItem5ID")]
+        public int RewardItem5Id { get; set; }
+
+        [JsonProperty("RewardItem5Level")]
+        public int RewardItem5Level { get; set; }
+
+        [JsonProperty("RewardItem5Num")]
+        public int RewardItem5Num { get; set; }
+
+        [JsonProperty("RewardItem6ID")]
+        public int RewardItem6Id { get; set; }
+
+        [JsonProperty("RewardItem6Level")]
+        public int RewardItem6Level { get; set; }
+
+        [JsonProperty("RewardItem6Num")]
+        public int RewardItem6Num { get; set; }
+
+        [JsonProperty("DataImpl")]
+        public object DataImpl { get; set; }
+
+        [JsonProperty("RewardID")]
+        public int RewardId { get; set; }
+    }
+}

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

@@ -47,7 +47,7 @@ namespace PemukulPaku.GameServer.Handlers
                     Rsp.ChallengeLists.AddRange(DecodedBody.ChallengeIndexLists.Select(challengeIndex => new StageChallengeData() { ChallengeIndex = challengeIndex, Reward = new() { Hcoin = 5 } }));
                 }
 
-                session.Player.User.Exp += 100;
+                session.Player.User.AddExp(100);
 
                 session.ProcessPacket(Packet.FromProto(new GetMainDataReq() { }, CmdId.GetMainDataReq));
                 session.ProcessPacket(Packet.FromProto(new GetEquipmentDataReq() { }, CmdId.GetEquipmentDataReq));

GameServer/Handlers/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; }
+        }
+    }
+}

Program.cs

@@ -4,6 +4,8 @@ using PemukulPaku.GameServer;
 using Common.Database;
 using PemukulPaku.GameServer.Game;
 using PemukulPaku.GameServer.Commands;
+using Common.Utils.ExcelReader;
+using Newtonsoft.Json;
 
 namespace PemukulPaku
 {