feat(battle-engine): M1 auto-copy closure (782 battle-logic files)

Compile-driven bulk-copy loop (tools/engine-port/m1_copy_loop.py) pulled the precise reference closure of the battle-core roots, stopping at the classify god-object/View-VFX-UI boundary. 782 files; no re-explosion (M0 had estimated ~order 1000). Residual frontier = 52 shim-classified + 80 external (Unity/BCL) types to author next.

SVSim.BattleEngine/Engine/Skill_attack_count.cs

@@ -0,0 +1,128 @@
+using System.Collections.Generic;
+using System.Linq;
+using Wizard.Battle.UI;
+using Wizard.Battle.View.Vfx;
+
+public class Skill_attack_count : SkillBase
+{
+	public class CardPair
+	{
+		public BattleCardBase card { get; private set; }
+
+		public int Sub { get; private set; }
+
+		public BuffInfo buffInfo { get; private set; }
+
+		public CardPair(BattleCardBase card, int sub, BuffInfo buffInfo)
+		{
+			this.card = card;
+			Sub = sub;
+			this.buffInfo = buffInfo;
+		}
+	}
+
+	private const int NULL_COUNT = -1;
+
+	private const string ATTACK_COUNT_RECOVERY = "recovery";
+
+	public bool IsRecovery => base.OptionValue.GetString(SkillFilterCreator.ContentKeyword.attack_count) == "recovery";
+
+	public Skill_attack_count(SkillParameter skillPrm, string option)
+		: base(skillPrm, option)
+	{
+	}
+
+	public int GetSetAttackCount()
+	{
+		if (!IsRecovery)
+		{
+			return base.OptionValue.GetInt(SkillFilterCreator.ContentKeyword.attack_count, -1);
+		}
+		return -1;
+	}
+
+	private int GetAddAttackCount()
+	{
+		return base.OptionValue.GetInt(SkillFilterCreator.ContentKeyword.add_attack_count, -1);
+	}
+
+	public bool IsSetAttackCount()
+	{
+		return GetSetAttackCount() != -1;
+	}
+
+	public bool IsAddAttackCount()
+	{
+		return GetAddAttackCount() != -1;
+	}
+
+	public override VfxWithLoading Start(CallParameter parameter)
+	{
+		bool isRecovery = IsRecovery;
+		int num = (IsAddAttackCount() ? GetAddAttackCount() : GetSetAttackCount());
+		VfxWithLoadingSequential vfxWithLoadingSequential = VfxWithLoadingSequential.Create();
+		CallOnChangeMaxAttackableCount(parameter.targetCards.ToList());
+		foreach (BattleCardBase targetCard in parameter.targetCards)
+		{
+			BattleCardBase battleCardBase = targetCard;
+			if (num != -1)
+			{
+				BuffInfo buffInfo = (IsBattleLog ? AddBuffInfoIfNeeded(targetCard) : null);
+				int maxAttackableCount = targetCard.MaxAttackableCount;
+				int intValue = (IsAddAttackCount() ? num : (num - maxAttackableCount));
+				vfxWithLoadingSequential.RegisterToMainVfx(battleCardBase.SkillApplyInformation.GiveAttackCount(this, num));
+				BuffInfoContainer buffInfoContainer = new BuffInfoContainer(battleCardBase, buffInfo, intValue, "", null, 0L);
+				SetOnLoseEvent(battleCardBase, buffInfo, buffInfoContainer);
+				base.buffInfoContainer.Add(buffInfoContainer);
+			}
+			if (isRecovery)
+			{
+				vfxWithLoadingSequential.RegisterToMainVfx(battleCardBase.RecoveryAttackCount());
+			}
+		}
+		vfxWithLoadingSequential.RegisterVfxWithLoading(CreateSkillEffect(base.SkillPrm.resourceMgr, parameter.targetCards));
+		if (IsBattleLog)
+		{
+			if (isRecovery)
+			{
+				BattleLogManager.GetInstance().AddLogSkillAttackCountRecovery(parameter.targetCards.ToList(), this);
+			}
+			else
+			{
+				BattleLogManager.GetInstance().AddLogSkillGain(parameter.targetCards.ToList(), this, SkillGainType.AttackCount, num);
+			}
+		}
+		return vfxWithLoadingSequential;
+	}
+
+	public override VfxWithLoading Stop(SkillProcessor skillProcessor)
+	{
+		ParallelVfxPlayer parallelVfxPlayer = ParallelVfxPlayer.Create();
+		parallelVfxPlayer.Register(base.Stop(skillProcessor));
+		List<BattleCardBase> list = new List<BattleCardBase>();
+		foreach (BuffInfoContainer item in buffInfoContainer)
+		{
+			list.Add(item._targetCard);
+			item._targetCard.RemoveBuffInfo(item._buffInfo);
+			parallelVfxPlayer.Register(item._targetCard.SkillApplyInformation.DepriveAttackCount(this));
+		}
+		CallOnUpdateSkillEffect(list, updateAttackEffect: true);
+		buffInfoContainer.Clear();
+		return VfxWithLoading.Create(parallelVfxPlayer);
+	}
+
+	public override void SetOnLoseEvent(BattleCardBase targetCard, BuffInfo buff, BuffInfoContainer container)
+	{
+		targetCard.OnLoseSkillOneTime += delegate(SkillBase loseSkill, SkillProcessor skillProcessor, BattleCardBase card)
+		{
+			card.RemoveBuffInfo(buff);
+			buffInfoContainer.Remove(container);
+			card.SkillApplyInformation.ForceDepriveAttackCount();
+			return NullVfx.GetInstance();
+		};
+	}
+
+	protected virtual void CallOnChangeMaxAttackableCount(List<BattleCardBase> targetCards)
+	{
+	}
+}