技能调整

OshimaModules/Effects/PassiveEffects/宫监手标记.cs

@@ -90,7 +90,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.PassiveEffects
             }
         }
 
-        public override void AfterDeathCalculation(Character death, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
+        public override void AfterDeathCalculation(Character death, bool hasMaster, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
         {
             if (death == _targetCharacter)
             {

OshimaModules/Effects/PassiveEffects/愤怒.cs

@@ -64,7 +64,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.PassiveEffects
             return CharacterActionType.EndTurn;
         }
 
-        public override void AfterDeathCalculation(Character death, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
+        public override void AfterDeathCalculation(Character death, bool hasMaster, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
         {
             if (death == _targetCharacter)
             {

OshimaModules/Effects/PassiveEffects/时雨标记.cs

@@ -47,7 +47,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.PassiveEffects
             List<Character> teammates = GamingQueue.GetTeammates(character);
             if ((character == Source || teammates.Contains(Source)) && enemy.Effects.Any(e => e is 时雨标记))
             {
-                double bonus = damage;
+                double bonus = damage * 0.25;
                 WriteLine($"[ {character} ] 受到了{nameof(时雨标记)}的影响，伤害提高了 {bonus:0.##} 点！");
                 return bonus;
             }

OshimaModules/Effects/PassiveEffects/长期监视.cs

@@ -45,7 +45,7 @@ namespace Oshima.FunGame.OshimaModules.Effects.PassiveEffects
             return true;
         }
 
-        public override void AfterDeathCalculation(Character death, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
+        public override void AfterDeathCalculation(Character death, bool hasMaster, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
         {
             if (GamingQueue != null && killer != null && killer == _targetCharacter && Source != null && death != Source && GamingQueue.Queue.Contains(Source))
             {

OshimaModules/Skills/CHAOS/雇佣兵团.cs

@@ -1,4 +1,5 @@
 using Milimoe.FunGame.Core.Entity;
+using Milimoe.FunGame.Core.Interface.Entity;
 using Milimoe.FunGame.Core.Library.Common.Addon;
 using Milimoe.FunGame.Core.Library.Constant;
 using Oshima.FunGame.OshimaModules.Models;
@@ -31,13 +32,13 @@ namespace Oshima.FunGame.OshimaModules.Skills
             (雇佣兵团.Count < 最小数量 && Skill.CurrentCD > 0 ? $"（下次补充：{Skill.CurrentCD} {GameplayEquilibriumConstant.InGameTime}后）" : "");
 
         public List<雇佣兵> 雇佣兵团 { get; } = [];
-        public const int 最小数量 = 2;
+        public const int 最小数量 = 1;
         public const int 最大数量 = 5;
-        public const int 补充间隔 = 20;
+        public const int 补充间隔 = 30;
-        public const double 生命值比例 = 0.15;
+        public const double 生命值比例 = 0.1;
-        public const double 攻击力比例 = 0.4;
+        public const double 攻击力比例 = 0.6;
 
-        public override void AfterDeathCalculation(Character death, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
+        public override void AfterDeathCalculation(Character death, bool hasMaster, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
         {
             if (death is 雇佣兵 gyb)
             {
@@ -99,6 +100,14 @@ namespace Oshima.FunGame.OshimaModules.Skills
                 }
                 while (count < 最小数量);
             }
+            if (GamingQueue != null)
+            {
+                foreach (雇佣兵 gyb in 雇佣兵团.Where(g => !GamingQueue.Queue.Contains(g)))
+                {
+                    if (gyb.HP <= 0) gyb.HP = 1;
+                    添加到地图(character, gyb);
+                }
+            }
         }
 
         public int 新增雇佣兵(Character character)
@@ -124,6 +133,14 @@ namespace Oshima.FunGame.OshimaModules.Skills
             gyb.Recovery();
             雇佣兵团.Add(gyb);
 
+            添加到地图(character, gyb);
+            WriteLine($"[ {character} ] 召唤了{gyb}！");
+
+            return 雇佣兵团.Count;
+        }
+
+        public void 添加到地图(Character character, 雇佣兵 gyb)
+        {
             // 添加到地图/队列
             if (GamingQueue != null)
             {
@@ -137,15 +154,12 @@ namespace Oshima.FunGame.OshimaModules.Skills
                         if (target != null)
                         {
                             map.SetCharacterCurrentGrid(gyb, target);
-                            WriteLine($"[ {character} ] 召唤了雇佣兵 ({target.X}, {target.Y}, {target.Z}) !");
                         }
                     }
                 }
                 GamingQueue.Queue.Add(gyb);
                 GamingQueue.ChangeCharacterHardnessTime(gyb, 5, false, false);
             }
-
-            return 雇佣兵团.Count;
         }
     }
 }

OshimaModules/Skills/Neptune/海王星的野望.cs

@@ -42,7 +42,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
         public string 爆炸伤害描述 => $"对受到标记的目标造成伤害时将产生爆炸，爆炸将产生 {分裂伤害系数 * 100:0.##}% 分裂伤害。分裂伤害为全图索敌，会优先分裂至三个在持续时间内对{Skill.SkillOwner()}造成伤害最多的敌人，若没有符合条件的敌人或敌人数量不足，则将分裂至被标记的敌人，或至多三个随机的敌人。";
         public double 直接伤害 => 180 + 240 * (Skill.Level - 1);
         public double 持续时间 => 25 + 2 * (Skill.Level - 1);
-        public double 分裂伤害系数 => 0.25 + 0.05 * (Skill.Level - 1);
+        public double 分裂伤害系数 => 0.25 + 0.02 * (Skill.Level - 1);
         public double 力量提升 => 0.6 * (Skill.Character?.BaseSTR ?? 0);
         public Dictionary<Character, double> 敌人伤害统计 { get; set; } = [];
 

OshimaModules/Skills/Neptune/深海之戟.cs

@@ -49,7 +49,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
         }
         public override ImmuneType IgnoreImmune => ImmuneType.All;
 
-        public double 分裂百分比 => Math.Min(0.5, 0.3 + (Skill.Character?.Level ?? 0 + 0.00) / 200);
+        public double 分裂百分比 { get; set; } = 0.25;
         public 海王星的野望特效? 野望 { get; set; } = null;
 
         public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult)

OshimaModules/Skills/ShiYu/开宫.cs

@@ -26,8 +26,8 @@ namespace Oshima.FunGame.OshimaModules.Skills
     {
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
-        public override string Description => $"{Skill.SkillOwner()}在其首个可行动回合的开始阶段进入 [ {nameof(长期监视)} ] 状态，时刻监视着场上的一举一动。当场上有角色死亡时，如果该角色死于技能，则{Skill.SkillOwner()}复制该技能获得使用权，持续 3 回合，该复制品没有冷却时间；如果该角色死于普通攻击，则{Skill.SkillOwner()}的普通攻击将转为魔法伤害并且无视闪避，持续 3 回合。" +
+        public override string Description => $"{Skill.SkillOwner()}在其首个可行动回合的开始阶段进入 [ {nameof(长期监视)} ] 状态，时刻监视着场上的一举一动。当场上有角色死亡时，如果该角色死于技能，则{Skill.SkillOwner()}复制该技能获得使用权，持续 3 回合；如果该角色死于普通攻击，则{Skill.SkillOwner()}的普通攻击将转为魔法伤害并且无视闪避，持续 3 回合。" +
-            $"接着，{Skill.SkillOwner()}给予击杀者 [ {nameof(时雨标记)} ]。{Skill.SkillOwner()}在造成魔法伤害时，会基于伤害值的 50% 治疗持有标记的友方角色；{Skill.SkillOwner()}与所有持有标记的友方角色对持有标记的敌方角色的伤害加成提升 100%，并且使持有标记的敌方角色在持续时间内的回合开始阶段，有 65% 概率陷入混乱。" +
+            $"接着，{Skill.SkillOwner()}给予击杀者 [ {nameof(时雨标记)} ]。{Skill.SkillOwner()}在造成魔法伤害时，会基于伤害值的 15% 治疗持有标记的友方角色；{Skill.SkillOwner()}与所有持有标记的友方角色对持有标记的敌方角色的伤害加成提升 25%，并且使持有标记的敌方角色在持续时间内的回合开始阶段，有 65% 概率陷入混乱。" +
             $"混乱：进入行动受限状态，失控并随机行动，且在进行攻击指令时，可能会选取友方角色为目标。时雨标记持续 3 回合。";
 
         private bool 激活 = false;
@@ -49,16 +49,6 @@ namespace Oshima.FunGame.OshimaModules.Skills
             }
         }
 
-        public override void OnCharacterActionTaken(Character actor, DecisionPoints dp, CharacterActionType type)
-        {
-            Skill[] skills = [.. actor.Skills.Where(s => s.Values.TryGetValue(nameof(时雨标记), out object? value) && value.Equals(1))];
-            foreach (Skill skill in skills)
-            {
-                skill.CurrentCD = 0;
-                skill.Enable = true;
-            }
-        }
-
         public override void AfterDamageCalculation(Character character, Character enemy, double damage, double actualDamage, bool isNormalAttack, DamageType damageType, MagicType magicType, DamageResult damageResult)
         {
             if (character != Skill.Character || GamingQueue is null || damageType != DamageType.Magical || (damageResult != DamageResult.Normal && damageResult != DamageResult.Critical))

OshimaModules/Skills/ShiYu/放监.cs

@@ -63,16 +63,6 @@ namespace Oshima.FunGame.OshimaModules.Skills
             }
             return true;
         }
-
-        public override void OnCharacterActionTaken(Character actor, DecisionPoints dp, CharacterActionType type)
-        {
-            Skill[] skills = [.. actor.Skills.Where(s => s.Values.TryGetValue(nameof(时雨标记), out object? value) && value.Equals(1))];
-            foreach (Skill skill in skills)
-            {
-                skill.CurrentCD = 0;
-                skill.Enable = true;
-            }
-        }
     }
 
     public class 放监特效(Skill skill) : Effect(skill)
@@ -84,9 +74,9 @@ namespace Oshima.FunGame.OshimaModules.Skills
 
         public string 通用描述 => $"使场上现有的时雨标记变得不可驱散，并且刷新为持续 3 回合。并给予持有时雨标记的敌方角色 [ 宫监手标记 ]，宫监手标记不可驱散，持续 3 回合。{任务要求}";
         public string 任务要求 => $"持有宫监手标记的角色，必须完成以下两个任务以消除标记，否则将在标记消失时，每个未完成的任务给予角色基于{Skill.SkillOwner()} {核心属性系数 * 100:0.##}% 核心属性 + {攻击力系数 * 100:0.##}% 攻击力 [ {Skill.Character?.PrimaryAttributeValue * 核心属性系数 + Skill.Character?.ATK * 攻击力系数:0.##} ] 的真实伤害：\r\n" +
-            $"1. 使用 [ 普通攻击 ] 攻击一次队友，此伤害必定暴击且无视闪避；\r\n2. 对{Skill.SkillOwner()}释放一个指向性技能，{Skill.SkillOwner()}将此技能效果无效化并且复制该技能获得使用权持续 4 回合，该复制品没有冷却时间。\r\n注意：在宫监手标记被消除前，对{Skill.SkillOwner()}释放指向性技能始终会触发无效化和复制效果。杀死{Skill.SkillOwner()}可以终止所有放监任务。";
+            $"1. 使用 [ 普通攻击 ] 攻击一次队友，此伤害必定暴击且无视闪避；\r\n2. 对{Skill.SkillOwner()}释放一个指向性技能，{Skill.SkillOwner()}将此技能效果无效化并且复制该技能获得使用权持续 4 回合。\r\n注意：在宫监手标记被消除前，对{Skill.SkillOwner()}释放指向性技能始终会触发无效化和复制效果。杀死{Skill.SkillOwner()}可以终止所有放监任务。";
-        public double 核心属性系数 => 0.8 * Skill.Level;
+        public double 核心属性系数 => 0.7 * Skill.Level;
-        public double 攻击力系数 => 0.2 + 0.15 * (Skill.Level - 1);
+        public double 攻击力系数 => 0.2 + 0.10 * (Skill.Level - 1);
 
         public void 造成伤害(Character character, int count)
         {
@@ -112,17 +102,17 @@ namespace Oshima.FunGame.OshimaModules.Skills
                     {
                         e.DispelledType = DispelledType.CannotBeDispelled;
                         e.RemainDurationTurn = 3;
-                    }
+                        if (enemies.Contains(character))
-                    if (enemies.Contains(character))
-                    {
-                        Effect e2 = new 宫监手标记(Skill, caster, character, this)
                         {
-                            Durative = false,
+                            Effect e2 = new 宫监手标记(Skill, caster, character, this)
-                            DurationTurn = 3,
+                            {
-                            RemainDurationTurn = 3
+                                Durative = false,
-                        };
+                                DurationTurn = 3,
-                        character.Effects.Add(e2);
+                                RemainDurationTurn = 3
-                        e2.OnEffectGained(character);
+                            };
+                            character.Effects.Add(e2);
+                            e2.OnEffectGained(character);
+                        }
                     }
                 }
                 GamingQueue.LastRound.AddApplyEffects(caster, EffectType.Focusing);

OshimaModules/Skills/TheGodK/概念之骰.cs

@@ -77,7 +77,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             return 0;
         }
 
-        public override void AfterDeathCalculation(Character death, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
+        public override void AfterDeathCalculation(Character death, bool hasMaster, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
         {
             if (Skill.Character != null && death != Skill.Character && (killer == Skill.Character || assists.Contains(Skill.Character)) && Skill is 概念之骰 skill)
             {

OshimaModules/Skills/TheGodK/神之因果.cs

@@ -53,7 +53,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             }
         }
 
-        public override void AfterDeathCalculation(Character death, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
+        public override void AfterDeathCalculation(Character death, bool hasMaster, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
         {
             if (death == Skill.Character)
             {

OshimaModules/Skills/XReouni/八卦阵.cs

@@ -36,7 +36,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
         public double 奇数伤害提升 { get; set; } = 0.3;
         public double 奇数伤害减少 { get; set; } = 0.15;
 
-        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)
+        public override double AlterExpectedDamageBeforeCalculation(Character character, Character enemy, double damage, bool isNormalAttack, DamageType damageType, MagicType magicType, Dictionary<Effect, double> totalDamageBonus)
         {
             double bonus = 0;
             if (character != Skill.Character && enemy != Skill.Character)

OshimaModules/Skills/被动/电刑.cs

@@ -27,7 +27,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
         public override long Id => Skill.Id;
         public override string Name => Skill.Name;
         public override string Description => $"造成伤害时，标记目标 25 {GameplayEquilibriumConstant.InGameTime}并叠加 1 层数，当目标身上的电刑标记达到 3 层时，此次伤害提升 {伤害百分比 * 100:0.##}%。";
-        private double 伤害百分比 => Skill.Character != null ? 0.3 + Skill.Character.Level * 0.005 : 0;
+        private double 伤害百分比 => Skill.Character != null ? 0.2 + Skill.Character.Level * 0.004 : 0;
 
         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)
         {

OshimaModules/Skills/被动/黑暗收割.cs

@@ -53,7 +53,7 @@ namespace Oshima.FunGame.OshimaModules.Skills
             }
         }
 
-        public override void AfterDeathCalculation(Character death, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
+        public override void AfterDeathCalculation(Character death, bool hasMaster, Character? killer, Dictionary<Character, int> continuousKilling, Dictionary<Character, int> earnedMoney, Character[] assists)
         {
             if (death == Skill.Character && 当前灵魂数量 > 0)
             {

OshimaServers/Service/FunGameSimulation.cs

@@ -23,6 +23,7 @@ namespace Oshima.FunGame.OshimaServers.Service
         public static GameMap Map { get; } = new FastAutoMap();
         public static bool IsRuning { get; set; } = false;
         public static bool IsWeb { get; set; } = false;
+        public static bool IsDebug { get; set; } = false;
         public static bool PrintOut { get; set; } = false;
         public static bool DeathMatchRoundDetail { get; set; } = false;
         public static string Msg { get; set; } = "";
@@ -204,6 +205,7 @@ namespace Oshima.FunGame.OshimaServers.Service
                     if (PrintOut) characters.ForEach(c => Console.WriteLine(c.GetInfo()));
 
                     // 初始化队列，准备开始游戏
+                    actionQueue.IsDebug = IsDebug;
                     actionQueue.InitActionQueue();
                     actionQueue.SetCharactersToAIControl(false, characters);
                     if (PrintOut) Console.WriteLine();