大幅技能修改和添加物品测试

OshimaModules/Effects/ItemEffects/GetEP.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.OpenEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
 {
@@ -8,7 +9,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
     {
         public override long Id => (long)EffectID.GetEP;
         public override string Name => "立即获得能量值";
-        public override string Description => $"角色立即获得 {实际获得:0.##} 点能量值。" + (Source != null && (Skill.Character != Source || Skill is not OpenSkill) ? $"来自：[ {Source} ]" + (Skill.Item != null ? $" 的 [ {Skill.Item.Name} ]" : (Skill is OpenSkill ? "" : $" 的 [ {Skill.Name} ]")) : "");
+        public override string Description => $"{Skill.TargetDescription()}立即获得 {实际获得:0.##} 点能量值。" + (Source != null && (Skill.Character != Source || Skill is not OpenSkill) ? $"来自：[ {Source} ]" + (Skill.Item != null ? $" 的 [ {Skill.Item.Name} ]" : (Skill is OpenSkill ? "" : $" 的 [ {Skill.Name} ]")) : "");
         public override EffectType EffectType { get; set; } = EffectType.Item;
 
         private readonly double 实际获得 = 0;
@@ -29,7 +30,11 @@ namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
 
         public override void OnSkillCasted(Character caster, List<Character> targets, Dictionary<string, object> others)
         {
-            caster.EP += 实际获得;
+            foreach (Character target in targets)
+            {
+                target.EP += 实际获得;
+                WriteLine($"[ {target} ] 获得了 {实际获得:0.##} 点能量值！");
+            }
         }
 
         public override void OnSkillCasted(User user, List<Character> targets, Dictionary<string, object> others)

OshimaModules/Effects/ItemEffects/GetEXP.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.OpenEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
 {
@@ -8,7 +9,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
     {
         public override long Id => (long)EffectID.GetEXP;
         public override string Name => "立即获得经验值";
-        public override string Description => $"角色立即获得 {实际获得:0.##} 点经验值。" + (Source != null && (Skill.Character != Source || Skill is not OpenSkill) ? $"来自：[ {Source} ]" + (Skill.Item != null ? $" 的 [ {Skill.Item.Name} ]" : (Skill is OpenSkill ? "" : $" 的 [ {Skill.Name} ]")) : "");
+        public override string Description => $"{Skill.TargetDescription()}立即获得 {实际获得:0.##} 点经验值。" + (Source != null && (Skill.Character != Source || Skill is not OpenSkill) ? $"来自：[ {Source} ]" + (Skill.Item != null ? $" 的 [ {Skill.Item.Name} ]" : (Skill is OpenSkill ? "" : $" 的 [ {Skill.Name} ]")) : "");
         public override EffectType EffectType { get; set; } = EffectType.Item;
 
         private readonly double 实际获得 = 0;
@@ -29,7 +30,11 @@ namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
 
         public override void OnSkillCasted(Character caster, List<Character> targets, Dictionary<string, object> others)
         {
-            caster.EXP += 实际获得;
+            foreach (Character target in targets)
+            {
+                target.EXP += 实际获得;
+                WriteLine($"[ {target} ] 获得了 {实际获得:0.##} 点经验值！");
+            }
         }
 
         public override void OnSkillCasted(User user, List<Character> targets, Dictionary<string, object> others)

OshimaModules/Effects/ItemEffects/RecoverHP.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.OpenEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
 {
@@ -8,10 +9,11 @@ namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
     {
         public override long Id => (long)EffectID.RecoverHP;
         public override string Name => "立即回复生命值";
-        public override string Description => $"立即回复角色 {实际回复:0.##} 点生命值（不可用于复活）。" + (Source != null && (Skill.Character != Source || Skill is not OpenSkill) ? $"来自：[ {Source} ]" + (Skill.Item != null ? $" 的 [ {Skill.Item.Name} ]" : (Skill is OpenSkill ? "" : $" 的 [ {Skill.Name} ]")) : "");
+        public override string Description => $"立即回复{Skill.TargetDescription()} {实际回复:0.##} 点生命值（{(能复活 ? "" : "不")}可用于复活）。" + (Source != null && (Skill.Character != Source || Skill is not OpenSkill) ? $"来自：[ {Source} ]" + (Skill.Item != null ? $" 的 [ {Skill.Item.Name} ]" : (Skill is OpenSkill ? "" : $" 的 [ {Skill.Name} ]")) : "");
         public override EffectType EffectType { get; set; } = EffectType.Item;
 
         private readonly double 实际回复 = 0;
+        private readonly bool 能复活 = false;
 
         public RecoverHP(Skill skill, Dictionary<string, object> args, Character? source = null) : base(skill, args)
         {
@@ -24,12 +26,17 @@ namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
                 {
                     实际回复 = hp;
                 }
+                key = Values.Keys.FirstOrDefault(s => s.Equals("respawn", StringComparison.CurrentCultureIgnoreCase)) ?? "";
+                if (key.Length > 0 && bool.TryParse(Values[key].ToString(), out bool respawn) && respawn)
+                {
+                    能复活 = respawn;
+                }
             }
         }
 
         public override void OnSkillCasted(Character caster, List<Character> targets, Dictionary<string, object> others)
         {
-            HealToTarget(caster, caster, 实际回复, false);
+            HealToTarget(caster, caster, 实际回复, 能复活);
         }
 
         public override void OnSkillCasted(User user, List<Character> targets, Dictionary<string, object> others)

OshimaModules/Effects/ItemEffects/RecoverHP2.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.OpenEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
 {
@@ -8,11 +9,11 @@ namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
     {
         public override long Id => (long)EffectID.RecoverHP2;
         public override string Name => "立即回复生命值";
-        public override string Description => $"立即回复角色 {回复比例 * 100:0.##}% [ {实际回复:0.##} ] 点生命值（不可用于复活）。" + (Source != null && (Skill.Character != Source || Skill is not OpenSkill) ? $"来自：[ {Source} ]" + (Skill.Item != null ? $" 的 [ {Skill.Item.Name} ]" : (Skill is OpenSkill ? "" : $" 的 [ {Skill.Name} ]")) : "");
+        public override string Description => $"立即回复{Skill.TargetDescription()} {回复比例 * 100:0.##}% 最大生命值（{(能复活 ? "" : "不")}可用于复活）。" + (Source != null && (Skill.Character != Source || Skill is not OpenSkill) ? $"来自：[ {Source} ]" + (Skill.Item != null ? $" 的 [ {Skill.Item.Name} ]" : (Skill is OpenSkill ? "" : $" 的 [ {Skill.Name} ]")) : "");
         public override EffectType EffectType { get; set; } = EffectType.Item;
 
-        private double 实际回复 => 回复比例 * (Skill.Character?.MaxHP ?? 0);
         private readonly double 回复比例 = 0;
+        private readonly bool 能复活 = false;
 
         public RecoverHP2(Skill skill, Dictionary<string, object> args, Character? source = null) : base(skill, args)
         {
@@ -25,19 +26,27 @@ namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
                 {
                     回复比例 = hp;
                 }
+                key = Values.Keys.FirstOrDefault(s => s.Equals("respawn", StringComparison.CurrentCultureIgnoreCase)) ?? "";
+                if (key.Length > 0 && bool.TryParse(Values[key].ToString(), out bool respawn) && respawn)
+                {
+                    能复活 = respawn;
+                }
             }
         }
 
         public override void OnSkillCasted(Character caster, List<Character> targets, Dictionary<string, object> others)
         {
-            HealToTarget(caster, caster, 实际回复, false);
+            foreach (Character target in targets)
+            {
+                HealToTarget(caster, target, 回复比例 * (target?.MaxHP ?? 0), 能复活);
+            }
         }
 
         public override void OnSkillCasted(User user, List<Character> targets, Dictionary<string, object> others)
         {
             foreach (Character target in targets)
             {
-                target.HP += 实际回复;
+                target.HP += 回复比例 * (target?.MaxHP ?? 0);
             }
         }
     }

OshimaModules/Effects/ItemEffects/RecoverMP.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.OpenEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
 {
@@ -8,7 +9,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
     {
         public override long Id => (long)EffectID.RecoverMP;
         public override string Name => "立即回复魔法值";
-        public override string Description => $"立即回复角色 {实际回复:0.##} 点魔法值。" + (Source != null && (Skill.Character != Source || Skill is not OpenSkill) ? $"来自：[ {Source} ]" + (Skill.Item != null ? $" 的 [ {Skill.Item.Name} ]" : (Skill is OpenSkill ? "" : $" 的 [ {Skill.Name} ]")) : "");
+        public override string Description => $"立即回复{Skill.TargetDescription()} {实际回复:0.##} 点魔法值。" + (Source != null && (Skill.Character != Source || Skill is not OpenSkill) ? $"来自：[ {Source} ]" + (Skill.Item != null ? $" 的 [ {Skill.Item.Name} ]" : (Skill is OpenSkill ? "" : $" 的 [ {Skill.Name} ]")) : "");
         public override EffectType EffectType { get; set; } = EffectType.Item;
 
         private readonly double 实际回复 = 0;

OshimaModules/Effects/ItemEffects/RecoverMP2.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.OpenEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
 {
@@ -8,10 +9,9 @@ namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
     {
         public override long Id => (long)EffectID.RecoverMP2;
         public override string Name => "立即回复魔法值";
-        public override string Description => $"立即回复角色 {回复比例 * 100:0.##}% [ {实际回复:0.##} ] 点魔法值。" + (Source != null && (Skill.Character != Source || Skill is not OpenSkill) ? $"来自：[ {Source} ]" + (Skill.Item != null ? $" 的 [ {Skill.Item.Name} ]" : (Skill is OpenSkill ? "" : $" 的 [ {Skill.Name} ]")) : "");
+        public override string Description => $"立即回复{Skill.TargetDescription()} {回复比例 * 100:0.##}% 最大魔法值。" + (Source != null && (Skill.Character != Source || Skill is not OpenSkill) ? $"来自：[ {Source} ]" + (Skill.Item != null ? $" 的 [ {Skill.Item.Name} ]" : (Skill is OpenSkill ? "" : $" 的 [ {Skill.Name} ]")) : "");
         public override EffectType EffectType { get; set; } = EffectType.Item;
 
-        private double 实际回复 => 回复比例 * (Skill.Character?.MaxMP ?? 0);
         private readonly double 回复比例 = 0;
 
         public RecoverMP2(Skill skill, Dictionary<string, object> args, Character? source = null) : base(skill, args)
@@ -30,14 +30,19 @@ namespace Oshima.FunGame.OshimaModules.Effects.ItemEffects
 
         public override void OnSkillCasted(Character caster, List<Character> targets, Dictionary<string, object> others)
         {
-            caster.MP += 实际回复;
+            foreach (Character target in targets)
+            {
+                double mp = 回复比例 * target.MaxMP;
+                target.MP += mp;
+                WriteLine($"[ {target} ] 回复了 {mp:0.##} 点魔法值！");
+            }
         }
 
         public override void OnSkillCasted(User user, List<Character> targets, Dictionary<string, object> others)
         {
             foreach (Character target in targets)
             {
-                target.MP += 实际回复;
+                target.MP += 回复比例 * (target?.MaxHP ?? 0);
             }
         }
     }

OshimaModules/Effects/PassiveEffects/气绝.cs

@@ -7,7 +7,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.PassiveEffects
     {
         public override long Id => 4109;
         public override string Name => "气绝";
-        public override string Description => $"此角色处于气绝状态，行动受限并且每{GameplayEquilibriumConstant.InGameTime}持续流失 {(_isPercentage ? $"{_durationDamagePercent * 100:0.##}% [ {Damage:0.##} ]" : Damage.ToString("0.##"))} 点生命值。来自：[ {Source} ] 的 [ {Skill.Name} ]";
+        public override string Description => $"此角色处于气绝状态，行动受限并且每{GameplayEquilibriumConstant.InGameTime}持续流失 {(_isPercentage ? $"{_durationDamagePercent * 100:0.##}% [ {Damage:0.##} ]" : Damage.ToString("0.##"))} 点当前生命值。来自：[ {Source} ] 的 [ {Skill.Name} ]";
         public override EffectType EffectType => EffectType.Bleed;
         public override DispelledType DispelledType => DispelledType.Strong;
         public override bool IsDebuff => true;
@@ -44,11 +44,24 @@ namespace Oshima.FunGame.OshimaModules.Effects.PassiveEffects
         {
             if (character.HP > 0)
             {
-                double damage = Damage * elapsed;
+                if (elapsed > 1)
-                character.HP -= damage;
-                if (character.HP <= 0)
                 {
-                    character.HP = 1;
+                    int loop = 0;
+                    for (; loop < elapsed; loop++)
+                    {
+                        OnTimeElapsed(character, 1);
+                    }
+                    elapsed -= loop;
+                    if (elapsed > 0)
+                    {
+                        OnTimeElapsed(character, elapsed);
+                    }
+                }
+                else
+                {
+                    double damage = Damage * elapsed;
+                    WriteLine($"[ {character} ] 因气绝而流失生命值！");
+                    DamageToEnemy(Source, character, DamageType.True, MagicType, damage);
                 }
             }
         }

OshimaModules/Effects/PassiveEffects/虚弱.cs

@@ -42,7 +42,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.PassiveEffects
             _healingReductionPercent = healingReductionPercent;
         }
 
-        public override double AlterActualDamageAfterCalculation(Character character, Character enemy, double damage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult, ref bool isEvaded, Dictionary<Effect, double> totalDamageBonus)
+        public override double AlterActualDamageAfterCalculation(Character character, Character enemy, double damage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult, ref bool isEvaded, Dictionary<Effect, double> totalDamageBonus)
         {
             if (character == _targetCharacter)
             {

OshimaModules/Effects/SkillEffects/基于属性的伤害.cs

@@ -1,5 +1,6 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -7,7 +8,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"对目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}敌人造成 {BaseDamage:0.##} + {AttributeCoefficient * 100:0.##}% {CharacterSet.GetPrimaryAttributeName(基于属性)} [ {Damage:0.##} ] 点{(IsMagic ? CharacterSet.GetMagicDamageName(MagicType) : "物理伤害")}。";
+        public override string Description => $"对{Skill.TargetDescription()}造成 {BaseDamage:0.##} + {AttributeCoefficient * 100:0.##}% {CharacterSet.GetPrimaryAttributeName(基于属性)} [ {Damage:0.##} ] 点{CharacterSet.GetDamageTypeName(DamageType, MagicType)}。";
         private double BaseDamage => Skill.Level > 0 ? 基础数值伤害 + 基础伤害等级成长 * (Skill.Level - 1) : 基础数值伤害;
         private double AttributeCoefficient => Skill.Level > 0 ? 基础属性系数 + 基础系数等级成长 * (Skill.Level - 1) : 基础属性系数;
         private double Damage
@@ -33,9 +34,9 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
         private double 基础伤害等级成长 { get; set; } = 50;
         private double 基础属性系数 { get; set; } = 0.4;
         private double 基础系数等级成长 { get; set; } = 0.4;
-        private bool IsMagic { get; set; } = true;
+        private DamageType DamageType { get; set; } = DamageType.Magical;
 
-        public 基于属性的伤害(Skill skill, PrimaryAttribute 基于属性, double 基础数值伤害, double 基础伤害等级成长, double 基础属性系数, double 基础系数等级成长, bool isMagic = true, MagicType magicType = MagicType.None) : base(skill)
+        public 基于属性的伤害(Skill skill, PrimaryAttribute 基于属性, double 基础数值伤害, double 基础伤害等级成长, double 基础属性系数, double 基础系数等级成长, DamageType damageType = DamageType.Magical, MagicType magicType = MagicType.None) : base(skill)
         {
             GamingQueue = skill.GamingQueue;
             this.基于属性 = 基于属性;
@@ -43,7 +44,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
             this.基础伤害等级成长 = 基础伤害等级成长;
             this.基础属性系数 = 基础属性系数;
             this.基础系数等级成长 = 基础系数等级成长;
-            IsMagic = isMagic;
+            DamageType = damageType;
             MagicType = magicType;
         }
 
@@ -51,7 +52,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
         {
             foreach (Character enemy in targets)
             {
-                DamageToEnemy(caster, enemy, IsMagic, MagicType, Damage);
+                DamageToEnemy(caster, enemy, DamageType, MagicType, Damage);
             }
         }
     }

OshimaModules/Effects/SkillEffects/基于攻击力的伤害_带基础伤害.cs

@@ -1,5 +1,6 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -7,7 +8,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"对目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}敌人造成 {BaseDamage:0.##} + {ATKCoefficient * 100:0.##}% 攻击力 [ {Damage:0.##} ] 点{(IsMagic ? CharacterSet.GetMagicDamageName(MagicType) : "物理伤害")}。";
+        public override string Description => $"对{Skill.TargetDescription()}造成 {BaseDamage:0.##} + {ATKCoefficient * 100:0.##}% 攻击力 [ {Damage:0.##} ] 点{CharacterSet.GetDamageTypeName(DamageType, MagicType)}。";
 
         private double BaseDamage => Skill.Level > 0 ? 基础数值伤害 + 基础伤害等级成长 * (Skill.Level - 1) : 基础数值伤害;
         private double ATKCoefficient => Skill.Level > 0 ? 基础攻击力系数 + 基础系数等级成长 * (Skill.Level - 1) : 基础攻击力系数;
@@ -16,16 +17,16 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
         private double 基础伤害等级成长 { get; set; } = 50;
         private double 基础攻击力系数 { get; set; } = 0.2;
         private double 基础系数等级成长 { get; set; } = 0.2;
-        private bool IsMagic { get; set; } = true;
+        private DamageType DamageType { get; set; } = DamageType.Magical;
 
-        public 基于攻击力的伤害_带基础伤害(Skill skill, double 基础数值伤害, double 基础伤害等级成长, double 基础攻击力系数, double 基础系数等级成长, bool isMagic = true, MagicType magicType = MagicType.None) : base(skill)
+        public 基于攻击力的伤害_带基础伤害(Skill skill, double 基础数值伤害, double 基础伤害等级成长, double 基础攻击力系数, double 基础系数等级成长, DamageType damageType = DamageType.Magical, MagicType magicType = MagicType.None) : base(skill)
         {
             GamingQueue = skill.GamingQueue;
             this.基础数值伤害 = 基础数值伤害;
             this.基础伤害等级成长 = 基础伤害等级成长;
             this.基础攻击力系数 = 基础攻击力系数;
             this.基础系数等级成长 = 基础系数等级成长;
-            IsMagic = isMagic;
+            DamageType = damageType;
             MagicType = magicType;
         }
 
@@ -33,7 +34,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
         {
             foreach (Character enemy in targets)
             {
-                DamageToEnemy(caster, enemy, IsMagic, MagicType, Damage);
+                DamageToEnemy(caster, enemy, DamageType, MagicType, Damage);
             }
         }
     }

OshimaModules/Effects/SkillEffects/基于攻击力的伤害_无基础伤害.cs

@@ -1,5 +1,6 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -7,20 +8,20 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"对目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}敌人造成 {ATKCoefficient * 100:0.##}% 攻击力 [ {Damage:0.##} ] 点{(IsMagic ? CharacterSet.GetMagicDamageName(MagicType) : "物理伤害")}。";
+        public override string Description => $"对{Skill.TargetDescription()}造成 {ATKCoefficient * 100:0.##}% 攻击力 [ {Damage:0.##} ] 点{CharacterSet.GetDamageTypeName(DamageType, MagicType)}。";
 
         private double ATKCoefficient => Skill.Level > 0 ? 基础攻击力系数 + 基础系数等级成长 * (Skill.Level - 1) : 基础攻击力系数;
         private double Damage => ATKCoefficient * Skill.Character?.ATK ?? 0;
         private double 基础攻击力系数 { get; set; } = 1.5;
         private double 基础系数等级成长 { get; set; } = 0.25;
-        private bool IsMagic { get; set; } = true;
+        private DamageType DamageType { get; set; } = DamageType.Magical;
 
-        public 基于攻击力的伤害_无基础伤害(Skill skill, double 基础攻击力系数, double 基础系数等级成长, bool isMagic = true, MagicType magicType = MagicType.None) : base(skill)
+        public 基于攻击力的伤害_无基础伤害(Skill skill, double 基础攻击力系数, double 基础系数等级成长, DamageType damageType = DamageType.Magical, MagicType magicType = MagicType.None) : base(skill)
         {
             GamingQueue = skill.GamingQueue;
             this.基础攻击力系数 = 基础攻击力系数;
             this.基础系数等级成长 = 基础系数等级成长;
-            IsMagic = isMagic;
+            DamageType = damageType;
             MagicType = magicType;
         }
 
@@ -28,7 +29,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
         {
             foreach (Character enemy in targets)
             {
-                DamageToEnemy(caster, enemy, IsMagic, MagicType, Damage);
+                DamageToEnemy(caster, enemy, DamageType, MagicType, Damage);
             }
         }
     }

OshimaModules/Effects/SkillEffects/基于核心属性的伤害.cs

@@ -1,5 +1,6 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -7,7 +8,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"对目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}敌人造成 {BaseDamage:0.##} + {AttributeCoefficient * 100:0.##}% {CharacterSet.GetPrimaryAttributeName(Skill.Character?.PrimaryAttribute ?? PrimaryAttribute.INT)} [ {Damage:0.##} ] 点{(IsMagic ? CharacterSet.GetMagicDamageName(MagicType) : "物理伤害")}。";
+        public override string Description => $"对{Skill.TargetDescription()}造成 {BaseDamage:0.##} + {AttributeCoefficient * 100:0.##}% {CharacterSet.GetPrimaryAttributeName(Skill.Character?.PrimaryAttribute ?? PrimaryAttribute.INT)} [ {Damage:0.##} ] 点{CharacterSet.GetDamageTypeName(DamageType, MagicType)}。";
 
         private double BaseDamage => Skill.Level > 0 ? 基础数值伤害 + 基础伤害等级成长 * (Skill.Level - 1) : 基础数值伤害;
         private double AttributeCoefficient => Skill.Level > 0 ? 基础属性系数 + 基础系数等级成长 * (Skill.Level - 1) : 基础属性系数;
@@ -16,16 +17,16 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
         private double 基础伤害等级成长 { get; set; } = 50;
         private double 基础属性系数 { get; set; } = 0.4;
         private double 基础系数等级成长 { get; set; } = 0.4;
-        private bool IsMagic { get; set; } = true;
+        private DamageType DamageType { get; set; } = DamageType.Magical;
 
-        public 基于核心属性的伤害(Skill skill, double 基础数值伤害, double 基础伤害等级成长, double 基础属性系数, double 基础系数等级成长, bool isMagic = true, MagicType magicType = MagicType.None) : base(skill)
+        public 基于核心属性的伤害(Skill skill, double 基础数值伤害, double 基础伤害等级成长, double 基础属性系数, double 基础系数等级成长, DamageType damageType = DamageType.Magical, MagicType magicType = MagicType.None) : base(skill)
         {
             GamingQueue = skill.GamingQueue;
             this.基础数值伤害 = 基础数值伤害;
             this.基础伤害等级成长 = 基础伤害等级成长;
             this.基础属性系数 = 基础属性系数;
             this.基础系数等级成长 = 基础系数等级成长;
-            IsMagic = isMagic;
+            DamageType = damageType;
             MagicType = magicType;
         }
 
@@ -33,7 +34,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
         {
             foreach (Character enemy in targets)
             {
-                DamageToEnemy(caster, enemy, IsMagic, MagicType, Damage);
+                DamageToEnemy(caster, enemy, DamageType, MagicType, Damage);
             }
         }
     }

OshimaModules/Effects/SkillEffects/增加混合护盾值.cs

@@ -1,5 +1,6 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -7,8 +8,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"为{TargetDescription}提供 {护盾值:0.##} 点混合护盾值。";
+        public override string Description => $"为{Skill.TargetDescription()}提供 {护盾值:0.##} 点混合护盾值。";
-        public string TargetDescription => Skill.SelectAllTeammates ? "友方全体角色" : $"目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}友方角色";
 
         private double 护盾值 => Level > 0 ? Math.Abs(基础数值护盾 + 基础护盾等级成长 * (Level - 1)) : Math.Abs(基础数值护盾);
         private double 基础数值护盾 { get; set; } = 200;

OshimaModules/Effects/SkillEffects/增加物理护盾_护盾值型.cs

@@ -1,5 +1,6 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -7,8 +8,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"为{TargetDescription}提供 {护盾值:0.##} 点物理护盾值。";
+        public override string Description => $"为{Skill.TargetDescription()}提供 {护盾值:0.##} 点物理护盾值。";
-        public string TargetDescription => Skill.SelectAllTeammates ? "友方全体角色" : $"目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}友方角色";
 
         private double 护盾值 => Level > 0 ? Math.Abs(基础数值护盾 + 基础护盾等级成长 * (Level - 1)) : Math.Abs(基础数值护盾);
         private double 基础数值护盾 { get; set; } = 200;

OshimaModules/Effects/SkillEffects/增加物理护盾_特效持续型.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.PassiveEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -8,8 +9,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"为{TargetDescription}提供 {护盾值:0.##} 点物理护盾，持续 {持续时间}。";
+        public override string Description => $"为{Skill.TargetDescription()}提供 {护盾值:0.##} 点物理护盾，持续 {持续时间}。";
-        public string TargetDescription => Skill.SelectAllTeammates ? "友方全体角色" : $"目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}友方角色";
 
         private string 持续时间 => _durative && _duration > 0 ? _duration + $" {GameplayEquilibriumConstant.InGameTime}" : (!_durative && _durationTurn > 0 ? _durationTurn + " 回合" : $"0 {GameplayEquilibriumConstant.InGameTime}");
         private double 护盾值 => Level > 0 ? Math.Abs(基础数值护盾 + 基础护盾等级成长 * (Level - 1)) : Math.Abs(基础数值护盾);

OshimaModules/Effects/SkillEffects/增加魔法护盾_护盾值型.cs

@@ -1,5 +1,6 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -7,8 +8,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"为{TargetDescription}提供 {护盾值:0.##} 点魔法护盾值。";
+        public override string Description => $"为{Skill.TargetDescription()}提供 {护盾值:0.##} 点魔法护盾值。";
-        public string TargetDescription => Skill.SelectAllTeammates ? "友方全体角色" : $"目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}友方角色";
 
         private double 护盾值 => Level > 0 ? Math.Abs(基础数值护盾 + 基础护盾等级成长 * (Level - 1)) : Math.Abs(基础数值护盾);
         private double 基础数值护盾 { get; set; } = 200;

OshimaModules/Effects/SkillEffects/增加魔法护盾_特效持续型.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.PassiveEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -8,8 +9,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"为{TargetDescription}提供 {护盾值:0.##} 点魔法护盾，持续 {持续时间}。";
+        public override string Description => $"为{Skill.TargetDescription()}提供 {护盾值:0.##} 点魔法护盾，持续 {持续时间}。";
-        public string TargetDescription => Skill.SelectAllTeammates ? "友方全体角色" : $"目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}友方角色";
 
         private string 持续时间 => _durative && _duration > 0 ? _duration + $" {GameplayEquilibriumConstant.InGameTime}" : (!_durative && _durationTurn > 0 ? _durationTurn + " 回合" : $"0 {GameplayEquilibriumConstant.InGameTime}");
         private double 护盾值 => Level > 0 ? Math.Abs(基础数值护盾 + 基础护盾等级成长 * (Level - 1)) : Math.Abs(基础数值护盾);

OshimaModules/Effects/SkillEffects/弱驱散特效.cs

@@ -1,5 +1,6 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -7,22 +8,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"弱驱散{TargetDescription}。";
+        public override string Description => $"弱驱散{Skill.TargetDescription()}。";
-        public string TargetDescription
-        {
-            get
-            {
-                if (Skill.SelectAllTeammates)
-                {
-                    return "友方全体角色";
-                }
-                else if (Skill.SelectAllEnemies)
-                {
-                    return "敌方全体角色";
-                }
-                return $"{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}目标";
-            }
-        }
         public override DispelType DispelType => DispelType.Weak;
 
         public 弱驱散特效(Skill skill) : base(skill)

OshimaModules/Effects/SkillEffects/强驱散特效.cs

@@ -1,5 +1,6 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -7,22 +8,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"强驱散{TargetDescription}。";
+        public override string Description => $"强驱散{Skill.TargetDescription()}。";
-        public string TargetDescription
-        {
-            get
-            {
-                if (Skill.SelectAllTeammates)
-                {
-                    return "友方全体角色";
-                }
-                else if (Skill.SelectAllEnemies)
-                {
-                    return "敌方全体角色";
-                }
-                return $"{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}目标";
-            }
-        }
         public override DispelType DispelType => DispelType.Strong;
 
         public 强驱散特效(Skill skill) : base(skill)

OshimaModules/Effects/SkillEffects/提升友方行动速度.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.OpenEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -8,7 +9,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"提升目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}友方角色 {SPD:0.##} 点行动速度 {持续时间}。并缩短目标 30% 的行动等待时间（当前硬直时间）。";
+        public override string Description => $"提升{Skill.TargetDescription()} {SPD:0.##} 点行动速度 {持续时间}。并缩短目标 30% 的行动等待时间（当前硬直时间）。";
 
         private double SPD => Level > 0 ? Math.Abs(基础数值速度 + 基础速度等级成长 * (Level - 1)) : Math.Abs(基础数值速度);
         private double 基础数值速度 { get; set; } = 65;

OshimaModules/Effects/SkillEffects/施加持续性弱驱散.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.PassiveEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -8,7 +9,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"持续弱驱散{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}目标{(_durativeWithoutDuration ? _durationString : $"，持续 {持续时间}")}。\r\n持续性驱散是持续性临时驱散，它会在持续时间结束之后恢复目标尚未结束的特效。";
+        public override string Description => $"持续弱驱散{Skill.TargetDescription()}{(_durativeWithoutDuration ? _durationString : $"，持续 {持续时间}")}。\r\n持续性驱散是持续性临时驱散，它会在持续时间结束之后恢复目标尚未结束的特效。";
         public override DispelType DispelType => DispelType.DurativeWeak;
 
         private string 持续时间 => _durative && _duration > 0 ? 实际持续时间 + $" {GameplayEquilibriumConstant.InGameTime}" : (!_durative && _durationTurn > 0 ? 实际持续时间 + " 回合" : $"0 {GameplayEquilibriumConstant.InGameTime}");

OshimaModules/Effects/SkillEffects/施加持续性强驱散.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.PassiveEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -8,7 +9,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"持续强驱散{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}目标{(_durativeWithoutDuration ? _durationString : $"，持续 {持续时间}")}。\r\n持续性驱散是持续性临时驱散，它会在持续时间结束之后恢复目标尚未结束的特效。";
+        public override string Description => $"持续强驱散{Skill.TargetDescription()}{(_durativeWithoutDuration ? _durationString : $"，持续 {持续时间}")}。\r\n持续性驱散是持续性临时驱散，它会在持续时间结束之后恢复目标尚未结束的特效。";
         public override DispelType DispelType => DispelType.DurativeStrong;
 
         private string 持续时间 => _durative && _duration > 0 ? 实际持续时间 + $" {GameplayEquilibriumConstant.InGameTime}" : (!_durative && _durationTurn > 0 ? 实际持续时间 + " 回合" : $"0 {GameplayEquilibriumConstant.InGameTime}");

OshimaModules/Effects/SkillEffects/百分比回复生命值.cs

@@ -1,4 +1,5 @@
 using Milimoe.FunGame.Core.Entity;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -6,7 +7,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"为{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}目标回复其最大生命值 {百分比 * 100:0.##}% 生命值。{(CanRespawn ? "如果目标已死亡，将复活目标。" : "")}";
+        public override string Description => $"为{Skill.TargetDescription()}回复 {百分比 * 100:0.##}% 最大生命值。{(CanRespawn ? "如果目标已死亡，将复活目标。" : "")}";
 
         private double 基础回复 { get; set; } = 0.03;
         private double 回复成长 { get; set; } = 0.03;

OshimaModules/Effects/SkillEffects/纯数值伤害.cs

@@ -1,5 +1,6 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -7,19 +8,19 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"对目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}敌人造成 {Damage:0.##} 点{(IsMagic ? CharacterSet.GetMagicDamageName(MagicType) : "物理伤害")}。";
+        public override string Description => $"对{Skill.TargetDescription()}造成 {Damage:0.##} 点{CharacterSet.GetDamageTypeName(DamageType, MagicType)}。";
 
         private double Damage => Skill.Level > 0 ? 基础数值伤害 + 基础伤害等级成长 * (Skill.Level - 1) : 基础数值伤害;
         private double 基础数值伤害 { get; set; } = 200;
         private double 基础伤害等级成长 { get; set; } = 100;
-        private bool IsMagic { get; set; } = true;
+        private DamageType DamageType { get; set; } = DamageType.Magical;
 
-        public 纯数值伤害(Skill skill, double 基础数值伤害, double 基础伤害等级成长, bool isMagic = true, MagicType magicType = MagicType.None) : base(skill)
+        public 纯数值伤害(Skill skill, double 基础数值伤害, double 基础伤害等级成长, DamageType damageType, MagicType magicType = MagicType.None) : base(skill)
         {
             GamingQueue = skill.GamingQueue;
             this.基础数值伤害 = 基础数值伤害;
             this.基础伤害等级成长 = 基础伤害等级成长;
-            IsMagic = isMagic;
+            DamageType = damageType;
             MagicType = magicType;
         }
 
@@ -27,7 +28,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
         {
             foreach (Character enemy in targets)
             {
-                DamageToEnemy(caster, enemy, IsMagic, MagicType, Damage);
+                DamageToEnemy(caster, enemy, DamageType, MagicType, Damage);
             }
         }
     }

OshimaModules/Effects/SkillEffects/纯数值回复生命值.cs

@@ -1,4 +1,5 @@
 using Milimoe.FunGame.Core.Entity;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -6,7 +7,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"为{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}目标回复 {Heal:0.##} 点生命值。{(CanRespawn ? "如果目标已死亡，将复活目标。" : "")}";
+        public override string Description => $"为{Skill.TargetDescription()}回复 {Heal:0.##} 点生命值。{(CanRespawn ? "如果目标已死亡，将复活目标。" : "")}";
 
         private double Heal => Skill.Level > 0 ? 基础回复 + 回复成长 * (Skill.Level - 1) : 基础回复;
         private double 基础回复 { get; set; } = 100;

OshimaModules/Effects/SkillEffects/造成封技.cs

@@ -1,5 +1,6 @@
 using Milimoe.FunGame.Core.Entity;
 using Oshima.FunGame.OshimaModules.Effects.PassiveEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -7,7 +8,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"对目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}敌人造成封技 {封技时间}，无法使用技能（魔法、战技和爆发技），并打断当前施法。";
+        public override string Description => $"对{Skill.TargetDescription()}造成封技 {封技时间}，无法使用技能（魔法、战技和爆发技），并打断当前施法。";
 
         private string 封技时间 => _durative && _duration > 0 ? 实际封技时间 + $" {GameplayEquilibriumConstant.InGameTime}" : (!_durative && _durationTurn > 0 ? 实际封技时间 + " 回合" : $"0 {GameplayEquilibriumConstant.InGameTime}");
         private double 实际封技时间 => _durative && _duration > 0 ? _duration + _levelGrowth * (Level - 1) : (!_durative && _durationTurn > 0 ? _durationTurn + _levelGrowth * (Level - 1) : 0);

OshimaModules/Effects/SkillEffects/造成气绝.cs

@@ -41,7 +41,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
             foreach (Character enemy in targets)
             {
                 WriteLine($"[ {caster} ] 对 [ {enemy} ] 造成了气绝！持续时间：{气绝时间}！");
-                气绝 e = new(Skill, enemy, caster, _durative, _duration, _durationTurn, _isPercentage, _durationDamage, _durationDamagePercent);
+                气绝 e = new(Skill, enemy, caster, _durative, _duration + _levelGrowth * (Level - 1), Convert.ToInt32(_durationTurn + _levelGrowth * (Level - 1)), _isPercentage, _durationDamage, _durationDamagePercent);
                 enemy.Effects.Add(e);
                 e.OnEffectGained(enemy);
                 GamingQueue?.LastRound.ApplyEffects.TryAdd(enemy, [e.EffectType]);

OshimaModules/Effects/SkillEffects/造成眩晕.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.PassiveEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -8,7 +9,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"对目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}敌人造成眩晕 {眩晕时间}。";
+        public override string Description => $"对{Skill.TargetDescription()}造成眩晕 {眩晕时间}。";
         public override DispelledType DispelledType => DispelledType.Strong;
 
         private string 眩晕时间 => _durative && _duration > 0 ? 实际眩晕时间 + $" {GameplayEquilibriumConstant.InGameTime}" : (!_durative && _durationTurn > 0 ? 实际眩晕时间 + " 回合" : $"0 {GameplayEquilibriumConstant.InGameTime}");

OshimaModules/Effects/SkillEffects/造成虚弱.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.PassiveEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -8,10 +9,9 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"对{TargetDescription}造成虚弱 {虚弱时间}，伤害降低 {ActualDamageReductionPercent * 100:0.##}%，" +
+        public override string Description => $"对{Skill.TargetDescription()}造成虚弱 {虚弱时间}，伤害降低 {ActualDamageReductionPercent * 100:0.##}%，" +
             $"物理护甲降低 {ActualDEFReductionPercent * 100:0.##}%，魔法抗性降低 {ActualMDFReductionPercent * 100:0.##}%，治疗效果降低 {ActualHealingReductionPercent * 100:0.##}%。";
         public override DispelledType DispelledType => DispelledType.Weak;
-        public string TargetDescription => Skill.SelectAllEnemies ? "敌方全体角色" : $"目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}敌人";
 
         private string 虚弱时间 => _durative && _duration > 0 ? 实际虚弱时间 + $" {GameplayEquilibriumConstant.InGameTime}" : (!_durative && _durationTurn > 0 ? 实际虚弱时间 + " 回合" : $"0 {GameplayEquilibriumConstant.InGameTime}");
         private double 实际虚弱时间 => _durative && _duration > 0 ? _duration + _levelGrowth * (Level - 1) : (!_durative && _durationTurn > 0 ? _durationTurn + _levelGrowth * (Level - 1) : 0);

OshimaModules/Effects/SkillEffects/降低敌方行动速度.cs

@@ -1,6 +1,7 @@
 using Milimoe.FunGame.Core.Entity;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Effects.OpenEffects;
+using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
 {
@@ -8,7 +9,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.SkillEffects
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"降低目标{(Skill.CanSelectTargetCount > 1 ? $"至多 {Skill.CanSelectTargetCount} 个" : "")}敌人 {Math.Abs(SPD):0.##} 点行动速度 {持续时间}。并延长目标 30% 的行动等待时间（当前硬直时间）。";
+        public override string Description => $"降低{Skill.TargetDescription()} {Math.Abs(SPD):0.##} 点行动速度 {持续时间}。并延长目标 30% 的行动等待时间（当前硬直时间）。";
 
         private double SPD => Level > 0 ? -Math.Abs(基础数值速度 + 基础速度等级成长 * (Level - 1)) : -Math.Abs(基础数值速度);
         private double 基础数值速度 { get; set; } = 30;

OshimaModules/Items/Accessory/攻击之爪.cs

@@ -5,16 +5,16 @@ using Oshima.FunGame.OshimaModules.Skills;
 
 namespace Oshima.FunGame.OshimaModules.Items
 {
-    public class 攻击之爪8 : Item
+    public class 攻击之爪10 : Item
     {
-        public override long Id => (long)AccessoryID.攻击之爪8;
+        public override long Id => (long)AccessoryID.攻击之爪10;
-        public override string Name => "攻击之爪 +8";
+        public override string Name => "攻击之爪 +10";
         public override string Description => Skills.Passives.Count > 0 ? Skills.Passives.First().Description : "";
         public override QualityType QualityType => QualityType.White;
 
-        public 攻击之爪8(Character? character = null) : base(ItemType.Accessory)
+        public 攻击之爪10(Character? character = null) : base(ItemType.Accessory)
         {
-            Skills.Passives.Add(new 攻击之爪技能(character, this, 8));
+            Skills.Passives.Add(new 攻击之爪技能(character, this, 10));
         }
     }
 
@@ -31,29 +31,29 @@ namespace Oshima.FunGame.OshimaModules.Items
         }
     }
 
-    public class 攻击之爪35 : Item
+    public class 攻击之爪30 : Item
     {
-        public override long Id => (long)AccessoryID.攻击之爪35;
+        public override long Id => (long)AccessoryID.攻击之爪30;
-        public override string Name => "攻击之爪 +35";
+        public override string Name => "攻击之爪 +30";
         public override string Description => Skills.Passives.Count > 0 ? Skills.Passives.First().Description : "";
         public override QualityType QualityType => QualityType.Blue;
 
-        public 攻击之爪35(Character? character = null) : base(ItemType.Accessory)
+        public 攻击之爪30(Character? character = null) : base(ItemType.Accessory)
         {
-            Skills.Passives.Add(new 攻击之爪技能(character, this, 35));
+            Skills.Passives.Add(new 攻击之爪技能(character, this, 30));
         }
     }
 
-    public class 攻击之爪50 : Item
+    public class 攻击之爪40 : Item
     {
-        public override long Id => (long)AccessoryID.攻击之爪50;
+        public override long Id => (long)AccessoryID.攻击之爪40;
-        public override string Name => "攻击之爪 +50";
+        public override string Name => "攻击之爪 +40";
         public override string Description => Skills.Passives.Count > 0 ? Skills.Passives.First().Description : "";
         public override QualityType QualityType => QualityType.Purple;
 
-        public 攻击之爪50(Character? character = null) : base(ItemType.Accessory)
+        public 攻击之爪40(Character? character = null) : base(ItemType.Accessory)
         {
-            Skills.Passives.Add(new 攻击之爪技能(character, this, 50));
+            Skills.Passives.Add(new 攻击之爪技能(character, this, 40));
         }
     }
 

OshimaModules/Items/Consumable/回复药.cs

@@ -12,11 +12,10 @@ namespace Oshima.FunGame.OshimaModules.Items
             public double HP { get; set; }
         }
 
-        public static void Init(Item item, double exp, int remainUseTimes = 1)
+        public static void Init(Item item, double hp, int remainUseTimes = 1, bool isPercentage = false)
         {
-            item.Skills.Active = new 回复药技能(item, exp);
+            item.Skills.Active = new 回复药技能(item, hp, isPercentage);
             item.RemainUseTimes = remainUseTimes;
-            item.IsInGameItem = false;
             item.IsReduceTimesAfterUse = true;
             item.IsRemoveAfterUse = true;
         }
@@ -130,20 +129,54 @@ namespace Oshima.FunGame.OshimaModules.Items
         }
     }
 
+    public class 全回复药 : Item, 回复药.HPRecovery
+    {
+        public override long Id => (long)ConsumableID.全回复药;
+        public override string Name => "全回复药";
+        public override string Description => Skills.Active?.Description ?? "";
+        public override QualityType QualityType => QualityType.Purple;
+        public double HP { get; set; } = 1;
+
+        public 全回复药(User? user = null, int remainUseTimes = 1) : base(ItemType.Consumable)
+        {
+            User = user;
+            回复药.Init(this, HP, remainUseTimes, true);
+        }
+
+        protected override bool OnItemUsed(User user, Dictionary<string, object> args)
+        {
+            return 回复药.OnItemUsed(user, this, args);
+        }
+    }
+
     public class 回复药技能 : Skill
     {
         public override long Id => (long)ItemActiveID.回复药;
         public override string Name => "回复药";
-        public override string Description => Effects.Count > 0 ? Effects.First().Description : "";
+        public override string Description => string.Join("", Effects.Select(e => e.Description));
+        public override bool CanSelectSelf => true;
+        public override bool CanSelectTeammate => true;
+        public override bool CanSelectEnemy => false;
+        public override int CanSelectTargetCount => 1;
 
-        public 回复药技能(Item? item = null, double hp = 0) : base(SkillType.Item)
+        public 回复药技能(Item? item = null, double hp = 0, bool isPercentage = false) : base(SkillType.Item)
         {
             Level = 1;
             Item = item;
+            if (!isPercentage)
+            {
                 Effects.Add(new RecoverHP(this, new()
                 {
                     { "hp", hp }
                 }));
             }
+            else
+            {
+                Effects.Add(new RecoverHP2(this, new()
+                {
+                    { "hp", hp }
+                }));
+            }
+        }
     }
 }

OshimaModules/Items/Consumable/复苏药.cs

@@ -0,0 +1,181 @@
+using Milimoe.FunGame.Core.Entity;
+using Milimoe.FunGame.Core.Library.Constant;
+using Oshima.FunGame.OshimaModules.Effects.ItemEffects;
+using Oshima.FunGame.OshimaModules.Effects.SkillEffects;
+using Oshima.FunGame.OshimaModules.Skills;
+
+namespace Oshima.FunGame.OshimaModules.Items
+{
+    public class 复苏药
+    {
+        public interface HPRecovery
+        {
+            public double HP { get; set; }
+        }
+
+        public static void Init(Item item, double hp, int remainUseTimes = 1, bool isPercentage = false)
+        {
+            item.Skills.Active = new 复苏药技能(item, hp, isPercentage);
+            item.RemainUseTimes = remainUseTimes;
+            item.IsReduceTimesAfterUse = true;
+            item.IsRemoveAfterUse = true;
+        }
+
+        public static string UseItem(User user, Item item, Character character)
+        {
+            if (item.Skills.Active != null)
+            {
+                item.Skills.Active.OnSkillCasted(user, [character]);
+                string msg = $"对角色 [ {character} ] 使用 [ {item.Name} ] 成功！";
+                if (item is HPRecovery hpBook)
+                {
+                    msg += $"回复了 {hpBook.HP} 点生命值！";
+                }
+                return msg;
+            }
+            return "此物品没有主动技能，无法被使用！";
+        }
+
+        public static bool OnItemUsed(User user, Item item, Dictionary<string, object> args)
+        {
+            string msg = "";
+            bool result = false;
+            Character[] targets = [];
+            string key = args.Keys.FirstOrDefault(s => s.Equals("targets", StringComparison.CurrentCultureIgnoreCase)) ?? "";
+            if (key != "" && args.TryGetValue(key, out object? value) && value is Character[] temp)
+            {
+                if (temp.Length > 0)
+                {
+                    targets = [temp[0]];
+                    msg = UseItem(user, item, temp[0]);
+                    result = true;
+                }
+                else
+                {
+                    msg = $"使用物品失败，没有作用目标！";
+                }
+            }
+            args["msg"] = msg;
+            key = args.Keys.FirstOrDefault(s => s.Equals("useCount", StringComparison.CurrentCultureIgnoreCase)) ?? "";
+            if (key != "" && args.TryGetValue(key, out value) && value is int count && targets.Length > 0)
+            {
+                string truemsg = $"对角色 [ {targets[0]} ] 使用 {count} 个 [ {item.Name} ] 成功！";
+                if (item is HPRecovery expBook)
+                {
+                    truemsg += $"回复了 {expBook.HP * count} 点生命值！";
+                }
+                args["truemsg"] = truemsg;
+            }
+            return result;
+        }
+    }
+
+    public class 复苏药1 : Item, 复苏药.HPRecovery
+    {
+        public override long Id => (long)ConsumableID.复苏药1;
+        public override string Name => "复苏药";
+        public override string Description => Skills.Active?.Description ?? "";
+        public override QualityType QualityType => QualityType.Green;
+        public double HP { get; set; } = 500;
+
+        public 复苏药1(User? user = null, int remainUseTimes = 1) : base(ItemType.Consumable)
+        {
+            User = user;
+            复苏药.Init(this, HP, remainUseTimes);
+        }
+
+        protected override bool OnItemUsed(User user, Dictionary<string, object> args)
+        {
+            return 复苏药.OnItemUsed(user, this, args);
+        }
+    }
+
+    public class 复苏药2 : Item, 复苏药.HPRecovery
+    {
+        public override long Id => (long)ConsumableID.复苏药2;
+        public override string Name => "复苏药·改";
+        public override string Description => Skills.Active?.Description ?? "";
+        public override QualityType QualityType => QualityType.Blue;
+        public double HP { get; set; } = 2500;
+
+        public 复苏药2(User? user = null, int remainUseTimes = 1) : base(ItemType.Consumable)
+        {
+            User = user;
+            复苏药.Init(this, HP, remainUseTimes);
+        }
+
+        protected override bool OnItemUsed(User user, Dictionary<string, object> args)
+        {
+            return 复苏药.OnItemUsed(user, this, args);
+        }
+    }
+
+    public class 复苏药3 : Item, 复苏药.HPRecovery
+    {
+        public override long Id => (long)ConsumableID.复苏药3;
+        public override string Name => "复苏药·全";
+        public override string Description => Skills.Active?.Description ?? "";
+        public override QualityType QualityType => QualityType.Purple;
+        public double HP { get; set; } = 1;
+
+        public 复苏药3(User? user = null, int remainUseTimes = 1) : base(ItemType.Consumable)
+        {
+            User = user;
+            复苏药.Init(this, HP, remainUseTimes, true);
+        }
+
+        protected override bool OnItemUsed(User user, Dictionary<string, object> args)
+        {
+            return 复苏药.OnItemUsed(user, this, args);
+        }
+    }
+
+    public class 复苏药技能 : Skill
+    {
+        public override long Id => (long)ItemActiveID.复苏药;
+        public override string Name => "复苏药";
+        public override string Description => string.Join("", Effects.Select(e => e.Description));
+        public override bool SelectAllTeammates => _canSelectAllTeammates;
+        public override bool SelectAllEnemies => _canSelectAllEnemies;
+        public override bool CanSelectSelf => _canSelectSelf;
+        public override bool CanSelectTeammate => _canSelectTeammate;
+        public override bool CanSelectEnemy => _canSelectEnemy;
+        public override int CanSelectTargetCount => _canSelectCount;
+
+        private readonly bool _canSelectAllTeammates;
+        private readonly bool _canSelectAllEnemies;
+        private readonly bool _canSelectSelf;
+        private readonly bool _canSelectTeammate;
+        private readonly bool _canSelectEnemy;
+        private readonly int _canSelectCount;
+
+        public 复苏药技能(Item? item = null, double hp = 0, bool isPercentage = false, bool canSelectAllTeammates = false, bool canSelectAllEnemies = false, bool canSelectSelf = true, bool canSelectTeammate = true, bool canSelectEnemy = false, int canSelectCount = 1) : base(SkillType.Item)
+        {
+            Level = 1;
+            Item = item;
+            _canSelectAllTeammates = canSelectAllTeammates;
+            _canSelectAllEnemies = canSelectAllEnemies;
+            _canSelectSelf = canSelectSelf;
+            _canSelectTeammate = canSelectTeammate;
+            _canSelectEnemy = canSelectEnemy;
+            _canSelectCount = canSelectCount;
+            Effects.Add(new 强驱散特效(this));
+            if (!isPercentage)
+            {
+                Effects.Add(new RecoverHP(this, new()
+                {
+                    { "hp", hp },
+                    { "respawn", true }
+                }));
+            }
+            else
+            {
+                Effects.Add(new RecoverHP2(this, new()
+                {
+                    { "hp", hp },
+                    { "respawn", true }
+                }));
+            }
+        }
+    }
+}

OshimaModules/Items/Consumable/能量饮料.cs

@@ -12,11 +12,10 @@ namespace Oshima.FunGame.OshimaModules.Items
             public double EP { get; set; }
         }
 
-        public static void Init(Item item, double exp, int remainUseTimes = 1)
+        public static void Init(Item item, double ep, int remainUseTimes = 1)
         {
-            item.Skills.Active = new 能量饮料技能(item, exp);
+            item.Skills.Active = new 能量饮料技能(item, ep);
             item.RemainUseTimes = remainUseTimes;
-            item.IsInGameItem = false;
             item.IsReduceTimesAfterUse = true;
             item.IsRemoveAfterUse = true;
         }
@@ -134,7 +133,11 @@ namespace Oshima.FunGame.OshimaModules.Items
     {
         public override long Id => (long)ItemActiveID.能量饮料;
         public override string Name => "能量饮料";
-        public override string Description => Effects.Count > 0 ? Effects.First().Description : "";
+        public override string Description => string.Join("", Effects.Select(e => e.Description));
+        public override bool CanSelectSelf => true;
+        public override bool CanSelectTeammate => true;
+        public override bool CanSelectEnemy => false;
+        public override int CanSelectTargetCount => 1;
 
         public 能量饮料技能(Item? item = null, double ep = 0) : base(SkillType.Item)
         {

OshimaModules/Items/Consumable/魔力填充剂.cs

@@ -12,11 +12,10 @@ namespace Oshima.FunGame.OshimaModules.Items
             public double MP { get; set; }
         }
 
-        public static void Init(Item item, double exp, int remainUseTimes = 1)
+        public static void Init(Item item, double mp, int remainUseTimes = 1, bool isPercentage = false)
         {
-            item.Skills.Active = new 魔力填充剂技能(item, exp);
+            item.Skills.Active = new 魔力填充剂技能(item, mp, isPercentage);
             item.RemainUseTimes = remainUseTimes;
-            item.IsInGameItem = false;
             item.IsReduceTimesAfterUse = true;
             item.IsRemoveAfterUse = true;
         }
@@ -134,16 +133,30 @@ namespace Oshima.FunGame.OshimaModules.Items
     {
         public override long Id => (long)ItemActiveID.魔力填充剂;
         public override string Name => "魔力填充剂";
-        public override string Description => Effects.Count > 0 ? Effects.First().Description : "";
+        public override string Description => string.Join("", Effects.Select(e => e.Description));
+        public override bool CanSelectSelf => true;
+        public override bool CanSelectTeammate => true;
+        public override bool CanSelectEnemy => false;
+        public override int CanSelectTargetCount => 1;
 
-        public 魔力填充剂技能(Item? item = null, double mp = 0) : base(SkillType.Item)
+        public 魔力填充剂技能(Item? item = null, double mp = 0, bool isPercentage = false) : base(SkillType.Item)
         {
             Level = 1;
             Item = item;
+            if (!isPercentage)
+            {
                 Effects.Add(new RecoverMP(this, new()
                 {
                     { "mp", mp }
                 }));
             }
+            else
+            {
+                Effects.Add(new RecoverMP2(this, new()
+                {
+                    { "mp", mp }
+                }));
+            }
+        }
     }
 }

OshimaModules/Items/ItemID.cs

@@ -2,10 +2,10 @@
 {
     public enum AccessoryID : long
     {
-        攻击之爪8 = 14001,
+        攻击之爪10 = 14001,
         攻击之爪20 = 14002,
-        攻击之爪35 = 14003,
+        攻击之爪30 = 14003,
-        攻击之爪50 = 14004,
+        攻击之爪40 = 14004,
     }
 
     public enum ConsumableID : long
@@ -22,6 +22,10 @@
         能量饮料1 = 15010,
         能量饮料2 = 15011,
         能量饮料3 = 15012,
+        复苏药1 = 15013,
+        复苏药2 = 15014,
+        复苏药3 = 15015,
+        全回复药 = 15016
     }
 
     public enum SpecialItemID : long

OshimaModules/Modules/ItemModule.cs

@@ -35,10 +35,10 @@ namespace Oshima.FunGame.OshimaModules
             {
                 return id switch
                 {
-                    (long)AccessoryID.攻击之爪8 => new 攻击之爪8(),
+                    (long)AccessoryID.攻击之爪10 => new 攻击之爪10(),
                     (long)AccessoryID.攻击之爪20 => new 攻击之爪20(),
-                    (long)AccessoryID.攻击之爪35 => new 攻击之爪35(),
+                    (long)AccessoryID.攻击之爪30 => new 攻击之爪30(),
-                    (long)AccessoryID.攻击之爪50 => new 攻击之爪50(),
+                    (long)AccessoryID.攻击之爪40 => new 攻击之爪40(),
                     (long)ConsumableID.小经验书 => new 小经验书(),
                     (long)ConsumableID.中经验书 => new 中经验书(),
                     (long)ConsumableID.大经验书 => new 大经验书(),

OshimaModules/Skills/ColdBlue/累积之压.cs

@@ -37,7 +37,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             return !是否是嵌套伤害;
         }
 
-        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult)
+        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult)
         {
             if (character == Skill.Character && actualDamage > 0 && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical) && !是否是嵌套伤害 && enemy.HP > 0)
             {
@@ -70,7 +70,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
                         e3.OnEffectGained(enemy);
                     }
                     是否是嵌套伤害 = true;
-                    DamageToEnemy(character, enemy, false, magicType, 额外伤害);
+                    DamageToEnemy(character, enemy, DamageType.Physical, magicType, 额外伤害);
                 }
                 else
                 {

OshimaModules/Skills/MagicalGirl/毁灭之势.cs

@@ -31,7 +31,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
         private double 累计伤害 = 0;
         private double 下一次提升 = 7;
 
-        public override double AlterActualDamageAfterCalculation(Character character, Character enemy, double damage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult, ref bool isEvaded, Dictionary<Effect, double> totalDamageBonus)
+        public override double AlterActualDamageAfterCalculation(Character character, Character enemy, double damage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult, ref bool isEvaded, Dictionary<Effect, double> totalDamageBonus)
         {
             if ((damageResult == DamageResult.Normal || damageResult == DamageResult.Critical) && character == Skill.Character)
             {
@@ -43,7 +43,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             return 0;
         }
 
-        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult)
+        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult)
         {
             if ((damageResult == DamageResult.Normal || damageResult == DamageResult.Critical) && enemy == Skill.Character && actualDamage > 0 && !enemy.Effects.Where(e => e is 绝对领域特效).Any())
             {

OshimaModules/Skills/MagicalGirl/绝对领域.cs

@@ -47,7 +47,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             character.ExAGI -= 实际敏捷提升;
         }
 
-        public override double AlterActualDamageAfterCalculation(Character character, Character enemy, double damage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult, ref bool isEvaded, Dictionary<Effect, double> totalDamageBonus)
+        public override double AlterActualDamageAfterCalculation(Character character, Character enemy, double damage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult, ref bool isEvaded, Dictionary<Effect, double> totalDamageBonus)
         {
             if (enemy == Skill.Character && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical))
             {

OshimaModules/Skills/NanGanyu/灵能反射.cs

@@ -31,9 +31,9 @@ namespace Oshima.FunGame.OshimaModules.Skills
         public int 释放次数 { get; set; } = 0;
         public double 获得额外能量值 => 0.15 * Skill.Character?.INT ?? 0;
 
-        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult)
+        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult)
         {
-            if (character == Skill.Character && (是否支持普攻 && isNormalAttack || isMagicDamage) && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical) && character.EP < 200)
+            if (character == Skill.Character && (是否支持普攻 && isNormalAttack || damageType == DamageType.Magical) && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical) && character.EP < 200)
             {
                 double 实际获得能量值 = 获得额外能量值;
                 character.EP += 实际获得能量值;

OshimaModules/Skills/NiuNan/变幻之心.cs

@@ -108,9 +108,9 @@ namespace Oshima.FunGame.OshimaModules.Skills
             当前魔法加成次数 = 0;
         }
 
-        public override double AlterExpectedDamageBeforeCalculation(Character character, Character enemy, double damage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, Dictionary<Effect, double> totalDamageBonus)
+        public override double AlterExpectedDamageBeforeCalculation(Character character, Character enemy, double damage, bool isNormalAttack, DamageType damageType, MagicType magicType, Dictionary<Effect, double> totalDamageBonus)
         {
-            if (character == Skill.Character && isMagicDamage && 当前魔法加成次数 > 0)
+            if (character == Skill.Character && damageType == DamageType.Magical && 当前魔法加成次数 > 0)
             {
                 当前魔法加成次数--;
                 double 实际伤害提升百分比 = 伤害提升;
@@ -126,7 +126,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             return 0;
         }
 
-        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult)
+        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult)
         {
             if (character == Skill.Character && 当前吸血次数 > 0 && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical) && damage > 0)
             {

OshimaModules/Skills/Oshima/力量爆发.cs

@@ -47,7 +47,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             character.ExATK2 -= 实际攻击力加成;
         }
 
-        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult)
+        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult)
         {
             if (character == Skill.Character && isNormalAttack)
             {

OshimaModules/Skills/QWQAQW/破釜沉舟.cs

@@ -67,7 +67,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             return 系数 * damage;
         }
 
-        public override double AlterExpectedDamageBeforeCalculation(Character character, Character enemy, double damage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, Dictionary<Effect, double> totalDamageBonus)
+        public override double AlterExpectedDamageBeforeCalculation(Character character, Character enemy, double damage, bool isNormalAttack, DamageType damageType, MagicType magicType, Dictionary<Effect, double> totalDamageBonus)
         {
             if (character == Skill.Character)
             {
@@ -94,7 +94,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             return 0;
         }
 
-        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult)
+        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult)
         {
             if (enemy == Skill.Character && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical))
             {

OshimaModules/Skills/QWQAQW/迅捷之势.cs

@@ -56,7 +56,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             实际魔法抗性 = 0;
         }
 
-        public override double AlterExpectedDamageBeforeCalculation(Character character, Character enemy, double damage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, Dictionary<Effect, double> totalDamageBonus)
+        public override double AlterExpectedDamageBeforeCalculation(Character character, Character enemy, double damage, bool isNormalAttack, DamageType damageType, MagicType magicType, Dictionary<Effect, double> totalDamageBonus)
         {
             if (character == Skill.Character && isNormalAttack)
             {

OshimaModules/Skills/QingXiang/枯竭打击.cs

@@ -28,7 +28,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
 
         private bool 是否是嵌套伤害 = false;
 
-        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult)
+        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult)
         {
             if (character == Skill.Character && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical) && !是否是嵌套伤害 && enemy.HP > 0)
             {
@@ -42,7 +42,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
                     double 额外伤害 = damage * 0.3;
                     WriteLine($"[ {character} ] 发动了枯竭打击！将造成额外伤害！");
                     是否是嵌套伤害 = true;
-                    DamageToEnemy(character, enemy, isMagicDamage, magicType, 额外伤害);
+                    DamageToEnemy(character, enemy, damageType, magicType, 额外伤害);
                 }
             }
 

OshimaModules/Skills/QingXiang/能量毁灭.cs

@@ -47,7 +47,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             {
                 WriteLine($"[ {caster} ] 正在毁灭 [ {c} ] 的能量！！");
                 double ep = c.EP;
-                DamageToEnemy(caster, c, true, MagicType, ep * 能量系数 + 智力伤害);
+                DamageToEnemy(caster, c, DamageType.Magical, MagicType, ep * 能量系数 + 智力伤害);
             }
         }
     }

OshimaModules/Skills/QuDuoduo/弱者猎手.cs

@@ -28,7 +28,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
 
         public HashSet<Character> 猎手标记 { get; set; } = [];
 
-        public override double AlterExpectedDamageBeforeCalculation(Character character, Character enemy, double damage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, Dictionary<Effect, double> totalDamageBonus)
+        public override double AlterExpectedDamageBeforeCalculation(Character character, Character enemy, double damage, bool isNormalAttack, DamageType damageType, MagicType magicType, Dictionary<Effect, double> totalDamageBonus)
         {
             if (character == Skill.Character && 猎手标记.Contains(enemy))
             {

OshimaModules/Skills/QuDuoduo/血之狂欢.cs

@@ -30,7 +30,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
         public override double Duration => 30;
         public override DispelledType DispelledType => DispelledType.CannotBeDispelled;
 
-        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult)
+        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult)
         {
             if (character == Skill.Character && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical) && character.HP < character.MaxHP)
             {

OshimaModules/Skills/SkillExtension.cs

@@ -0,0 +1,31 @@
+using Milimoe.FunGame.Core.Entity;
+
+namespace Oshima.FunGame.OshimaModules.Skills
+{
+    public static class SkillExtension
+    {
+        public static string TargetDescription(this Skill skill)
+        {
+            if (skill.SelectAllTeammates)
+            {
+                return "友方全体角色";
+            }
+            else if (skill.SelectAllEnemies)
+            {
+                return "敌方全体角色";
+            }
+            if (skill.CanSelectTeammate && !skill.CanSelectEnemy)
+            {
+                return $"目标{(skill.CanSelectTargetCount > 1 ? $"至多 {skill.CanSelectTargetCount} 个" : "")}友方角色";
+            }
+            else if (!skill.CanSelectTeammate && skill.CanSelectEnemy)
+            {
+                return $"目标{(skill.CanSelectTargetCount > 1 ? $"至多 {skill.CanSelectTargetCount} 个" : "")}敌方角色";
+            }
+            else
+            {
+                return $"{(skill.CanSelectTargetCount > 1 ? $"至多 {skill.CanSelectTargetCount} 个" : "")}目标";
+            }
+        }
+    }
+}

OshimaModules/Skills/SkillID.cs

@@ -108,6 +108,7 @@
         回复药 = 6002,
         魔力填充剂 = 6003,
         能量饮料 = 6004,
-        礼包 = 6005
+        礼包 = 6005,
+        复苏药 = 6006
     }
 }

OshimaModules/Skills/XinYin/天赐之力.cs

@@ -65,7 +65,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             return CharacterActionType.None;
         }
 
-        public override double AlterExpectedDamageBeforeCalculation(Character character, Character enemy, double damage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, Dictionary<Effect, double> totalDamageBonus)
+        public override double AlterExpectedDamageBeforeCalculation(Character character, Character enemy, double damage, bool isNormalAttack, DamageType damageType, MagicType magicType, Dictionary<Effect, double> totalDamageBonus)
         {
             if (character == Skill.Character && isNormalAttack)
             {

OshimaModules/Skills/XinYin/心灵之火.cs

@@ -31,7 +31,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
         public double 基础冷却时间 { get; set; } = 12;
         private bool 是否是嵌套普通攻击 = false;
 
-        public override double AlterActualDamageAfterCalculation(Character character, Character enemy, double damage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult, ref bool isEvaded, Dictionary<Effect, double> totalDamageBonus)
+        public override double AlterActualDamageAfterCalculation(Character character, Character enemy, double damage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult, ref bool isEvaded, Dictionary<Effect, double> totalDamageBonus)
         {
             if (character == Skill.Character && 是否是嵌套普通攻击 && isNormalAttack && damage > 0)
             {
@@ -40,7 +40,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             return 0;
         }
 
-        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult)
+        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult)
         {
             if (character == Skill.Character && isNormalAttack && 冷却时间 == 0 && !是否是嵌套普通攻击 && GamingQueue != null && enemy.HP > 0)
             {

OshimaModules/Skills/Yang/魔法涌流.cs

@@ -56,7 +56,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             }
         }
 
-        public override double AlterActualDamageAfterCalculation(Character character, Character enemy, double damage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult, ref bool isEvaded, Dictionary<Effect, double> totalDamageBonus)
+        public override double AlterActualDamageAfterCalculation(Character character, Character enemy, double damage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult, ref bool isEvaded, Dictionary<Effect, double> totalDamageBonus)
         {
             if (enemy == Skill.Character)
             {

OshimaModules/Skills/Yang/魔法震荡.cs

@@ -34,7 +34,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
         private static double 系数 => 4;
         private double 伤害加成 => 系数 * Skill.Character?.STR ?? 0;
 
-        public override double AlterExpectedDamageBeforeCalculation(Character character, Character enemy, double damage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, Dictionary<Effect, double> totalDamageBonus)
+        public override double AlterExpectedDamageBeforeCalculation(Character character, Character enemy, double damage, bool isNormalAttack, DamageType damageType, MagicType magicType, Dictionary<Effect, double> totalDamageBonus)
         {
             if (character == Skill.Character && (
                 enemy.CharacterState == CharacterState.NotActionable ||
@@ -48,9 +48,9 @@ namespace Oshima.FunGame.OshimaModules.Skills
             return 0;
         }
 
-        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult)
+        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult)
         {
-            if (character == Skill.Character && isMagicDamage && actualDamage > 0 && 冷却时间 == 0 && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical))
+            if (character == Skill.Character && damageType == DamageType.Magical && actualDamage > 0 && 冷却时间 == 0 && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical))
             {
                 IEnumerable<Effect> effects = enemy.Effects.Where(e => e is 眩晕 && e.Skill == Skill);
                 if (effects.Any())

OshimaModules/Skills/dddovo/敏捷之刃.cs

@@ -30,13 +30,13 @@ namespace Oshima.FunGame.OshimaModules.Skills
         private readonly double 敏捷系数 = 2.5;
         private bool 是否是嵌套伤害 = false;
 
-        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult)
+        public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult)
         {
             if (character == Skill.Character && isNormalAttack && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical) && !是否是嵌套伤害 && enemy.HP > 0)
             {
                 WriteLine($"[ {character} ] 发动了敏捷之刃！将造成额外伤害！");
                 是否是嵌套伤害 = true;
-                DamageToEnemy(character, enemy, true, magicType, 敏捷伤害);
+                DamageToEnemy(character, enemy, DamageType.Magical, magicType, 敏捷伤害);
             }
 
             if (character == Skill.Character && 是否是嵌套伤害)

OshimaModules/Skills/战技/疾风步.cs

@@ -59,7 +59,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             character.ExCritRate -= 0.08;
         }
 
-        public override double AlterActualDamageAfterCalculation(Character character, Character enemy, double damage, bool isNormalAttack, bool isMagicDamage, MagicType magicType, DamageResult damageResult, ref bool isEvaded, Dictionary<Effect, double> totalDamageBonus)
+        public override double AlterActualDamageAfterCalculation(Character character, Character enemy, double damage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult, ref bool isEvaded, Dictionary<Effect, double> totalDamageBonus)
         {
             if (character == Skill.Character && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical) && 首次伤害)
             {

OshimaModules/Skills/魔法/暗物质.cs

@@ -16,7 +16,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
 
         public 暗物质(Character? character = null) : base(SkillType.Magic, character)
         {
-            Effects.Add(new 基于攻击力的伤害_无基础伤害(this, 1.3, 0.28, true));
+            Effects.Add(new 基于攻击力的伤害_无基础伤害(this, 1.3, 0.28));
         }
     }
 }

OshimaModules/Skills/魔法/混沌烙印.cs

@@ -18,7 +18,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
 
         public 混沌烙印(Character? character = null) : base(SkillType.Magic, character)
         {
-            Effects.Add(new 造成气绝(this, true, 6, 0, 1.5, true, 0, 0.3));
+            Effects.Add(new 造成气绝(this, true, 4, 0, 0.5, true, 0, 0.3));
         }
     }
 }

OshimaModules/configs/oshima-studios/oshima.fungame.items.json

@@ -1326,7 +1326,7 @@
   "YukiのCalfSocks": {
     "Id": 14510,
     "Name": "YukiのCalfSocks",
-    "Description": "增加角色 15% 暴击率和 30% 暴击伤害。",
+    "Description": "增加角色 10% 暴击率和 25% 暴击伤害。",
     "BackgroundStory": "小雪的小腿袜，拥有神秘的力量，令人神往。",
     "ItemType": 4,
     "WeaponType": 0,
@@ -1341,11 +1341,11 @@
           "Effects": [
             {
               "Id": 8014,
-              "excr": 0.15
+              "excr": 0.1
             },
             {
               "Id": 8015,
-              "excrd": 0.3
+              "excrd": 0.25
             }
           ]
         }
@@ -1477,7 +1477,7 @@
   "YukiのCalfSocks-圣诞限定": {
     "Id": 14515,
     "Name": "YukiのCalfSocks-圣诞限定",
-    "Description": "增加角色 50% 暴击伤害。",
+    "Description": "增加角色 40% 暴击伤害。",
     "BackgroundStory": "小雪的圣诞限定小腿袜，结合了圣诞树的红绿色，还有铃铛和鹿角的装饰。",
     "ItemType": 4,
     "WeaponType": 0,
@@ -1492,7 +1492,7 @@
           "Effects": [
             {
               "Id": 8015,
-              "excrd": 0.5
+              "excrd": 0.4
             }
           ]
         }

OshimaServers/FastAutoServer.cs

@@ -263,11 +263,11 @@ namespace Oshima.FunGame.OshimaServers
                         totalStats.TotalDamage = Calculation.Round2Digits(totalStats.TotalDamage + stats.TotalDamage);
                         totalStats.TotalPhysicalDamage = Calculation.Round2Digits(totalStats.TotalPhysicalDamage + stats.TotalPhysicalDamage);
                         totalStats.TotalMagicDamage = Calculation.Round2Digits(totalStats.TotalMagicDamage + stats.TotalMagicDamage);
-                        totalStats.TotalRealDamage = Calculation.Round2Digits(totalStats.TotalRealDamage + stats.TotalRealDamage);
+                        totalStats.TotalTrueDamage = Calculation.Round2Digits(totalStats.TotalTrueDamage + stats.TotalTrueDamage);
                         totalStats.TotalTakenDamage = Calculation.Round2Digits(totalStats.TotalTakenDamage + stats.TotalTakenDamage);
                         totalStats.TotalTakenPhysicalDamage = Calculation.Round2Digits(totalStats.TotalTakenPhysicalDamage + stats.TotalTakenPhysicalDamage);
                         totalStats.TotalTakenMagicDamage = Calculation.Round2Digits(totalStats.TotalTakenMagicDamage + stats.TotalTakenMagicDamage);
-                        totalStats.TotalTakenRealDamage = Calculation.Round2Digits(totalStats.TotalTakenRealDamage + stats.TotalTakenRealDamage);
+                        totalStats.TotalTakenTrueDamage = Calculation.Round2Digits(totalStats.TotalTakenTrueDamage + stats.TotalTakenTrueDamage);
                         totalStats.LiveRound += stats.LiveRound;
                         totalStats.ActionTurn += stats.ActionTurn;
                         totalStats.LiveTime = Calculation.Round2Digits(totalStats.LiveTime + stats.LiveTime);
@@ -287,11 +287,11 @@ namespace Oshima.FunGame.OshimaServers
                             totalStats.AvgDamage = Calculation.Round2Digits(totalStats.TotalDamage / totalStats.Plays);
                             totalStats.AvgPhysicalDamage = Calculation.Round2Digits(totalStats.TotalPhysicalDamage / totalStats.Plays);
                             totalStats.AvgMagicDamage = Calculation.Round2Digits(totalStats.TotalMagicDamage / totalStats.Plays);
-                            totalStats.AvgRealDamage = Calculation.Round2Digits(totalStats.TotalRealDamage / totalStats.Plays);
+                            totalStats.AvgTrueDamage = Calculation.Round2Digits(totalStats.TotalTrueDamage / totalStats.Plays);
                             totalStats.AvgTakenDamage = Calculation.Round2Digits(totalStats.TotalTakenDamage / totalStats.Plays);
                             totalStats.AvgTakenPhysicalDamage = Calculation.Round2Digits(totalStats.TotalTakenPhysicalDamage / totalStats.Plays);
                             totalStats.AvgTakenMagicDamage = Calculation.Round2Digits(totalStats.TotalTakenMagicDamage / totalStats.Plays);
-                            totalStats.AvgTakenRealDamage = Calculation.Round2Digits(totalStats.TotalTakenRealDamage / totalStats.Plays);
+                            totalStats.AvgTakenTrueDamage = Calculation.Round2Digits(totalStats.TotalTakenTrueDamage / totalStats.Plays);
                             totalStats.AvgLiveRound = totalStats.LiveRound / totalStats.Plays;
                             totalStats.AvgActionTurn = totalStats.ActionTurn / totalStats.Plays;
                             totalStats.AvgLiveTime = Calculation.Round2Digits(totalStats.LiveTime / totalStats.Plays);
@@ -339,7 +339,7 @@ namespace Oshima.FunGame.OshimaServers
             {
                 foreach (Character character in queue.Queue)
                 {
-                    这次发放的空投 = [new 攻击之爪35()];
+                    这次发放的空投 = [new 攻击之爪20()];
                     foreach (Item item in 这次发放的空投)
                     {
                         queue.Equip(character, EquipSlotType.Accessory1, item, out _);

OshimaServers/Service/FunGameActionQueue.cs

@@ -175,6 +175,7 @@ namespace Oshima.FunGame.OshimaServers.Service
                     mvpBuilder.AppendLine($"控制时长：{stats.ControlTime:0.##} / 总计治疗：{stats.TotalHeal:0.##} / 护盾抵消：{stats.TotalShield:0.##}");
                     mvpBuilder.AppendLine($"总计伤害：{stats.TotalDamage:0.##} / 总计物理伤害：{stats.TotalPhysicalDamage:0.##} / 总计魔法伤害：{stats.TotalMagicDamage:0.##}");
                     mvpBuilder.AppendLine($"总承受伤害：{stats.TotalTakenDamage:0.##} / 总承受物理伤害：{stats.TotalTakenPhysicalDamage:0.##} / 总承受魔法伤害：{stats.TotalTakenMagicDamage:0.##}");
+                    if (stats.TotalTrueDamage > 0 || stats.TotalTakenTrueDamage > 0) mvpBuilder.AppendLine($"总计真实伤害：{stats.TotalTrueDamage:0.##} / 总承受真实伤害：{stats.TotalTakenTrueDamage:0.##}");
                     mvpBuilder.Append($"每秒伤害：{stats.DamagePerSecond:0.##} / 每回合伤害：{stats.DamagePerTurn:0.##}");
                 }
 
@@ -192,6 +193,7 @@ namespace Oshima.FunGame.OshimaServers.Service
                     builder.AppendLine($"控制时长：{stats.ControlTime:0.##} / 总计治疗：{stats.TotalHeal:0.##} / 护盾抵消：{stats.TotalShield:0.##}");
                     builder.AppendLine($"总计伤害：{stats.TotalDamage:0.##} / 总计物理伤害：{stats.TotalPhysicalDamage:0.##} / 总计魔法伤害：{stats.TotalMagicDamage:0.##}");
                     builder.AppendLine($"总承受伤害：{stats.TotalTakenDamage:0.##} / 总承受物理伤害：{stats.TotalTakenPhysicalDamage:0.##} / 总承受魔法伤害：{stats.TotalTakenMagicDamage:0.##}");
+                    if (stats.TotalTrueDamage > 0 || stats.TotalTakenTrueDamage > 0) builder.AppendLine($"总计真实伤害：{stats.TotalTrueDamage:0.##} / 总承受真实伤害：{stats.TotalTakenTrueDamage:0.##}");
                     builder.AppendLine($"每秒伤害：{stats.DamagePerSecond:0.##} / 每回合伤害：{stats.DamagePerTurn:0.##}");
                     builder.Append($"生命值：{character.HP:0.##}/{character.MaxHP:0.##} / 魔法值：{character.MP:0.##}/{character.MaxMP:0.##}");
                     if (count++ <= top)
@@ -386,6 +388,7 @@ namespace Oshima.FunGame.OshimaServers.Service
                         mvpBuilder.AppendLine($"控制时长：{stats.ControlTime:0.##} / 总计治疗：{stats.TotalHeal:0.##} / 护盾抵消：{stats.TotalShield:0.##}");
                         mvpBuilder.AppendLine($"总计伤害：{stats.TotalDamage:0.##} / 总计物理伤害：{stats.TotalPhysicalDamage:0.##} / 总计魔法伤害：{stats.TotalMagicDamage:0.##}");
                         mvpBuilder.AppendLine($"总承受伤害：{stats.TotalTakenDamage:0.##} / 总承受物理伤害：{stats.TotalTakenPhysicalDamage:0.##} / 总承受魔法伤害：{stats.TotalTakenMagicDamage:0.##}");
+                        if (stats.TotalTrueDamage > 0 || stats.TotalTakenTrueDamage > 0) mvpBuilder.AppendLine($"总计真实伤害：{stats.TotalTrueDamage:0.##} / 总承受真实伤害：{stats.TotalTakenTrueDamage:0.##}");
                         mvpBuilder.Append($"每秒伤害：{stats.DamagePerSecond:0.##} / 每回合伤害：{stats.DamagePerTurn:0.##}");
                     }
 

OshimaServers/Service/FunGameService.cs

@@ -44,11 +44,13 @@ namespace Oshima.FunGame.OshimaServers.Service
 
             Dictionary<string, Item> exItems = Factory.GetGameModuleInstances<Item>(OshimaGameModuleConstant.General, OshimaGameModuleConstant.Item);
             FunGameConstant.Equipment.AddRange(exItems.Values.Where(i => (int)i.ItemType >= 0 && (int)i.ItemType < 5));
-            FunGameConstant.Equipment.AddRange([new 攻击之爪8(), new 攻击之爪20(), new 攻击之爪35(), new 攻击之爪50()]);
+            FunGameConstant.Equipment.AddRange([new 攻击之爪10(), new 攻击之爪20(), new 攻击之爪30(), new 攻击之爪40()]);
 
             FunGameConstant.Items.AddRange(exItems.Values.Where(i => (int)i.ItemType > 4));
             FunGameConstant.Items.AddRange([new 小经验书(), new 中经验书(), new 大经验书(), new 升华之印(), new 流光之印(), new 永恒之印(), new 技能卷轴(), new 智慧之果(), new 奥术符文(), new 混沌之核(),
-                new 小回复药(), new 中回复药(), new 大回复药(), new 魔力填充剂1(), new 魔力填充剂2(), new 魔力填充剂3(), new 能量饮料1(), new 能量饮料2(), new 能量饮料3(), new 年夜饭(), new 蛇年大吉(), new 新春快乐(), new 毕业礼包()]);
+                new 小回复药(), new 中回复药(), new 大回复药(), new 魔力填充剂1(), new 魔力填充剂2(), new 魔力填充剂3(), new 能量饮料1(), new 能量饮料2(), new 能量饮料3(), new 年夜饭(), new 蛇年大吉(), new 新春快乐(), new 毕业礼包(),
+                new 复苏药1(), new 复苏药2(), new 复苏药3(), new 全回复药()
+            ]);
 
             FunGameConstant.AllItems.AddRange(FunGameConstant.Equipment);
             FunGameConstant.AllItems.AddRange(FunGameConstant.Items);

OshimaServers/Service/FunGameSimulation.cs

@@ -421,6 +421,7 @@ namespace Oshima.FunGame.OshimaServers.Service
                         mvpBuilder.AppendLine($"控制时长：{stats.ControlTime:0.##} / 总计治疗：{stats.TotalHeal:0.##} / 护盾抵消：{stats.TotalShield:0.##}");
                         mvpBuilder.AppendLine($"总计伤害：{stats.TotalDamage:0.##} / 总计物理伤害：{stats.TotalPhysicalDamage:0.##} / 总计魔法伤害：{stats.TotalMagicDamage:0.##}");
                         mvpBuilder.AppendLine($"总承受伤害：{stats.TotalTakenDamage:0.##} / 总承受物理伤害：{stats.TotalTakenPhysicalDamage:0.##} / 总承受魔法伤害：{stats.TotalTakenMagicDamage:0.##}");
+                        if (stats.TotalTrueDamage > 0 || stats.TotalTakenTrueDamage > 0) mvpBuilder.AppendLine($"总计真实伤害：{stats.TotalTrueDamage:0.##} / 总承受真实伤害：{stats.TotalTakenTrueDamage:0.##}");
                         mvpBuilder.Append($"每秒伤害：{stats.DamagePerSecond:0.##} / 每回合伤害：{stats.DamagePerTurn:0.##}");
                     }
 
@@ -483,6 +484,7 @@ namespace Oshima.FunGame.OshimaServers.Service
                             builder.AppendLine($"控制时长：{stats.ControlTime:0.##} / 总计治疗：{stats.TotalHeal:0.##} / 护盾抵消：{stats.TotalShield:0.##}");
                             builder.AppendLine($"总计伤害：{stats.TotalDamage:0.##} / 总计物理伤害：{stats.TotalPhysicalDamage:0.##} / 总计魔法伤害：{stats.TotalMagicDamage:0.##}");
                             builder.AppendLine($"总承受伤害：{stats.TotalTakenDamage:0.##} / 总承受物理伤害：{stats.TotalTakenPhysicalDamage:0.##} / 总承受魔法伤害：{stats.TotalTakenMagicDamage:0.##}");
+                            if (stats.TotalTrueDamage > 0 || stats.TotalTakenTrueDamage > 0) builder.AppendLine($"总计真实伤害：{stats.TotalTrueDamage:0.##} / 总承受真实伤害：{stats.TotalTakenTrueDamage:0.##}");
                             builder.Append($"每秒伤害：{stats.DamagePerSecond:0.##} / 每回合伤害：{stats.DamagePerTurn:0.##}");
                             if (count++ <= top)
                             {
@@ -515,6 +517,7 @@ namespace Oshima.FunGame.OshimaServers.Service
                             builder.AppendLine($"控制时长：{stats.ControlTime:0.##} / 总计治疗：{stats.TotalHeal:0.##} / 护盾抵消：{stats.TotalShield:0.##}");
                             builder.AppendLine($"总计伤害：{stats.TotalDamage:0.##} / 总计物理伤害：{stats.TotalPhysicalDamage:0.##} / 总计魔法伤害：{stats.TotalMagicDamage:0.##}");
                             builder.AppendLine($"总承受伤害：{stats.TotalTakenDamage:0.##} / 总承受物理伤害：{stats.TotalTakenPhysicalDamage:0.##} / 总承受魔法伤害：{stats.TotalTakenMagicDamage:0.##}");
+                            if (stats.TotalTrueDamage > 0 || stats.TotalTakenTrueDamage > 0) builder.AppendLine($"总计真实伤害：{stats.TotalTrueDamage:0.##} / 总承受真实伤害：{stats.TotalTakenTrueDamage:0.##}");
                             builder.Append($"每秒伤害：{stats.DamagePerSecond:0.##} / 每回合伤害：{stats.DamagePerTurn:0.##}");
                             if (count++ <= top)
                             {
@@ -849,7 +852,7 @@ namespace Oshima.FunGame.OshimaServers.Service
                                     {
                                         character.User.Inventory.Credits -= costLevel;
                                         operation["升级角色"] = true;
-                                        character.Level += 10;
+                                        character.SetLevel(character.Level + 10, false);
                                         character.NormalAttack.Level += 2;
                                         foreach (Skill skill in character.Skills)
                                         {
@@ -964,11 +967,16 @@ namespace Oshima.FunGame.OshimaServers.Service
 
         public static void DropItems(GamingQueue queue, int mQuality, int wQuality, int aQuality, int sQuality, int acQuality, bool addLevel = true)
         {
+            Item[] weapons = [.. FunGameConstant.Equipment.Where(i => i.Id.ToString().StartsWith("11") && (int)i.QualityType == wQuality)];
+            Item[] armors = [.. FunGameConstant.Equipment.Where(i => i.Id.ToString().StartsWith("12") && (int)i.QualityType == aQuality)];
+            Item[] shoes = [.. FunGameConstant.Equipment.Where(i => i.Id.ToString().StartsWith("13") && (int)i.QualityType == sQuality)];
+            Item[] accessories = [.. FunGameConstant.Equipment.Where(i => i.Id.ToString().StartsWith("14") && (int)i.QualityType == acQuality)];
+            Item[] consumables = [.. FunGameConstant.AllItems.Where(i => i.ItemType == ItemType.Consumable)];
             foreach (Character character in queue.HardnessTime.Keys)
             {
                 if (addLevel)
                 {
-                    character.Level += 10;
+                    character.SetLevel(character.Level + 10, false);
                     character.NormalAttack.Level += 2;
                     foreach (Skill skill in character.Skills)
                     {
@@ -1001,10 +1009,6 @@ namespace Oshima.FunGame.OshimaServers.Service
                 {
                     continue;
                 }
-                Item[] weapons = [.. FunGameConstant.Equipment.Where(i => i.Id.ToString().StartsWith("11") && (int)i.QualityType == wQuality)];
-                Item[] armors = [.. FunGameConstant.Equipment.Where(i => i.Id.ToString().StartsWith("12") && (int)i.QualityType == aQuality)];
-                Item[] shoes = [.. FunGameConstant.Equipment.Where(i => i.Id.ToString().StartsWith("13") && (int)i.QualityType == sQuality)];
-                Item[] accessories = [.. FunGameConstant.Equipment.Where(i => i.Id.ToString().StartsWith("14") && (int)i.QualityType == acQuality)];
                 Item? weapon = null, armor = null, shoe = null, accessory1 = null, accessory2 = null;
                 if (weapons.Length > 0)
                 {
@@ -1038,6 +1042,14 @@ namespace Oshima.FunGame.OshimaServers.Service
                     realItem.SetGamingQueue(queue);
                     queue.Equip(character, realItem);
                 }
+                if (consumables.Length > 0 && character.Items.Count < 5)
+                {
+                    for (int i = 0; i < 2; i++)
+                    {
+                        Item consumable = consumables[Random.Shared.Next(consumables.Length)].Copy();
+                        character.Items.Add(consumable);
+                    }
+                }
             }
         }
 
@@ -1047,11 +1059,11 @@ namespace Oshima.FunGame.OshimaServers.Service
             totalStats.TotalDamage = Calculation.Round2Digits(totalStats.TotalDamage + stats.TotalDamage);
             totalStats.TotalPhysicalDamage = Calculation.Round2Digits(totalStats.TotalPhysicalDamage + stats.TotalPhysicalDamage);
             totalStats.TotalMagicDamage = Calculation.Round2Digits(totalStats.TotalMagicDamage + stats.TotalMagicDamage);
-            totalStats.TotalRealDamage = Calculation.Round2Digits(totalStats.TotalRealDamage + stats.TotalRealDamage);
+            totalStats.TotalTrueDamage = Calculation.Round2Digits(totalStats.TotalTrueDamage + stats.TotalTrueDamage);
             totalStats.TotalTakenDamage = Calculation.Round2Digits(totalStats.TotalTakenDamage + stats.TotalTakenDamage);
             totalStats.TotalTakenPhysicalDamage = Calculation.Round2Digits(totalStats.TotalTakenPhysicalDamage + stats.TotalTakenPhysicalDamage);
             totalStats.TotalTakenMagicDamage = Calculation.Round2Digits(totalStats.TotalTakenMagicDamage + stats.TotalTakenMagicDamage);
-            totalStats.TotalTakenRealDamage = Calculation.Round2Digits(totalStats.TotalTakenRealDamage + stats.TotalTakenRealDamage);
+            totalStats.TotalTakenTrueDamage = Calculation.Round2Digits(totalStats.TotalTakenTrueDamage + stats.TotalTakenTrueDamage);
             totalStats.TotalHeal = Calculation.Round2Digits(totalStats.TotalHeal + stats.TotalHeal);
             totalStats.LiveRound += stats.LiveRound;
             totalStats.ActionTurn += stats.ActionTurn;
@@ -1080,11 +1092,11 @@ namespace Oshima.FunGame.OshimaServers.Service
                 totalStats.AvgDamage = Calculation.Round2Digits(totalStats.TotalDamage / totalStats.Plays);
                 totalStats.AvgPhysicalDamage = Calculation.Round2Digits(totalStats.TotalPhysicalDamage / totalStats.Plays);
                 totalStats.AvgMagicDamage = Calculation.Round2Digits(totalStats.TotalMagicDamage / totalStats.Plays);
-                totalStats.AvgRealDamage = Calculation.Round2Digits(totalStats.TotalRealDamage / totalStats.Plays);
+                totalStats.AvgTrueDamage = Calculation.Round2Digits(totalStats.TotalTrueDamage / totalStats.Plays);
                 totalStats.AvgTakenDamage = Calculation.Round2Digits(totalStats.TotalTakenDamage / totalStats.Plays);
                 totalStats.AvgTakenPhysicalDamage = Calculation.Round2Digits(totalStats.TotalTakenPhysicalDamage / totalStats.Plays);
                 totalStats.AvgTakenMagicDamage = Calculation.Round2Digits(totalStats.TotalTakenMagicDamage / totalStats.Plays);
-                totalStats.AvgTakenRealDamage = Calculation.Round2Digits(totalStats.TotalTakenRealDamage / totalStats.Plays);
+                totalStats.AvgTakenTrueDamage = Calculation.Round2Digits(totalStats.TotalTakenTrueDamage / totalStats.Plays);
                 totalStats.AvgHeal = Calculation.Round2Digits(totalStats.TotalHeal / totalStats.Plays);
                 totalStats.AvgLiveRound = totalStats.LiveRound / totalStats.Plays;
                 totalStats.AvgActionTurn = totalStats.ActionTurn / totalStats.Plays;

OshimaWebAPI/Controllers/FunGameController.cs

@@ -61,11 +61,11 @@ namespace Oshima.FunGame.WebAPI.Controllers
                     builder.AppendLine($"总计造成伤害：{stats.TotalDamage:0.##} / 场均：{stats.AvgDamage:0.##}");
                     builder.AppendLine($"总计造成物理伤害：{stats.TotalPhysicalDamage:0.##} / 场均：{stats.AvgPhysicalDamage:0.##}");
                     builder.AppendLine($"总计造成魔法伤害：{stats.TotalMagicDamage:0.##} / 场均：{stats.AvgMagicDamage:0.##}");
-                    builder.AppendLine($"总计造成真实伤害：{stats.TotalRealDamage:0.##} / 场均：{stats.AvgRealDamage:0.##}");
+                    builder.AppendLine($"总计造成真实伤害：{stats.TotalTrueDamage:0.##} / 场均：{stats.AvgTrueDamage:0.##}");
                     builder.AppendLine($"总计承受伤害：{stats.TotalTakenDamage:0.##} / 场均：{stats.AvgTakenDamage:0.##}");
                     builder.AppendLine($"总计承受物理伤害：{stats.TotalTakenPhysicalDamage:0.##} / 场均：{stats.AvgTakenPhysicalDamage:0.##}");
                     builder.AppendLine($"总计承受魔法伤害：{stats.TotalTakenMagicDamage:0.##} / 场均：{stats.AvgTakenMagicDamage:0.##}");
-                    builder.AppendLine($"总计承受真实伤害：{stats.TotalTakenRealDamage:0.##} / 场均：{stats.AvgTakenRealDamage:0.##}");
+                    builder.AppendLine($"总计承受真实伤害：{stats.TotalTakenTrueDamage:0.##} / 场均：{stats.AvgTakenTrueDamage:0.##}");
                     builder.AppendLine($"总计治疗：{stats.TotalHeal:0.##} / 场均：{stats.AvgHeal:0.##}");
                     builder.AppendLine($"总计存活回合数：{stats.LiveRound} / 场均：{stats.AvgLiveRound}");
                     builder.AppendLine($"总计行动回合数：{stats.ActionTurn} / 场均：{stats.AvgActionTurn}");
@@ -119,11 +119,11 @@ namespace Oshima.FunGame.WebAPI.Controllers
                     builder.AppendLine($"总计造成伤害：{stats.TotalDamage:0.##} / 场均：{stats.AvgDamage:0.##}");
                     builder.AppendLine($"总计造成物理伤害：{stats.TotalPhysicalDamage:0.##} / 场均：{stats.AvgPhysicalDamage:0.##}");
                     builder.AppendLine($"总计造成魔法伤害：{stats.TotalMagicDamage:0.##} / 场均：{stats.AvgMagicDamage:0.##}");
-                    builder.AppendLine($"总计造成真实伤害：{stats.TotalRealDamage:0.##} / 场均：{stats.AvgRealDamage:0.##}");
+                    builder.AppendLine($"总计造成真实伤害：{stats.TotalTrueDamage:0.##} / 场均：{stats.AvgTrueDamage:0.##}");
                     builder.AppendLine($"总计承受伤害：{stats.TotalTakenDamage:0.##} / 场均：{stats.AvgTakenDamage:0.##}");
                     builder.AppendLine($"总计承受物理伤害：{stats.TotalTakenPhysicalDamage:0.##} / 场均：{stats.AvgTakenPhysicalDamage:0.##}");
                     builder.AppendLine($"总计承受魔法伤害：{stats.TotalTakenMagicDamage:0.##} / 场均：{stats.AvgTakenMagicDamage:0.##}");
-                    builder.AppendLine($"总计承受真实伤害：{stats.TotalTakenRealDamage:0.##} / 场均：{stats.AvgTakenRealDamage:0.##}");
+                    builder.AppendLine($"总计承受真实伤害：{stats.TotalTakenTrueDamage:0.##} / 场均：{stats.AvgTakenTrueDamage:0.##}");
                     builder.AppendLine($"总计治疗：{stats.TotalHeal:0.##} / 场均：{stats.AvgHeal:0.##}");
                     builder.AppendLine($"总计存活回合数：{stats.LiveRound} / 场均：{stats.AvgLiveRound}");
                     builder.AppendLine($"总计行动回合数：{stats.ActionTurn} / 场均：{stats.AvgActionTurn}");

OshimaWebAPI/OshimaWebAPI.cs

@@ -121,7 +121,7 @@ namespace Oshima.FunGame.WebAPI
                                 user.Inventory.Characters.Add(character);
 
                                 // 测试物品
-                                Item item = new 攻击之爪50();
+                                Item item = new 攻击之爪20();
                                 user.Inventory.Items.Add(item);
 
                                 sql.UpdateInventory(user.Inventory); // 更新库存