技能、回合日志优化 (#138)

Entity/Character/Character.cs

@@ -1353,7 +1353,7 @@ namespace Milimoe.FunGame.Core.Entity
             double exATK = ExATK + ExATK2 + ExATK3;
             builder.AppendLine($"攻击力：{ATK:0.##}" + (exATK != 0 ? $" [{BaseATK:0.##} {(exATK >= 0 ? "+" : "-")} {Math.Abs(exATK):0.##}]" : ""));
             double exDEF = ExDEF + ExDEF2 + ExDEF3;
-            builder.AppendLine($"物理护甲：{DEF:0.##}" + (exDEF != 0 ? $" [{BaseDEF:0.##} {(exMP >= 0 ? "+" : "-")} {Math.Abs(exDEF):0.##}]" : "") + $" ({PDR * 100:0.##}%)");
+            builder.AppendLine($"物理护甲：{DEF:0.##}" + (exDEF != 0 ? $" [{BaseDEF:0.##} {(exDEF >= 0 ? "+" : "-")} {Math.Abs(exDEF):0.##}]" : "") + $" ({PDR * 100:0.##}%)");
             builder.AppendLine($"魔法抗性：{MDF.Avg:0.##}%（平均）");
             double exSPD = AGI * GameplayEquilibriumConstant.AGItoSPDMultiplier + ExSPD;
             builder.AppendLine($"行动速度：{SPD:0.##}" + (exSPD != 0 ? $" [{InitialSPD:0.##} {(exSPD >= 0 ? "+" : "-")} {Math.Abs(exSPD):0.##}]" : "") + $" ({ActionCoefficient * 100:0.##}%)");
@@ -1486,7 +1486,7 @@ namespace Milimoe.FunGame.Core.Entity
             double exATK = ExATK + ExATK2 + ExATK3;
             builder.AppendLine($"攻击力：{ATK:0.##}" + (exATK != 0 ? $" [{BaseATK:0.##} {(exATK >= 0 ? "+" : "-")} {Math.Abs(exATK):0.##}]" : ""));
             double exDEF = ExDEF + ExDEF2 + ExDEF3;
-            builder.AppendLine($"物理护甲：{DEF:0.##}" + (exDEF != 0 ? $" [{BaseDEF:0.##} {(exMP >= 0 ? "+" : "-")} {Math.Abs(exDEF):0.##}]" : "") + $" ({PDR * 100:0.##}%)");
+            builder.AppendLine($"物理护甲：{DEF:0.##}" + (exDEF != 0 ? $" [{BaseDEF:0.##} {(exDEF >= 0 ? "+" : "-")} {Math.Abs(exDEF):0.##}]" : "") + $" ({PDR * 100:0.##}%)");
             builder.AppendLine($"魔法抗性：{MDF.Avg:0.##}%（平均）");
             if (showBasicOnly)
             {
@@ -1732,7 +1732,7 @@ namespace Milimoe.FunGame.Core.Entity
             double exATK = ExATK + ExATK2 + ExATK3;
             builder.AppendLine($"攻击力：{ATK:0.##}" + (exATK != 0 ? $" [{BaseATK:0.##} {(exATK >= 0 ? "+" : "-")} {Math.Abs(exATK):0.##}]" : ""));
             double exDEF = ExDEF + ExDEF2 + ExDEF3;
-            builder.AppendLine($"物理护甲：{DEF:0.##}" + (exDEF != 0 ? $" [{BaseDEF:0.##} {(exMP >= 0 ? "+" : "-")} {Math.Abs(exDEF):0.##}]" : "") + $" ({PDR * 100:0.##}%)");
+            builder.AppendLine($"物理护甲：{DEF:0.##}" + (exDEF != 0 ? $" [{BaseDEF:0.##} {(exDEF >= 0 ? "+" : "-")} {Math.Abs(exDEF):0.##}]" : "") + $" ({PDR * 100:0.##}%)");
             builder.AppendLine($"魔法抗性：{MDF.Avg:0.##}%（平均）");
             double exSPD = AGI * GameplayEquilibriumConstant.AGItoSPDMultiplier + ExSPD;
             builder.AppendLine($"行动速度：{SPD:0.##}" + (exSPD != 0 ? $" [{InitialSPD:0.##} {(exSPD >= 0 ? "+" : "-")} {Math.Abs(exSPD):0.##}]" : "") + $" ({ActionCoefficient * 100:0.##}%)");
@@ -2028,8 +2028,10 @@ namespace Milimoe.FunGame.Core.Entity
             EP = c.EP;
             InitialATK = c.InitialATK;
             ExATK2 = c.ExATK2;
+            ExATKPercentage = c.ExATKPercentage;
             InitialDEF = c.InitialDEF;
             ExDEF2 = c.ExDEF2;
+            ExDEFPercentage = c.ExDEFPercentage;
             MDF = c.MDF.Copy();
             PhysicalPenetration = c.PhysicalPenetration;
             MagicalPenetration = c.MagicalPenetration;
@@ -2042,8 +2044,11 @@ namespace Milimoe.FunGame.Core.Entity
             InitialAGI = c.InitialAGI;
             InitialINT = c.InitialINT;
             ExSTR = c.ExSTR;
+            ExSTRPercentage = c.ExSTRPercentage;
             ExAGI = c.ExAGI;
+            ExAGIPercentage = c.ExAGIPercentage;
             ExINT = c.ExINT;
+            ExINTPercentage = c.ExINTPercentage;
             STRGrowth = c.STRGrowth;
             AGIGrowth = c.AGIGrowth;
             INTGrowth = c.INTGrowth;

Entity/Skill/Skill.cs

@@ -108,6 +108,16 @@ namespace Milimoe.FunGame.Core.Entity
         /// </summary>
         public virtual bool CanSelectTeammate { get; set; } = false;
 
+        /// <summary>
+        /// 选取所有敌对角色，优先级大于 <see cref="CanSelectTargetCount"/>
+        /// </summary>
+        public virtual bool SelectAllEnemies { get; set; } = false;
+
+        /// <summary>
+        /// 选取所有友方角色，优先级大于 <see cref="CanSelectTargetCount"/>，默认包含自身
+        /// </summary>
+        public virtual bool SelectAllTeammates { get; set; } = false;
+
         /// <summary>
         /// 可选取的作用目标数量
         /// </summary>
@@ -319,6 +329,9 @@ namespace Milimoe.FunGame.Core.Entity
                 selectable.AddRange(teammates);
             }
 
+            // 其他条件
+            selectable = [.. selectable.Where(c => SelectTargetPredicates.All(f => f(c)))];
+
             return selectable;
         }
 
@@ -333,12 +346,20 @@ namespace Milimoe.FunGame.Core.Entity
         {
             List<Character> tobeSelected = GetSelectableTargets(caster, enemys, teammates);
 
-            // 筛选出符合条件的角色
-            tobeSelected = [.. tobeSelected.Where(c => SelectTargetPredicates.All(f => f(c)))];
-
             List<Character> targets = [];
 
-            if (tobeSelected.Count <= CanSelectTargetCount)
+            if (SelectAllTeammates || SelectAllEnemies)
+            {
+                if (SelectAllTeammates)
+                {
+                    targets.AddRange(tobeSelected.Where(c => c == caster || teammates.Contains(c)));
+                }
+                if (SelectAllEnemies)
+                {
+                    targets.AddRange(tobeSelected.Where(enemys.Contains));
+                }
+            }
+            else if (tobeSelected.Count <= CanSelectTargetCount)
             {
                 targets.AddRange(tobeSelected);
             }

Entity/System/RoundRecord.cs

@@ -66,6 +66,7 @@ namespace Milimoe.FunGame.Core.Entity
                 builder.AppendLine(string.Join(" / ", GetTargetsState()));
                 if (DeathContinuousKilling.Count > 0) builder.AppendLine($"{string.Join("\r\n", DeathContinuousKilling)}");
                 if (ActorContinuousKilling.Count > 0) builder.AppendLine($"{string.Join("\r\n", ActorContinuousKilling)}");
+                if (Assists.Count > 0) builder.AppendLine($"本回合助攻：[ {string.Join(" ] / [ ", Assists)} ]");
             }
 
             if (ActionType == CharacterActionType.PreCastSkill && Skill != null)

Library/Common/JsonConverter/RoundRecordConverter.cs

@@ -0,0 +1,233 @@
+using System.Text.Json;
+using Milimoe.FunGame.Core.Api.Utility;
+using Milimoe.FunGame.Core.Entity;
+using Milimoe.FunGame.Core.Library.Common.Architecture;
+using Milimoe.FunGame.Core.Library.Constant;
+
+namespace Milimoe.FunGame.Core.Library.Common.JsonConverter
+{
+    public class RoundRecordConverter : BaseEntityConverter<RoundRecord>
+    {
+        public override RoundRecord NewInstance()
+        {
+            return new RoundRecord(0);
+        }
+
+        public override void ReadPropertyName(ref Utf8JsonReader reader, string propertyName, JsonSerializerOptions options, ref RoundRecord result, Dictionary<string, object> convertingContext)
+        {
+            switch (propertyName)
+            {
+                case nameof(RoundRecord.Round):
+                    result.Round = reader.GetInt32();
+                    break;
+                case nameof(RoundRecord.Actor):
+                    result.Actor = NetworkUtility.JsonDeserialize<Character>(ref reader, options) ?? Factory.GetCharacter();
+                    break;
+                case nameof(RoundRecord.Targets):
+                    List<Character> targets = NetworkUtility.JsonDeserialize<List<Character>>(ref reader, options) ?? [];
+                    result.Targets.AddRange(targets);
+                    break;
+                case nameof(RoundRecord.Damages):
+                    Dictionary<Guid, double> damagesGuid = NetworkUtility.JsonDeserialize<Dictionary<Guid, double>>(ref reader, options) ?? [];
+                    foreach (KeyValuePair<Guid, double> kvp in damagesGuid)
+                    {
+                        Character? character = FindCharacterByGuid(kvp.Key, result);
+                        if (character != null)
+                        {
+                            result.Damages[character] = kvp.Value;
+                        }
+                    }
+                    break;
+
+                case nameof(RoundRecord.ActionType):
+                    result.ActionType = (CharacterActionType)reader.GetInt32();
+                    break;
+                case nameof(RoundRecord.Skill):
+                    result.Skill = NetworkUtility.JsonDeserialize<Skill>(ref reader, options);
+                    break;
+                case nameof(RoundRecord.SkillCost):
+                    result.SkillCost = reader.GetString() ?? "";
+                    break;
+                case nameof(RoundRecord.Item):
+                    result.Item = NetworkUtility.JsonDeserialize<Item>(ref reader, options);
+                    break;
+                case nameof(RoundRecord.HasKill):
+                    result.HasKill = reader.GetBoolean();
+                    break;
+                case nameof(RoundRecord.Assists):
+                    List<Character> assists = NetworkUtility.JsonDeserialize<List<Character>>(ref reader, options) ?? [];
+                    result.Assists.AddRange(assists);
+                    break;
+
+                case nameof(RoundRecord.IsCritical):
+                    Dictionary<Guid, bool> isCriticalGuid = NetworkUtility.JsonDeserialize<Dictionary<Guid, bool>>(ref reader, options) ?? [];
+                    foreach (KeyValuePair<Guid, bool> kvp in isCriticalGuid)
+                    {
+                        Character? character = FindCharacterByGuid(kvp.Key, result);
+                        if (character != null)
+                        {
+                            result.IsCritical[character] = kvp.Value;
+                        }
+                    }
+                    break;
+                case nameof(RoundRecord.IsEvaded):
+                    Dictionary<Guid, bool> isEvadedGuid = NetworkUtility.JsonDeserialize<Dictionary<Guid, bool>>(ref reader, options) ?? [];
+                    foreach (KeyValuePair<Guid, bool> kvp in isEvadedGuid)
+                    {
+                        Character? character = FindCharacterByGuid(kvp.Key, result);
+                        if (character != null)
+                        {
+                            result.IsEvaded[character] = kvp.Value;
+                        }
+                    }
+                    break;
+                case nameof(RoundRecord.IsImmune):
+                    Dictionary<Guid, bool> isImmuneGuid = NetworkUtility.JsonDeserialize<Dictionary<Guid, bool>>(ref reader, options) ?? [];
+                    foreach (KeyValuePair<Guid, bool> kvp in isImmuneGuid)
+                    {
+                        Character? character = FindCharacterByGuid(kvp.Key, result);
+                        if (character != null)
+                        {
+                            result.IsImmune[character] = kvp.Value;
+                        }
+                    }
+                    break;
+                case nameof(RoundRecord.Heals):
+                    Dictionary<Guid, double> healsGuid = NetworkUtility.JsonDeserialize<Dictionary<Guid, double>>(ref reader, options) ?? [];
+                    foreach (KeyValuePair<Guid, double> kvp in healsGuid)
+                    {
+                        Character? character = FindCharacterByGuid(kvp.Key, result);
+                        if (character != null)
+                        {
+                            result.Heals[character] = kvp.Value;
+                        }
+                    }
+                    break;
+                case nameof(RoundRecord.Effects):
+                    Dictionary<Guid, Effect> effectsGuid = NetworkUtility.JsonDeserialize<Dictionary<Guid, Effect>>(ref reader, options) ?? [];
+                    foreach (KeyValuePair<Guid, Effect> kvp in effectsGuid)
+                    {
+                        Character? character = FindCharacterByGuid(kvp.Key, result);
+                        if (character != null)
+                        {
+                            result.Effects[character] = kvp.Value;
+                        }
+                    }
+                    break;
+                case nameof(RoundRecord.ApplyEffects):
+                    Dictionary<Guid, List<EffectType>> applyEffectsGuid = NetworkUtility.JsonDeserialize<Dictionary<Guid, List<EffectType>>>(ref reader, options) ?? [];
+                    result.ApplyEffects.Clear();
+                    foreach (KeyValuePair<Guid, List<EffectType>> kvp in applyEffectsGuid)
+                    {
+                        Character? character = FindCharacterByGuid(kvp.Key, result);
+                        if (character != null)
+                        {
+                            result.ApplyEffects[character] = kvp.Value;
+                        }
+                    }
+                    break;
+                case nameof(RoundRecord.ActorContinuousKilling):
+                    List<string> actorCK = NetworkUtility.JsonDeserialize<List<string>>(ref reader, options) ?? [];
+                    result.ActorContinuousKilling.AddRange(actorCK);
+                    break;
+                case nameof(RoundRecord.DeathContinuousKilling):
+                    List<string> deathCK = NetworkUtility.JsonDeserialize<List<string>>(ref reader, options) ?? [];
+                    result.DeathContinuousKilling.AddRange(deathCK);
+                    break;
+                case nameof(RoundRecord.CastTime):
+                    result.CastTime = reader.GetDouble();
+                    break;
+                case nameof(RoundRecord.HardnessTime):
+                    result.HardnessTime = reader.GetDouble();
+                    break;
+                case nameof(RoundRecord.RespawnCountdowns):
+                    Dictionary<Guid, double> respawnCountdownGuid = NetworkUtility.JsonDeserialize<Dictionary<Guid, double>>(ref reader, options) ?? [];
+                    foreach (KeyValuePair<Guid, double> kvp in respawnCountdownGuid)
+                    {
+                        Character? character = FindCharacterByGuid(kvp.Key, result);
+                        if (character != null)
+                        {
+                            result.RespawnCountdowns[character] = kvp.Value;
+                        }
+                    }
+                    break;
+                case nameof(RoundRecord.Respawns):
+                    List<Character> respawns = NetworkUtility.JsonDeserialize<List<Character>>(ref reader, options) ?? [];
+                    result.Respawns.AddRange(respawns);
+                    break;
+                case nameof(RoundRecord.RoundRewards):
+                    List<Skill> rewards = NetworkUtility.JsonDeserialize<List<Skill>>(ref reader, options) ?? [];
+                    result.RoundRewards.AddRange(rewards);
+                    break;
+                case nameof(RoundRecord.OtherMessages):
+                    List<string> messages = NetworkUtility.JsonDeserialize<List<string>>(ref reader, options) ?? [];
+                    result.OtherMessages.AddRange(messages);
+                    break;
+
+                default:
+                    reader.Skip();
+                    break;
+            }
+        }
+
+        public override void Write(Utf8JsonWriter writer, RoundRecord value, JsonSerializerOptions options)
+        {
+            writer.WriteStartObject();
+            writer.WriteNumber(nameof(RoundRecord.Round), value.Round);
+            writer.WritePropertyName(nameof(RoundRecord.Actor));
+            JsonSerializer.Serialize(writer, value.Actor, options);
+            writer.WritePropertyName(nameof(RoundRecord.Targets));
+            JsonSerializer.Serialize(writer, value.Targets, options);
+            writer.WritePropertyName(nameof(RoundRecord.Damages));
+            JsonSerializer.Serialize(writer, value.Damages.ToDictionary(kv => kv.Key.Guid, kv => kv.Value), options);
+            writer.WriteNumber(nameof(RoundRecord.ActionType), (int)value.ActionType);
+            writer.WritePropertyName(nameof(RoundRecord.Skill));
+            JsonSerializer.Serialize(writer, value.Skill, options);
+            writer.WriteString(nameof(RoundRecord.SkillCost), value.SkillCost);
+            writer.WritePropertyName(nameof(RoundRecord.Item));
+            JsonSerializer.Serialize(writer, value.Item, options);
+            writer.WriteBoolean(nameof(RoundRecord.HasKill), value.HasKill);
+            writer.WritePropertyName(nameof(RoundRecord.Assists));
+            JsonSerializer.Serialize(writer, value.Assists, options);
+            writer.WritePropertyName(nameof(RoundRecord.IsCritical));
+            JsonSerializer.Serialize(writer, value.IsCritical.ToDictionary(kv => kv.Key.Guid, kv => kv.Value), options);
+            writer.WritePropertyName(nameof(RoundRecord.IsEvaded));
+            JsonSerializer.Serialize(writer, value.IsEvaded.ToDictionary(kv => kv.Key.Guid, kv => kv.Value), options);
+            writer.WritePropertyName(nameof(RoundRecord.IsImmune));
+            JsonSerializer.Serialize(writer, value.IsImmune.ToDictionary(kv => kv.Key.Guid, kv => kv.Value), options);
+            writer.WritePropertyName(nameof(RoundRecord.Heals));
+            JsonSerializer.Serialize(writer, value.Heals.ToDictionary(kv => kv.Key.Guid, kv => kv.Value), options);
+            writer.WritePropertyName(nameof(RoundRecord.Effects));
+            JsonSerializer.Serialize(writer, value.Effects.ToDictionary(kv => kv.Key.Guid, kv => kv.Value), options);
+            writer.WritePropertyName(nameof(RoundRecord.ApplyEffects));
+            JsonSerializer.Serialize(writer, value.ApplyEffects.ToDictionary(kv => kv.Key.Guid, kv => kv.Value), options);
+            writer.WritePropertyName(nameof(RoundRecord.ActorContinuousKilling));
+            JsonSerializer.Serialize(writer, value.ActorContinuousKilling, options);
+            writer.WritePropertyName(nameof(RoundRecord.DeathContinuousKilling));
+            JsonSerializer.Serialize(writer, value.DeathContinuousKilling, options);
+            writer.WriteNumber(nameof(RoundRecord.CastTime), value.CastTime);
+            writer.WriteNumber(nameof(RoundRecord.HardnessTime), value.HardnessTime);
+            writer.WritePropertyName(nameof(RoundRecord.RespawnCountdowns));
+            JsonSerializer.Serialize(writer, value.RespawnCountdowns.ToDictionary(kv => kv.Key.Guid, kv => kv.Value), options);
+            writer.WritePropertyName(nameof(RoundRecord.Respawns));
+            JsonSerializer.Serialize(writer, value.Respawns, options);
+            writer.WritePropertyName(nameof(RoundRecord.RoundRewards));
+            JsonSerializer.Serialize(writer, value.RoundRewards, options);
+            writer.WritePropertyName(nameof(RoundRecord.OtherMessages));
+            JsonSerializer.Serialize(writer, value.OtherMessages, options);
+            writer.WriteEndObject();
+        }
+
+        private static Character? FindCharacterByGuid(Guid guid, RoundRecord record)
+        {
+            Character? character = record.Targets.FirstOrDefault(c => c.Guid == guid);
+            if (character != null) return character;
+            if (record.Actor != null && record.Actor.Guid == guid) return record.Actor;
+            character = record.Assists.FirstOrDefault(c => c.Guid == guid);
+            if (character != null) return character;
+            character = record.Respawns.FirstOrDefault(c => c.Guid == guid);
+            if (character != null) return character;
+            return null;
+        }
+    }
+}

Library/Constant/ConstantSet.cs

@@ -439,6 +439,7 @@ namespace Milimoe.FunGame.Core.Library.Constant
                 CharacterState.ActionRestricted => "角色现在行动受限",
                 CharacterState.BattleRestricted => "角色现在战斗不能",
                 CharacterState.SkillRestricted => "角色现在技能受限",
+                CharacterState.AttackRestricted => "角色现在攻击受限",
                 _ => "角色现在完全行动不能"
             };
         }
@@ -797,7 +798,7 @@ namespace Milimoe.FunGame.Core.Library.Constant
                 EffectType.AllImmune => false,
                 EffectType.EvadeBoost => false,
                 EffectType.Lifesteal => false,
-                EffectType.GrievousWound => false,
+                EffectType.GrievousWound => true,
                 _ => false
             };
         }

Model/GamingQueue.cs

@@ -1496,19 +1496,25 @@ namespace Milimoe.FunGame.Core.Model
 
                     // 造成伤害和受伤都可以获得能量。攻击者为全额，被攻击者为 actualDamage，护盾抵消的伤害不算
                     double ep = GetEP(damage, GameplayEquilibriumConstant.DamageGetEPFactor, GameplayEquilibriumConstant.DamageGetEPMax);
+                    if (ep > 0)
+                    {
                         effects = [.. actor.Effects.Where(e => e.IsInEffect)];
                         foreach (Effect effect in effects)
                         {
                             effect.AlterEPAfterDamage(actor, ref ep);
                         }
                         actor.EP += ep;
+                    }
                     ep = GetEP(actualDamage, GameplayEquilibriumConstant.TakenDamageGetEPFactor, GameplayEquilibriumConstant.TakenDamageGetEPMax);
+                    if (ep > 0)
+                    {
                         effects = [.. enemy.Effects.Where(e => e.IsInEffect)];
                         foreach (Effect effect in effects)
                         {
                             effect.AlterEPAfterGetDamage(enemy, ref ep);
                         }
                         enemy.EP += ep;
+                    }
 
                     // 统计伤害
                     CalculateCharacterDamageStatistics(actor, enemy, damage, isMagicDamage, actualDamage);

Service/JsonManager.cs

@@ -22,7 +22,7 @@ namespace Milimoe.FunGame.Core.Service
             Converters = { new DateTimeConverter(), new DataTableConverter(), new DataSetConverter(), new UserConverter(), new RoomConverter(),
                 new CharacterConverter(), new MagicResistanceConverter(), new EquipSlotConverter(), new SkillConverter(), new EffectConverter(), new ItemConverter(),
                 new InventoryConverter(), new NormalAttackConverter(), new ClubConverter(), new GoodsConverter(), new StoreConverter(),
-                new NovelOptionConverter(), new NovelNodeConverter(), new ShieldConverter()
+                new NovelOptionConverter(), new NovelNodeConverter(), new ShieldConverter(), new RoundRecordConverter()
             }
         };